ESLint autofixes

gulpfile.js

@@ -1,7 +1,7 @@
 var gulp = require("gulp");
 var presetES2015 = require("@joepie91/gulp-preset-es2015");
 
-var source = ["src/**/*.js"]
+var source = ["src/**/*.js"];
 
 gulp.task('babel', function() {
 	return gulp.src(source)

src/errors/check-constraint-violation.js

@@ -12,48 +12,48 @@ let CheckConstraintViolationError = create("CheckConstraintViolationError", { in
 let messageRegex = /^(.+) - new row for relation "([^"]+)" violates check constraint "([^"]+)"$/;
 
 module.exports = {
-    error: CheckConstraintViolationError,
-    errorName: "CheckConstraintViolationError",
-    check: function checkType(error) {
-        return (
-            // PostgreSQL (via `pg`):
-            (error.length != null && error.file != null && error.line != null && error.routine != null && error.code === "23514")
-        )
-    },
-    convert: function convertError(error) {
-        let messageMatch = messageRegex.exec(error.message);
-
-        if (messageMatch == null) {
-            throw new Error("Encountered unknown error format");
-        }
-
-        let [_, query, table, constraint] = messageMatch;
-
-        let columns = getColumns(query);
-
-        let offendingColumn, message;
-
-        if (columns != null) {
-            /* This is the naming convention that Knex uses for .enum() in PostgreSQL */
-            offendingColumn = columns.find(column => {
-                return error.constraint === `${error.table}_${column}_check`
-            });
-
-            message = `Value violates the '${error.constraint}' constraint for the '${offendingColumn}' column in the '${error.table}' table`;
-        } else {
-            message = `Value violates the '${error.constraint}' constraint for the '${error.table}' table`;
-        }
-
-        return new CheckConstraintViolationError(message, {
-            originalError: error,
-            pgCode: error.code,
-            code: pgErrorCodes[error.code],
-            query: query,
-            schema: error.schema,
-            table: error.table,
-            column: offendingColumn,
-            constraint: error.constraint,
-            values: getValues(error.detail)
-        });
-    }
+	error: CheckConstraintViolationError,
+	errorName: "CheckConstraintViolationError",
+	check: function checkType(error) {
+		return (
+		// PostgreSQL (via `pg`):
+			(error.length != null && error.file != null && error.line != null && error.routine != null && error.code === "23514")
+		);
+	},
+	convert: function convertError(error) {
+		let messageMatch = messageRegex.exec(error.message);
+
+		if (messageMatch == null) {
+			throw new Error("Encountered unknown error format");
+		}
+
+		let [_, query, table, constraint] = messageMatch;
+
+		let columns = getColumns(query);
+
+		let offendingColumn, message;
+
+		if (columns != null) {
+			/* This is the naming convention that Knex uses for .enum() in PostgreSQL */
+			offendingColumn = columns.find(column => {
+				return error.constraint === `${error.table}_${column}_check`;
+			});
+
+			message = `Value violates the '${error.constraint}' constraint for the '${offendingColumn}' column in the '${error.table}' table`;
+		} else {
+			message = `Value violates the '${error.constraint}' constraint for the '${error.table}' table`;
+		}
+
+		return new CheckConstraintViolationError(message, {
+			originalError: error,
+			pgCode: error.code,
+			code: pgErrorCodes[error.code],
+			query: query,
+			schema: error.schema,
+			table: error.table,
+			column: offendingColumn,
+			constraint: error.constraint,
+			values: getValues(error.detail)
+		});
+	}
 };

src/errors/enum.js

@@ -11,40 +11,40 @@ let EnumError = create("EnumError", { inheritsFrom: DatabaseError });
 let messageRegex = /^(.+) - invalid input value for enum ([^:]+): "([^"]+)"$/;
 
 module.exports = {
-    error: EnumError,
-    errorName: "EnumError",
-    check: function checkType(error) {
-        return (
-            // PostgreSQL (via `pg`):
-            (error.length != null && error.file != null && error.line != null && error.routine != null && error.code === "22P02" && error.message.includes("invalid input value for enum"))
-        )
-    },
-    convert: function convertError(error) {
-        let messageMatch = messageRegex.exec(error.message);
-
-        if (messageMatch == null) {
-            throw new Error("Encountered unknown error format");
-        }
-
-        let [_, query, enumType, value] = messageMatch;
-        let table = getTable(query);
-
-        let message;
-
-        if (table != null) {
-            message = `Value '${value}' is not an allowed value for the ENUM type '${enumType}' (in table '${table}')`;
-        } else {
-            message = `Value '${value}' is not an allowed value for the ENUM type '${enumType}'`;
-        }
-
-        return new EnumError(message, {
-            originalError: error,
-            pgCode: error.code,
-            code: pgErrorCodes[error.code],
-            query: query,
-            table: table,
-            enumType: enumType,
-            value: value
-        });
-    }
+	error: EnumError,
+	errorName: "EnumError",
+	check: function checkType(error) {
+		return (
+		// PostgreSQL (via `pg`):
+			(error.length != null && error.file != null && error.line != null && error.routine != null && error.code === "22P02" && error.message.includes("invalid input value for enum"))
+		);
+	},
+	convert: function convertError(error) {
+		let messageMatch = messageRegex.exec(error.message);
+
+		if (messageMatch == null) {
+			throw new Error("Encountered unknown error format");
+		}
+
+		let [_, query, enumType, value] = messageMatch;
+		let table = getTable(query);
+
+		let message;
+
+		if (table != null) {
+			message = `Value '${value}' is not an allowed value for the ENUM type '${enumType}' (in table '${table}')`;
+		} else {
+			message = `Value '${value}' is not an allowed value for the ENUM type '${enumType}'`;
+		}
+
+		return new EnumError(message, {
+			originalError: error,
+			pgCode: error.code,
+			code: pgErrorCodes[error.code],
+			query: query,
+			table: table,
+			enumType: enumType,
+			value: value
+		});
+	}
 };

src/errors/foreign-key-constraint-violation.js

@@ -9,27 +9,27 @@ let ForeignKeyConstraintViolationError = create("ForeignKeyConstraintViolationEr
 let detailsRegex = /^Key \(([^\)]+)\)=\(([^\)]+)\) is not present in table "([^"]+)"\.$/;
 
 module.exports = {
-    error: ForeignKeyConstraintViolationError,
-    errorName: "ForeignKeyConstraintViolationError",
-    check: function checkType(error) {
-        return (
-            // PostgreSQL (via `pg`):
-            (error.length != null && error.file != null && error.line != null && error.routine != null && error.code === "23503")
-        )
-    },
-    convert: function convertError(error) {
-        let [_, column, value, foreignTable] = detailsRegex.exec(error.detail);
+	error: ForeignKeyConstraintViolationError,
+	errorName: "ForeignKeyConstraintViolationError",
+	check: function checkType(error) {
+		return (
+		// PostgreSQL (via `pg`):
+			(error.length != null && error.file != null && error.line != null && error.routine != null && error.code === "23503")
+		);
+	},
+	convert: function convertError(error) {
+		let [_, column, value, foreignTable] = detailsRegex.exec(error.detail);
 
-        return new ForeignKeyConstraintViolationError(`Value for column '${column}' in table '${error.table}' refers to a non-existent key '${value}' in table '${foreignTable}'`, {
-            originalError: error,
-            pgCode: error.code,
-            code: pgErrorCodes[error.code],
-            schema: error.schema,
-            table: error.table,
-            foreignTable: foreignTable,
-            column: column,
-            value: value,
-            constraint: error.constraint
-        });
-    }
+		return new ForeignKeyConstraintViolationError(`Value for column '${column}' in table '${error.table}' refers to a non-existent key '${value}' in table '${foreignTable}'`, {
+			originalError: error,
+			pgCode: error.code,
+			code: pgErrorCodes[error.code],
+			schema: error.schema,
+			table: error.table,
+			foreignTable: foreignTable,
+			column: column,
+			value: value,
+			constraint: error.constraint
+		});
+	}
 };

src/errors/invalid-type.js

@@ -12,42 +12,42 @@ let InvalidTypeError = create("InvalidTypeError", { inheritsFrom: DatabaseError
 let messageRegex = /^(?:(.+) - )?invalid input syntax for(?: type)? ([^:]+)(?:: "(.+)")?$/;
 
 module.exports = {
-    error: InvalidTypeError,
-    errorName: "InvalidTypeError",
-    check: function checkType(error) {
-        return (
-            // PostgreSQL (via `pg`):
-            (error.length != null && error.file != null && error.line != null && error.routine != null && error.code === "22P02" && error.message.includes("invalid input syntax for"))
-        )
-    },
-    convert: function convertError(error) {
-        let messageMatch = messageRegex.exec(error.message);
-
-        if (messageMatch == null) {
-            /* TODO: Update other error parsing modules to display the original error message here as well. */
-            throw new Error(`Encountered unknown error format for error message: ${error.message}`);
-        }
-
-        let [_, query, expectedType, value] = messageMatch;
-        let table = getTable(query);
-
-        let message;
-
-        /* TODO: `value` can be undefined! */
-        if (table != null) {
-            message = `Value <${value}> is of the wrong type for a '${expectedType}'-type column (in table '${table}')`;
-        } else {
-            message = `Value <${value}> is of the wrong type for a '${expectedType}'-type column`;
-        }
-
-        return new InvalidTypeError(message, {
-            originalError: error,
-            pgCode: error.code,
-            code: pgErrorCodes[error.code],
-            query: query,
-            table: table,
-            expectedType: expectedType,
-            value: value,
-        });
-    }
+	error: InvalidTypeError,
+	errorName: "InvalidTypeError",
+	check: function checkType(error) {
+		return (
+		// PostgreSQL (via `pg`):
+			(error.length != null && error.file != null && error.line != null && error.routine != null && error.code === "22P02" && error.message.includes("invalid input syntax for"))
+		);
+	},
+	convert: function convertError(error) {
+		let messageMatch = messageRegex.exec(error.message);
+
+		if (messageMatch == null) {
+			/* TODO: Update other error parsing modules to display the original error message here as well. */
+			throw new Error(`Encountered unknown error format for error message: ${error.message}`);
+		}
+
+		let [_, query, expectedType, value] = messageMatch;
+		let table = getTable(query);
+
+		let message;
+
+		/* TODO: `value` can be undefined! */
+		if (table != null) {
+			message = `Value <${value}> is of the wrong type for a '${expectedType}'-type column (in table '${table}')`;
+		} else {
+			message = `Value <${value}> is of the wrong type for a '${expectedType}'-type column`;
+		}
+
+		return new InvalidTypeError(message, {
+			originalError: error,
+			pgCode: error.code,
+			code: pgErrorCodes[error.code],
+			query: query,
+			table: table,
+			expectedType: expectedType,
+			value: value,
+		});
+	}
 };

src/errors/not-null-constraint-violation.js

@@ -11,26 +11,26 @@ let NotNullConstraintViolationError = create(DatabaseError, "NotNullConstraintVi
 let messageRegex = /^(.+) - null value in column "([^"]+)" violates not-null constraint$/;
 
 module.exports = {
-    error: NotNullConstraintViolationError,
-    errorName: "NotNullConstraintViolationError",
-    check: function checkType(error) {
-        return (
-            // PostgreSQL (via `pg`):
-            (error.length != null && error.file != null && error.line != null && error.routine != null && error.code === "23502")
-        )
-    },
-    convert: function convertError(error) {
-        let [_, query, column] = messageRegex.exec(error.message);
+	error: NotNullConstraintViolationError,
+	errorName: "NotNullConstraintViolationError",
+	check: function checkType(error) {
+		return (
+		// PostgreSQL (via `pg`):
+			(error.length != null && error.file != null && error.line != null && error.routine != null && error.code === "23502")
+		);
+	},
+	convert: function convertError(error) {
+		let [_, query, column] = messageRegex.exec(error.message);
 
-        return new NotNullConstraintViolationError(`Missing required value for column '${error.column}' in table '${error.table}'`, {
-            originalError: error,
-            pgCode: error.code,
-            code: pgErrorCodes[error.code],
-            schema: error.schema,
-            table: error.table,
-            column: error.column,
-            values: getValues(error.detail),
-            query: query
-        });
-    }
+		return new NotNullConstraintViolationError(`Missing required value for column '${error.column}' in table '${error.table}'`, {
+			originalError: error,
+			pgCode: error.code,
+			code: pgErrorCodes[error.code],
+			schema: error.schema,
+			table: error.table,
+			column: error.column,
+			values: getValues(error.detail),
+			query: query
+		});
+	}
 };

src/errors/undefined-column.js

@@ -11,39 +11,39 @@ let UndefinedColumnError = create("UndefinedColumnError", { inheritsFrom: Databa
 let messageRegex = /^(.+) - column "([^"]+)" (?:of relation "([^"]+)" )?does not exist$/;
 
 module.exports = {
-    error: UndefinedColumnError,
-    errorName: "UndefinedColumnError",
-    check: function checkType(error) {
-        return (
-            // PostgreSQL (via `pg`):
-            (error.length != null && error.file != null && error.line != null && error.routine != null && error.code === "42703")
-        )
-    },
-    convert: function convertError(error) {
-        let messageMatch = messageRegex.exec(error.message);
-
-        if (messageMatch == null) {
-            throw new Error("Encountered unknown error format");
-        }
-
-        let [_, query, column, table] = messageMatch;
-
-        let errorMessage;
-
-        if (table != null) {
-            errorMessage = `The '${column}' column does not exist in the '${table}' table`;
-        } else {
-            /* TODO: Maybe try to extract this from the query... somehow? */
-            errorMessage = `The '${column}' column does not exist in (unknown table)`;
-        }
-
-        return new UndefinedColumnError(errorMessage, {
-            originalError: error,
-            pgCode: error.code,
-            code: pgErrorCodes[error.code],
-            query: query,
-            table: table,
-            column: column,
-        });
-    }
+	error: UndefinedColumnError,
+	errorName: "UndefinedColumnError",
+	check: function checkType(error) {
+		return (
+		// PostgreSQL (via `pg`):
+			(error.length != null && error.file != null && error.line != null && error.routine != null && error.code === "42703")
+		);
+	},
+	convert: function convertError(error) {
+		let messageMatch = messageRegex.exec(error.message);
+
+		if (messageMatch == null) {
+			throw new Error("Encountered unknown error format");
+		}
+
+		let [_, query, column, table] = messageMatch;
+
+		let errorMessage;
+
+		if (table != null) {
+			errorMessage = `The '${column}' column does not exist in the '${table}' table`;
+		} else {
+			/* TODO: Maybe try to extract this from the query... somehow? */
+			errorMessage = `The '${column}' column does not exist in (unknown table)`;
+		}
+
+		return new UndefinedColumnError(errorMessage, {
+			originalError: error,
+			pgCode: error.code,
+			code: pgErrorCodes[error.code],
+			query: query,
+			table: table,
+			column: column,
+		});
+	}
 };

src/errors/unique-constraint-violation.js

@@ -10,49 +10,49 @@ let UniqueConstraintViolationError = create("UniqueConstraintViolationError", {
 let detailsRegex = /Key \(([^\)]+)\)=\(([^\)]+)\) already exists\./;
 
 module.exports = {
-    error: UniqueConstraintViolationError,
-    errorName: "UniqueConstraintViolationError",
-    check: function checkType(error) {
-        return (
-            // PostgreSQL (via `pg`):
-            (error.length != null && error.file != null && error.line != null && error.routine != null && error.code === "23505")
-        )
-    },
-    convert: function convertError(error) {
-        let [_, columnValue, valueValue] = detailsRegex.exec(error.detail);
-
-        let column, columns, value, values, messageColumn, messageValue, isComposite;
-
-        if (columnValue.includes(",")) {
-            columns = splitValues(columnValue);
-            messageColumn = `columns [${columns.map(column => `'${column}'`).join(", ")}]`;
-            isComposite = true;
-        } else {
-            column = columnValue;
-            messageColumn = `column '${column}'`;
-            isComposite = false;
-        }
-
-        if (valueValue.includes(",")) {
-            values = splitValues(valueValue);
-            messageValue = `Values [${values.map(value => `'${value}'`).join(", ")}] already exist`;
-        } else {
-            value = valueValue;
-            messageValue = `Value '${value}' already exists`;
-        }
-
-        return new UniqueConstraintViolationError(`${messageValue} for ${messageColumn} in table '${error.table}'`, {
-            originalError: error,
-            pgCode: error.code,
-            code: pgErrorCodes[error.code],
-            schema: error.schema,
-            table: error.table,
-            column: column,
-            columns: columns,
-            value: value,
-            values: values,
-            isComposite: isComposite,
-            constraint: error.constraint
-        });
-    }
+	error: UniqueConstraintViolationError,
+	errorName: "UniqueConstraintViolationError",
+	check: function checkType(error) {
+		return (
+		// PostgreSQL (via `pg`):
+			(error.length != null && error.file != null && error.line != null && error.routine != null && error.code === "23505")
+		);
+	},
+	convert: function convertError(error) {
+		let [_, columnValue, valueValue] = detailsRegex.exec(error.detail);
+
+		let column, columns, value, values, messageColumn, messageValue, isComposite;
+
+		if (columnValue.includes(",")) {
+			columns = splitValues(columnValue);
+			messageColumn = `columns [${columns.map(column => `'${column}'`).join(", ")}]`;
+			isComposite = true;
+		} else {
+			column = columnValue;
+			messageColumn = `column '${column}'`;
+			isComposite = false;
+		}
+
+		if (valueValue.includes(",")) {
+			values = splitValues(valueValue);
+			messageValue = `Values [${values.map(value => `'${value}'`).join(", ")}] already exist`;
+		} else {
+			value = valueValue;
+			messageValue = `Value '${value}' already exists`;
+		}
+
+		return new UniqueConstraintViolationError(`${messageValue} for ${messageColumn} in table '${error.table}'`, {
+			originalError: error,
+			pgCode: error.code,
+			code: pgErrorCodes[error.code],
+			schema: error.schema,
+			table: error.table,
+			column: column,
+			columns: columns,
+			value: value,
+			values: values,
+			isComposite: isComposite,
+			constraint: error.constraint
+		});
+	}
 };

src/get-columns.js

@@ -5,15 +5,15 @@ let updateRegex = /^update "[^"]+" set (.+) where/;
 let updateColumnRegex = /^"([^"]+)"/;
 
 module.exports = function getColumns(query) {
-    let match, columns;
+	let match, columns;
 
-    if (match = insertRegex.exec(query)) {
-        return match[1].split(",").map((columnName) => {
-            return columnName.trim().slice(1, -1)
-        });
-    } else if (match = updateRegex.exec(query)) {
-        return match[1].split(",").map((statement) => {
-            return updateColumnRegex.exec(statement.trim())[1];
-        });
-    }
+	if (match = insertRegex.exec(query)) {
+		return match[1].split(",").map((columnName) => {
+			return columnName.trim().slice(1, -1);
+		});
+	} else if (match = updateRegex.exec(query)) {
+		return match[1].split(",").map((statement) => {
+			return updateColumnRegex.exec(statement.trim())[1];
+		});
+	}
 };

src/get-table.js

@@ -4,11 +4,11 @@ let insertRegex = /^insert into "([^"]+)"/;
 let updateRegex = /^update "([^"]+)"/;
 
 module.exports = function getTable(query) {
-    let match;
+	let match;
 
-    if (match = insertRegex.exec(query)) {
-        return match[1];
-    } else if (match = updateRegex.exec(query)) {
-        return match[1];
-    }
+	if (match = insertRegex.exec(query)) {
+		return match[1];
+	} else if (match = updateRegex.exec(query)) {
+		return match[1];
+	}
 };

src/get-values.js

@@ -3,13 +3,13 @@
 let detailsRegex = /^Failing row contains \((.+)\).$/;
 
 module.exports = function getValues(detail) {
-    let detailsMatch = detailsRegex.exec(detail);
+	let detailsMatch = detailsRegex.exec(detail);
 
-    if (detailsMatch == null) {
-        throw new Error("Could not determine values for query");
-    }
+	if (detailsMatch == null) {
+		throw new Error("Could not determine values for query");
+	}
 
-    let [_, valueList] = detailsMatch;
+	let [_, valueList] = detailsMatch;
 
-    return valueList.split(", ");
+	return valueList.split(", ");
 };

src/index.js

@@ -15,13 +15,13 @@ let handlers = [
 	require("./errors/invalid-type"),
 	require("./errors/undefined-column"),
 	require("./errors/not-null-constraint-violation"),
-]
+];
 
 function convertError(error) {
 	let handler = handlers.find(handler => handler.check(error));
 
 	if (handler != null) {
-		debug(`Converting error with message: ${error.message}`)
+		debug(`Converting error with message: ${error.message}`);
 		return handler.convert(error);
 	} else {
 		throw new UnknownError("The specified error is not of a recognized type");
@@ -51,4 +51,4 @@ module.exports = Object.assign({
 	rethrow: rethrowBetterError,
 	UnknownError: UnknownError,
 	DatabaseError: DatabaseError
-}, errorTypes)
+}, errorTypes);

test/create-tables/check-constraint-violation.js

@@ -3,14 +3,14 @@
 const Promise = require("bluebird");
 
 module.exports = {
-    up: function createCheckConstraintViolationTable(knex, errorHandler) {
-        return knex.schema.createTable("check_constraint_violation", (table) => {
-            table.increments("id");
-            table.enum("number_value", ["one", "two", "three"]);
-            table.text("name");
-        }).catch(errorHandler);
-    },
-    down: function dropCheckConstraintViolationTable(knex, errorHandler) {
-        return knex.schema.dropTable("check_constraint_violation").catch(errorHandler);
-    }
+	up: function createCheckConstraintViolationTable(knex, errorHandler) {
+		return knex.schema.createTable("check_constraint_violation", (table) => {
+			table.increments("id");
+			table.enum("number_value", ["one", "two", "three"]);
+			table.text("name");
+		}).catch(errorHandler);
+	},
+	down: function dropCheckConstraintViolationTable(knex, errorHandler) {
+		return knex.schema.dropTable("check_constraint_violation").catch(errorHandler);
+	}
 };

test/create-tables/composite-unique-constraint-violation.js

@@ -1,16 +1,16 @@
 'use strict';
 
 module.exports = {
-    up: function createUniqueConstraintViolationTable(knex, errorHandler) {
-        return knex.schema.createTable("composite_unique_constraint_violation", (table) => {
-            table.increments("id");
-            table.text("email");
-            table.text("username");
-            table.text("name");
-            table.unique(["email", "username"]);
-        }).catch(errorHandler);
-    },
-    down: function dropUniqueConstraintViolationTable(knex, errorHandler) {
-        return knex.schema.dropTable("composite_unique_constraint_violation").catch(errorHandler);
-    }
+	up: function createUniqueConstraintViolationTable(knex, errorHandler) {
+		return knex.schema.createTable("composite_unique_constraint_violation", (table) => {
+			table.increments("id");
+			table.text("email");
+			table.text("username");
+			table.text("name");
+			table.unique(["email", "username"]);
+		}).catch(errorHandler);
+	},
+	down: function dropUniqueConstraintViolationTable(knex, errorHandler) {
+		return knex.schema.dropTable("composite_unique_constraint_violation").catch(errorHandler);
+	}
 };

test/create-tables/enum.js

@@ -3,22 +3,22 @@
 const Promise = require("bluebird");
 
 module.exports = {
-    up: function createEnumViolationTable(knex, errorHandler) {
-        return Promise.try(() => {
-            return knex.raw("CREATE TYPE number AS ENUM ('one', 'two', 'three')").catch(errorHandler);
-        }).then(() => {
-            return knex.schema.createTable("enum_violation", (table) => {
-                table.increments("id");
-                table.specificType("number_value", "number");
-                table.text("name");
-            }).catch(errorHandler);
-        });
-    },
-    down: function dropEnumViolationTable(knex, errorHandler) {
-        return Promise.try(() => {
-            return knex.schema.dropTable("enum_violation").catch(errorHandler);
-        }).then(() => {
-            return knex.raw("DROP TYPE number").catch(errorHandler);
-        });
-    }
+	up: function createEnumViolationTable(knex, errorHandler) {
+		return Promise.try(() => {
+			return knex.raw("CREATE TYPE number AS ENUM ('one', 'two', 'three')").catch(errorHandler);
+		}).then(() => {
+			return knex.schema.createTable("enum_violation", (table) => {
+				table.increments("id");
+				table.specificType("number_value", "number");
+				table.text("name");
+			}).catch(errorHandler);
+		});
+	},
+	down: function dropEnumViolationTable(knex, errorHandler) {
+		return Promise.try(() => {
+			return knex.schema.dropTable("enum_violation").catch(errorHandler);
+		}).then(() => {
+			return knex.raw("DROP TYPE number").catch(errorHandler);
+		});
+	}
 };

test/create-tables/foreign-key-constraint-violation.js

@@ -3,26 +3,26 @@
 const Promise = require("bluebird");
 
 module.exports = {
-    up: function createForeignKeyConstraintViolationTable(knex, errorHandler) {
-        return Promise.try(() => {
-            return knex.schema.createTable("foreign_key_constraint_users", (table) => {
-                table.increments("id");
-                table.text("username");
-                table.text("name");
-            }).catch(errorHandler);
-        }).then(() => {
-            return knex.schema.createTable("foreign_key_constraint_posts", (table) => {
-                table.increments("id");
-                table.integer("user_id").references("id").inTable("foreign_key_constraint_users");
-                table.text("body");
-            }).catch(errorHandler);
-        });
-    },
-    down: function dropForeignKeyConstraintViolationTable(knex, errorHandler) {
-        return Promise.try(() => {
-            return knex.schema.dropTable("foreign_key_constraint_posts").catch(errorHandler);
-        }).then(() => {
-            return knex.schema.dropTable("foreign_key_constraint_users").catch(errorHandler);
-        });
-    }
+	up: function createForeignKeyConstraintViolationTable(knex, errorHandler) {
+		return Promise.try(() => {
+			return knex.schema.createTable("foreign_key_constraint_users", (table) => {
+				table.increments("id");
+				table.text("username");
+				table.text("name");
+			}).catch(errorHandler);
+		}).then(() => {
+			return knex.schema.createTable("foreign_key_constraint_posts", (table) => {
+				table.increments("id");
+				table.integer("user_id").references("id").inTable("foreign_key_constraint_users");
+				table.text("body");
+			}).catch(errorHandler);
+		});
+	},
+	down: function dropForeignKeyConstraintViolationTable(knex, errorHandler) {
+		return Promise.try(() => {
+			return knex.schema.dropTable("foreign_key_constraint_posts").catch(errorHandler);
+		}).then(() => {
+			return knex.schema.dropTable("foreign_key_constraint_users").catch(errorHandler);
+		});
+	}
 };

test/create-tables/index.js

@@ -3,40 +3,40 @@
 const Promise = require("bluebird");
 
 let tables = [
-    require("./unique-constraint-violation"),
-    require("./composite-unique-constraint-violation"),
-    require("./check-constraint-violation"),
-    require("./foreign-key-constraint-violation"),
-    require("./enum"),
-    require("./invalid-type"),
-    require("./not-null-constraint-violation")
+	require("./unique-constraint-violation"),
+	require("./composite-unique-constraint-violation"),
+	require("./check-constraint-violation"),
+	require("./foreign-key-constraint-violation"),
+	require("./enum"),
+	require("./invalid-type"),
+	require("./not-null-constraint-violation")
 ];
 
 let noop = function noop(err) {
-    // Do nothing.
-}
+	// Do nothing.
+};
 
 let rethrow = function rethrowError(err) {
-    throw err;
-}
+	throw err;
+};
 
 module.exports = {
-    up: function createTables(knex) {
-        return Promise.map(tables, (table) => {
-            return table.up(knex, rethrow);
-        });
-    },
-    down: function dropTables(knex, ignoreErrors) {
-        let errorHandler;
+	up: function createTables(knex) {
+		return Promise.map(tables, (table) => {
+			return table.up(knex, rethrow);
+		});
+	},
+	down: function dropTables(knex, ignoreErrors) {
+		let errorHandler;
 
-        if (ignoreErrors) {
-            errorHandler = noop;
-        } else {
-            errorHandler = rethrow;
-        }
+		if (ignoreErrors) {
+			errorHandler = noop;
+		} else {
+			errorHandler = rethrow;
+		}
 
-        return Promise.map(tables, (table) => {
-            return table.down(knex, errorHandler);
-        });
-    }
-}
+		return Promise.map(tables, (table) => {
+			return table.down(knex, errorHandler);
+		});
+	}
+};

test/create-tables/invalid-type.js

@@ -1,15 +1,15 @@
 'use strict';
 
 module.exports = {
-    up: function createInvalidTypeTable(knex, errorHandler) {
-        return knex.schema.createTable("invalid_type", (table) => {
-            table.increments("id");
-            table.integer("age");
-            table.text("name");
-            table.boolean("active");
-        }).catch(errorHandler);
-    },
-    down: function dropInvalidTypeTable(knex, errorHandler) {
-        return knex.schema.dropTable("invalid_type").catch(errorHandler);
-    }
+	up: function createInvalidTypeTable(knex, errorHandler) {
+		return knex.schema.createTable("invalid_type", (table) => {
+			table.increments("id");
+			table.integer("age");
+			table.text("name");
+			table.boolean("active");
+		}).catch(errorHandler);
+	},
+	down: function dropInvalidTypeTable(knex, errorHandler) {
+		return knex.schema.dropTable("invalid_type").catch(errorHandler);
+	}
 };

test/create-tables/not-null-constraint-violation.js

@@ -1,14 +1,14 @@
 'use strict';
 
 module.exports = {
-    up: function createNotNullConstraintViolationTable(knex, errorHandler) {
-        return knex.schema.createTable("not_null_violation", (table) => {
-            table.increments("id");
-            table.text("email").notNull();
-            table.text("name");
-        }).catch(errorHandler);
-    },
-    down: function dropNotNullConstraintViolationTable(knex, errorHandler) {
-        return knex.schema.dropTable("not_null_violation").catch(errorHandler);
-    }
+	up: function createNotNullConstraintViolationTable(knex, errorHandler) {
+		return knex.schema.createTable("not_null_violation", (table) => {
+			table.increments("id");
+			table.text("email").notNull();
+			table.text("name");
+		}).catch(errorHandler);
+	},
+	down: function dropNotNullConstraintViolationTable(knex, errorHandler) {
+		return knex.schema.dropTable("not_null_violation").catch(errorHandler);
+	}
 };

test/create-tables/unique-constraint-violation.js

@@ -1,14 +1,14 @@
 'use strict';
 
 module.exports = {
-    up: function createUniqueConstraintViolationTable(knex, errorHandler) {
-        return knex.schema.createTable("unique_constraint_violation", (table) => {
-            table.increments("id");
-            table.text("email").unique();
-            table.text("name");
-        }).catch(errorHandler);
-    },
-    down: function dropUniqueConstraintViolationTable(knex, errorHandler) {
-        return knex.schema.dropTable("unique_constraint_violation").catch(errorHandler);
-    }
+	up: function createUniqueConstraintViolationTable(knex, errorHandler) {
+		return knex.schema.createTable("unique_constraint_violation", (table) => {
+			table.increments("id");
+			table.text("email").unique();
+			table.text("name");
+		}).catch(errorHandler);
+	},
+	down: function dropUniqueConstraintViolationTable(knex, errorHandler) {
+		return knex.schema.dropTable("unique_constraint_violation").catch(errorHandler);
+	}
 };

test/test.js

@@ -10,29 +10,29 @@ const path = require("path");
 const createTables = require("./create-tables");
 
 let db = knex({
-    client: "pg",
-    connection: {
-        host: "localhost",
-        user: "sven",
-        password: "password",
-        database: "database_error"
-    },
-    debug: true
+	client: "pg",
+	connection: {
+		host: "localhost",
+		user: "sven",
+		password: "password",
+		database: "database_error"
+	},
+	debug: true
 });
 
 return Promise.try(() => {
-    return createTables.down(db, true);
+	return createTables.down(db, true);
 }).then(() => {
-    return createTables.up(db);
+	return createTables.up(db);
 }).then(() => {
-    let testcase = require(path.join(process.cwd(), process.argv[2]));
-    return testcase(db);
+	let testcase = require(path.join(process.cwd(), process.argv[2]));
+	return testcase(db);
 }).catch(databaseError.rethrow).catch((err) => {
-    console.log("__________________\n");
-    console.error(util.inspect(err, {colors: true, depth: 1}));
-    console.log("__________________\n");
+	console.log("__________________\n");
+	console.error(util.inspect(err, {colors: true, depth: 1}));
+	console.log("__________________\n");
 }).finally(() => {
-    return createTables.down(db);
+	return createTables.down(db);
 }).finally(() => {
-    return db.destroy();
+	return db.destroy();
 });

test/testcase/check-constraint-violation-insert.js

@@ -1,11 +1,11 @@
 'use strict';
 
 module.exports = function attemptCheckConstraintViolation(knex) {
-    return knex("check_constraint_violation").insert([{
-        number_value: "one",
-        name: "Joe"
-    }, {
-        number_value: "four",
-        name: "Jane"
-    }]).returning("*");
+	return knex("check_constraint_violation").insert([{
+		number_value: "one",
+		name: "Joe"
+	}, {
+		number_value: "four",
+		name: "Jane"
+	}]).returning("*");
 };

test/testcase/check-constraint-violation-update.js

@@ -3,16 +3,16 @@
 const Promise = require("bluebird");
 
 module.exports = function attemptCheckConstraintViolation(knex) {
-    return Promise.try(() => {
-        return knex("check_constraint_violation").insert({
-            number_value: "one",
-            name: "Joe"
-        }).returning("id");
-    }).then((id) => {
-        return knex("check_constraint_violation").update({
-            number_value: "four"
-        }).where({
-            id: id[0]
-        });
-    });
+	return Promise.try(() => {
+		return knex("check_constraint_violation").insert({
+			number_value: "one",
+			name: "Joe"
+		}).returning("id");
+	}).then((id) => {
+		return knex("check_constraint_violation").update({
+			number_value: "four"
+		}).where({
+			id: id[0]
+		});
+	});
 };

test/testcase/composite-unique-constraint-violation.js

@@ -1,21 +1,21 @@
 'use strict';
 
 module.exports = function attemptCompositeUniqueConstraintViolation(knex) {
-    return knex("composite_unique_constraint_violation").insert([{
-        email: "foo@bar.com",
-        username: "foo",
-        name: "Joe"
-    }, {
-        email: "baz@qux.com",
-        username: "bar",
-        name: "Jane"
-    }, {
-        email: "foo@bar.com",
-        username: "baz",
-        name: "Pete"
-    }, {
-        email: "foo@bar.com",
-        username: "foo",
-        name: "Jill"
-    }]).returning("*");
+	return knex("composite_unique_constraint_violation").insert([{
+		email: "foo@bar.com",
+		username: "foo",
+		name: "Joe"
+	}, {
+		email: "baz@qux.com",
+		username: "bar",
+		name: "Jane"
+	}, {
+		email: "foo@bar.com",
+		username: "baz",
+		name: "Pete"
+	}, {
+		email: "foo@bar.com",
+		username: "foo",
+		name: "Jill"
+	}]).returning("*");
 };

test/testcase/enum-insert.js

@@ -1,11 +1,11 @@
 'use strict';
 
 module.exports = function attemptEnumViolation(knex) {
-    return knex("enum_violation").insert([{
-        number_value: "one",
-        name: "Joe"
-    }, {
-        number_value: "four",
-        name: "Jane"
-    }]).returning("*");
+	return knex("enum_violation").insert([{
+		number_value: "one",
+		name: "Joe"
+	}, {
+		number_value: "four",
+		name: "Jane"
+	}]).returning("*");
 };

test/testcase/enum-update.js

@@ -3,16 +3,16 @@
 const Promise = require("bluebird");
 
 module.exports = function attemptEnumViolation(knex) {
-    return Promise.try(() => {
-        return knex("enum_violation").insert({
-            number_value: "one",
-            name: "Joe"
-        }).returning("id");
-    }).then((id) => {
-        return knex("enum_violation").update({
-            number_value: "four"
-        }).where({
-            id: id[0]
-        });
-    });
+	return Promise.try(() => {
+		return knex("enum_violation").insert({
+			number_value: "one",
+			name: "Joe"
+		}).returning("id");
+	}).then((id) => {
+		return knex("enum_violation").update({
+			number_value: "four"
+		}).where({
+			id: id[0]
+		});
+	});
 };

test/testcase/foreign-key-constraint-violation.js

@@ -3,24 +3,24 @@
 const Promise = require("bluebird");
 
 module.exports = function attemptForeignKeyConstraintViolation(knex) {
-    return Promise.try(() => {
-        return knex("foreign_key_constraint_users").insert([{
-            name: "Joe",
-            username: "joe"
-        }, {
-            name: "Jane",
-            username: "jane"
-        }]).returning("id");
-    }).then((ids) => {
-        return knex("foreign_key_constraint_posts").insert([{
-            user_id: ids[0],
-            body: "Foo"
-        }, {
-            user_id: ids[1],
-            body: "Bar"
-        }, {
-            user_id: 567213,
-            body: "Baz"
-        }])
-    });
+	return Promise.try(() => {
+		return knex("foreign_key_constraint_users").insert([{
+			name: "Joe",
+			username: "joe"
+		}, {
+			name: "Jane",
+			username: "jane"
+		}]).returning("id");
+	}).then((ids) => {
+		return knex("foreign_key_constraint_posts").insert([{
+			user_id: ids[0],
+			body: "Foo"
+		}, {
+			user_id: ids[1],
+			body: "Bar"
+		}, {
+			user_id: 567213,
+			body: "Baz"
+		}]);
+	});
 };

test/testcase/invalid-type-boolean-inverse.js

@@ -1,17 +1,17 @@
 'use strict';
 
 module.exports = function attemptInvalidTypeBooleanInverse(knex) {
-    return knex("invalid_type").insert([{
-        name: "Joe",
-        age: 29,
-        active: true
-    }, {
-        name: "Jane",
-        age: 42,
-        active: true
-    }, {
-        name: true,
-        age: 24,
-        active: false
-    }]).returning("*");
+	return knex("invalid_type").insert([{
+		name: "Joe",
+		age: 29,
+		active: true
+	}, {
+		name: "Jane",
+		age: 42,
+		active: true
+	}, {
+		name: true,
+		age: 24,
+		active: false
+	}]).returning("*");
 };

test/testcase/invalid-type-boolean.js

@@ -1,17 +1,17 @@
 'use strict';
 
 module.exports = function attemptInvalidTypeBoolean(knex) {
-    return knex("invalid_type").insert([{
-        name: "Joe",
-        age: 29,
-        active: true
-    }, {
-        name: "Jane",
-        age: 42,
-        active: true
-    }, {
-        name: "Pete",
-        age: 24,
-        active: "foo bar"
-    }]).returning("*");
+	return knex("invalid_type").insert([{
+		name: "Joe",
+		age: 29,
+		active: true
+	}, {
+		name: "Jane",
+		age: 42,
+		active: true
+	}, {
+		name: "Pete",
+		age: 24,
+		active: "foo bar"
+	}]).returning("*");
 };

test/testcase/invalid-type-integer.js

@@ -1,17 +1,17 @@
 'use strict';
 
 module.exports = function attemptInvalidTypeInteger(knex) {
-    return knex("invalid_type").insert([{
-        name: "Joe",
-        age: 29,
-        active: true
-    }, {
-        name: "Jane",
-        age: 42,
-        active: true
-    }, {
-        name: "Pete",
-        age: "twenty-four",
-        active: false
-    }]).returning("*");
+	return knex("invalid_type").insert([{
+		name: "Joe",
+		age: 29,
+		active: true
+	}, {
+		name: "Jane",
+		age: 42,
+		active: true
+	}, {
+		name: "Pete",
+		age: "twenty-four",
+		active: false
+	}]).returning("*");
 };

test/testcase/not-null-constraint-violation.js

@@ -1,12 +1,12 @@
 'use strict';
 
 module.exports = function attemptNotNullConstraintViolation(knex) {
-    return knex("not_null_violation").insert([{
-        email: "foo@bar.com",
-        name: "Joe"
-    }, {
-        email: "baz@qux.com"
-    }, {
-        name: "Pete"
-    }]).returning("*");
+	return knex("not_null_violation").insert([{
+		email: "foo@bar.com",
+		name: "Joe"
+	}, {
+		email: "baz@qux.com"
+	}, {
+		name: "Pete"
+	}]).returning("*");
 };

test/testcase/undefined-column.js

@@ -1,10 +1,10 @@
 'use strict';
 
 module.exports = function attemptUndefinedColumn(knex) {
-    return knex("invalid_type").insert([{
-        name: "Joe",
-        age: 29,
-        active: true,
-        nonexistentColumn: "Hello!"
-    }]).returning("*");
+	return knex("invalid_type").insert([{
+		name: "Joe",
+		age: 29,
+		active: true,
+		nonexistentColumn: "Hello!"
+	}]).returning("*");
 };

test/testcase/unique-constraint-violation.js

@@ -1,14 +1,14 @@
 'use strict';
 
 module.exports = function attemptUniqueConstraintViolation(knex) {
-    return knex("unique_constraint_violation").insert([{
-        email: "foo@bar.com",
-        name: "Joe"
-    }, {
-        email: "baz@qux.com",
-        name: "Jane"
-    }, {
-        email: "foo@bar.com",
-        name: "Pete"
-    }]).returning("*");
+	return knex("unique_constraint_violation").insert([{
+		email: "foo@bar.com",
+		name: "Joe"
+	}, {
+		email: "baz@qux.com",
+		name: "Jane"
+	}, {
+		email: "foo@bar.com",
+		name: "Pete"
+	}]).returning("*");
 };