ESLint autofixes

master
Sven Slootweg 4 years ago
parent abba82ad07
commit ccae979451

@ -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)

@ -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)
});
}
};

@ -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
});
}
};

@ -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
});
}
};

@ -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,
});
}
};

@ -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
});
}
};

@ -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,
});
}
};

@ -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
});
}
};

@ -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];
});
}
};

@ -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];
}
};

@ -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(", ");
};

@ -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);

@ -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);
}
};

@ -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);
}
};

@ -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);
});
}
};

@ -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);
});
}
};

@ -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);
});
}
};

@ -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);
}
};

@ -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);
}
};

@ -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);
}
};

@ -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();
});

@ -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("*");
};

@ -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]
});
});
};

@ -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("*");
};

@ -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("*");
};

@ -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]
});
});
};

@ -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"
}]);
});
};

@ -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("*");
};

@ -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("*");
};

@ -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("*");
};

@ -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("*");
};

@ -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("*");
};

@ -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("*");
};

Loading…
Cancel
Save