objection 3.9.0 → 4.0.0-rc.1

package/lib/dbErrors/errorCodes/postgres.js

@@ -0,0 +1,241 @@
+export const postgresErrorCodes = new Set([
+  '000',
+  '00000',
+  '01000',
+  '0100C',
+  '01008',
+  '01003',
+  '01007',
+  '01006',
+  '01004',
+  '01P01',
+  '02000',
+  '02001',
+  '03000',
+  '08000',
+  '08003',
+  '08006',
+  '08001',
+  '08004',
+  '08007',
+  '08P01',
+  '09000',
+  '0A000',
+  '0B000',
+  '0F000',
+  '0F001',
+  '0L000',
+  '0LP01',
+  '0P000',
+  '0Z000',
+  '0Z002',
+  '20000',
+  '21000',
+  '22000',
+  '2202E',
+  '22021',
+  '22008',
+  '22012',
+  '22005',
+  '2200B',
+  '22022',
+  '22015',
+  '2201E',
+  '22014',
+  '22016',
+  '2201F',
+  '2201G',
+  '22018',
+  '22007',
+  '22019',
+  '2200D',
+  '22025',
+  '22P06',
+  '22010',
+  '22023',
+  '2201B',
+  '2201W',
+  '2201X',
+  '2202H',
+  '2202G',
+  '22009',
+  '2200C',
+  '2200G',
+  '22004',
+  '22002',
+  '22003',
+  '22026',
+  '22001',
+  '22011',
+  '22027',
+  '22024',
+  '2200F',
+  '22P01',
+  '22P02',
+  '22P03',
+  '22P04',
+  '22P05',
+  '2200L',
+  '2200M',
+  '2200N',
+  '2200S',
+  '2200T',
+  '23000',
+  '23001',
+  '23502',
+  '23503',
+  '23505',
+  '23514',
+  '23P01',
+  '24000',
+  '25000',
+  '25001',
+  '25002',
+  '25008',
+  '25003',
+  '25004',
+  '25005',
+  '25006',
+  '25007',
+  '25P01',
+  '25P02',
+  '25P03',
+  '26000',
+  '27000',
+  '28000',
+  '28P01',
+  '2B000',
+  '2BP01',
+  '2D000',
+  '2F000',
+  '2F005',
+  '2F002',
+  '2F003',
+  '2F004',
+  '34000',
+  '38000',
+  '38001',
+  '38002',
+  '38003',
+  '38004',
+  '39000',
+  '39001',
+  '39004',
+  '39P01',
+  '39P02',
+  '39P03',
+  '3B000',
+  '3B001',
+  '3D000',
+  '3F000',
+  '40000',
+  '40002',
+  '40001',
+  '40003',
+  '40P01',
+  '42000',
+  '42601',
+  '42501',
+  '42846',
+  '42803',
+  '42P20',
+  '42P19',
+  '42830',
+  '42602',
+  '42622',
+  '42939',
+  '42804',
+  '42P18',
+  '42P21',
+  '42P22',
+  '42809',
+  '42703',
+  '42883',
+  '42P01',
+  '42P02',
+  '42704',
+  '42701',
+  '42P03',
+  '42P04',
+  '42723',
+  '42P05',
+  '42P06',
+  '42P07',
+  '42712',
+  '42710',
+  '42702',
+  '42725',
+  '42P08',
+  '42P09',
+  '42P10',
+  '42611',
+  '42P11',
+  '42P12',
+  '42P13',
+  '42P14',
+  '42P15',
+  '42P16',
+  '42P17',
+  '44000',
+  '53000',
+  '53100',
+  '53200',
+  '53300',
+  '53400',
+  '54000',
+  '54001',
+  '54011',
+  '54023',
+  '55000',
+  '55006',
+  '55P02',
+  '55P03',
+  '57000',
+  '57014',
+  '57P01',
+  '57P02',
+  '57P03',
+  '57P04',
+  '58000',
+  '58030',
+  '58P01',
+  '58P02',
+  '72000',
+  'F0000',
+  'F0001',
+  'HV000',
+  'HV005',
+  'HV002',
+  'HV010',
+  'HV021',
+  'HV024',
+  'HV007',
+  'HV008',
+  'HV004',
+  'HV006',
+  'HV091',
+  'HV00B',
+  'HV00C',
+  'HV00D',
+  'HV090',
+  'HV00A',
+  'HV009',
+  'HV014',
+  'HV001',
+  'HV00P',
+  'HV00J',
+  'HV00K',
+  'HV00Q',
+  'HV00R',
+  'HV00L',
+  'HV00M',
+  'HV00N',
+  'P0000',
+  'P0001',
+  'P0002',
+  'P0003',
+  'P0004',
+  'XX000',
+  'XX001',
+  'XX002',
+]);

package/lib/dbErrors/errors/CheckViolationError.js

@@ -0,0 +1,10 @@
+import { ConstraintViolationError } from './ConstraintViolationError.js';
+
+export class CheckViolationError extends ConstraintViolationError {
+  constructor(args) {
+    super(args);
+
+    this.table = args.table;
+    this.constraint = args.constraint;
+  }
+}

package/lib/dbErrors/errors/ConstraintViolationError.js

@@ -0,0 +1,3 @@
+import { DBError } from './DBError.js';
+
+export class ConstraintViolationError extends DBError {}

package/lib/dbErrors/errors/DBError.js

@@ -0,0 +1,9 @@
+export class DBError extends Error {
+  constructor(args) {
+    super(args.message ?? args.nativeError.message);
+
+    this.name = this.constructor.name;
+    this.nativeError = args.nativeError;
+    this.client = args.client;
+  }
+}

package/lib/dbErrors/errors/DataError.js

@@ -0,0 +1,3 @@
+import { DBError } from './DBError.js';
+
+export class DataError extends DBError {}

package/lib/dbErrors/errors/ForeignKeyViolationError.js

@@ -0,0 +1,11 @@
+import { ConstraintViolationError } from './ConstraintViolationError.js';
+
+export class ForeignKeyViolationError extends ConstraintViolationError {
+  constructor(args) {
+    super(args);
+
+    this.table = args.table;
+    this.constraint = args.constraint;
+    this.schema = args.schema;
+  }
+}

package/lib/dbErrors/errors/NotNullViolationError.js

@@ -0,0 +1,12 @@
+import { ConstraintViolationError } from './ConstraintViolationError.js';
+
+export class NotNullViolationError extends ConstraintViolationError {
+  constructor(args) {
+    super(args);
+
+    this.table = args.table;
+    this.column = args.column;
+    this.schema = args.schema;
+    this.database = args.database;
+  }
+}

package/lib/dbErrors/errors/UniqueViolationError.js

@@ -0,0 +1,12 @@
+import { ConstraintViolationError } from './ConstraintViolationError.js';
+
+export class UniqueViolationError extends ConstraintViolationError {
+  constructor(args) {
+    super(args);
+
+    this.table = args.table;
+    this.columns = args.columns;
+    this.constraint = args.constraint;
+    this.schema = args.schema;
+  }
+}

package/lib/dbErrors/index.js

@@ -0,0 +1,59 @@
+/**
+ * Vendored from db-errors 0.2.3 (https://github.com/Vincit/db-errors),
+ * converted to ES modules, with support for the mssql errors of tedious and
+ * for mssql primary key violations.
+ *
+ * Copyright (c) 2017 Vincit
+ * Released under the MIT license, see ./LICENSE
+ */
+
+import { dbErrorParser as postgresParser } from './parsers/postgres/DBError/parser.js';
+import { dbErrorParser as sqliteParser } from './parsers/sqlite/DBError/parser.js';
+import { dbErrorParser as mysqlParser } from './parsers/mysql/DBError/parser.js';
+import { dbErrorParser as mssqlParser } from './parsers/mssql/DBError/parser.js';
+
+export { DBError } from './errors/DBError.js';
+export { ConstraintViolationError } from './errors/ConstraintViolationError.js';
+export { ForeignKeyViolationError } from './errors/ForeignKeyViolationError.js';
+export { NotNullViolationError } from './errors/NotNullViolationError.js';
+export { UniqueViolationError } from './errors/UniqueViolationError.js';
+export { CheckViolationError } from './errors/CheckViolationError.js';
+export { DataError } from './errors/DataError.js';
+
+// The parsers are tried in this order.
+const parsers = [postgresParser, sqliteParser, mysqlParser, mssqlParser];
+
+export function wrapError(err) {
+  for (let i = 0, l = parsers.length; i < l; ++i) {
+    const result = parse(parsers[i], err, null);
+
+    if (result !== null) {
+      return new result.node.error(result.args);
+    }
+  }
+
+  return err;
+}
+
+function parse(node, err, parentResult) {
+  const args = node.parse(err);
+
+  if (args === null) {
+    return null;
+  }
+
+  const result = {
+    node,
+    args: Object.assign({}, parentResult && parentResult.args, args),
+  };
+
+  for (let i = 0; i < node.subclassParsers.length; ++i) {
+    const subResult = parse(node.subclassParsers[i], err, result);
+
+    if (subResult !== null) {
+      return subResult;
+    }
+  }
+
+  return result;
+}

package/lib/dbErrors/parsers/mssql/DBError/CheckViolationError/parser.js

@@ -0,0 +1,28 @@
+import { CheckViolationError } from '../../../../errors/CheckViolationError.js';
+import { isCode } from '../util.js';
+
+const REGEX =
+  /The (INSERT|UPDATE) statement conflicted with the CHECK constraint "(.+)". The conflict occurred in database "(.+)", table "(.+)", column '(.+)'./;
+
+export const checkViolationErrorParser = {
+  error: CheckViolationError,
+
+  parse: (err) => {
+    if (isCode(err, 16, 547)) {
+      const match = REGEX.exec(err.message);
+
+      if (!match) {
+        return null;
+      }
+
+      return {
+        table: match[3],
+        constraint: match[1],
+      };
+    } else {
+      return null;
+    }
+  },
+
+  subclassParsers: [],
+};

package/lib/dbErrors/parsers/mssql/DBError/DataError/parser.js

@@ -0,0 +1,25 @@
+import { DataError } from '../../../../errors/DataError.js';
+import { isCode } from '../util.js';
+
+export const dataErrorParser = {
+  error: DataError,
+
+  parse: (err) => {
+    // 241 - Conversion failed when converting date and/or time from character string.
+    // 242 - The conversion of a nvarchar data type to a datetime data type resulted in an out-of-range value.
+    // 245 - Conversion failed when converting the nvarchar value 'lol' to data type int.
+    // 8152 - String or binary data would be truncated.
+    if (
+      isCode(err, 16, 241) ||
+      isCode(err, 16, 242) ||
+      isCode(err, 16, 245) ||
+      isCode(err, 16, 8152)
+    ) {
+      return {};
+    } else {
+      return null;
+    }
+  },
+
+  subclassParsers: [],
+};

package/lib/dbErrors/parsers/mssql/DBError/ForeignKeyViolationError/parser.js

@@ -0,0 +1,39 @@
+import { ForeignKeyViolationError } from '../../../../errors/ForeignKeyViolationError.js';
+import { isCode } from '../util.js';
+
+const INSERT_UPDATE_REGEX =
+  /The (?:INSERT|UPDATE) statement conflicted with the FOREIGN KEY constraint "(.+)". The conflict occurred in database "(.+)", table "(.+)\.(.+)", column '(.+)'./;
+const DELETE_REGEX =
+  /The DELETE statement conflicted with the REFERENCE constraint "(.+)". The conflict occurred in database "(.+)", table "(.+)\.(.+)", column '(.+)'./;
+
+export const foreignKeyViolationErrorParser = {
+  error: ForeignKeyViolationError,
+
+  parse: (err) => {
+    if (isCode(err, 16, 547)) {
+      const insertUpdateMatch = INSERT_UPDATE_REGEX.exec(err.message);
+
+      if (insertUpdateMatch) {
+        return {
+          table: insertUpdateMatch[4],
+          schema: insertUpdateMatch[3],
+          constraint: insertUpdateMatch[1],
+        };
+      }
+
+      const deleteMatch = DELETE_REGEX.exec(err.message);
+
+      if (deleteMatch) {
+        return {
+          table: deleteMatch[4],
+          schema: deleteMatch[3],
+          constraint: deleteMatch[1],
+        };
+      }
+    }
+
+    return null;
+  },
+
+  subclassParsers: [],
+};

package/lib/dbErrors/parsers/mssql/DBError/NotNullViolationError/parser.js

@@ -0,0 +1,30 @@
+import { NotNullViolationError } from '../../../../errors/NotNullViolationError.js';
+import { isCode } from '../util.js';
+
+const REGEX =
+  /Cannot insert the value NULL into column '(.+)', table '(.+)\.(.+)\.(.+)'; column does not allow nulls. (?:INSERT|UPDATE) fails./;
+
+export const notNullViolationErrorParser = {
+  error: NotNullViolationError,
+
+  parse: (err) => {
+    if (isCode(err, 16, 515) || isCode(err, 16, 50000)) {
+      const match = REGEX.exec(err.message);
+
+      if (!match) {
+        return null;
+      }
+
+      return {
+        column: match[1],
+        database: match[2],
+        schema: match[3],
+        table: match[4],
+      };
+    } else {
+      return null;
+    }
+  },
+
+  subclassParsers: [],
+};

package/lib/dbErrors/parsers/mssql/DBError/UniqueViolationError/parser.js

@@ -0,0 +1,53 @@
+import { UniqueViolationError } from '../../../../errors/UniqueViolationError.js';
+import { isCode } from '../util.js';
+
+const UNIQUE_INDEX_REGEX =
+  /Cannot insert duplicate key row in object '(.+)\.(.+)' with unique index '(.+)'. The duplicate key value is (.+)./;
+const UNIQUE_CONSTRAINT_REGEX =
+  /Violation of UNIQUE KEY constraint '(.+)'. Cannot insert duplicate key in object '(.+)\.(.+)'. The duplicate key value is \((.+)\)/;
+
+// The same error number (2627) is also used for primary key violations (#2688).
+const PRIMARY_KEY_REGEX =
+  /Violation of PRIMARY KEY constraint '(.+)'. Cannot insert duplicate key in object '(.+)\.(.+)'. The duplicate key value is \((.+)\)/;
+
+// 2601 - Violation in unique index
+// 2627 - Violation in unique or primary key constraint (although it is implemented using unique index)
+
+export const uniqueViolationErrorParser = {
+  error: UniqueViolationError,
+
+  parse: (err) => {
+    if (isCode(err, 14, 2627)) {
+      const constraintMatch =
+        UNIQUE_CONSTRAINT_REGEX.exec(err.message) || PRIMARY_KEY_REGEX.exec(err.message);
+
+      if (!constraintMatch) {
+        return null;
+      }
+
+      return {
+        table: constraintMatch[3],
+        schema: constraintMatch[2],
+        constraint: constraintMatch[1],
+      };
+    }
+
+    if (isCode(err, 14, 2601)) {
+      const indexMatch = UNIQUE_INDEX_REGEX.exec(err.message);
+
+      if (!indexMatch) {
+        return null;
+      }
+
+      return {
+        table: indexMatch[2],
+        constraint: indexMatch[3],
+        schema: indexMatch[1],
+      };
+    }
+
+    return null;
+  },
+
+  subclassParsers: [],
+};

package/lib/dbErrors/parsers/mssql/DBError/parser.js

@@ -0,0 +1,51 @@
+import { DBError } from '../../../errors/DBError.js';
+import { mssqlErrorCodes } from '../../../errorCodes/mssql.js';
+import { getCode } from './util.js';
+import { checkViolationErrorParser } from './CheckViolationError/parser.js';
+import { dataErrorParser } from './DataError/parser.js';
+import { foreignKeyViolationErrorParser } from './ForeignKeyViolationError/parser.js';
+import { notNullViolationErrorParser } from './NotNullViolationError/parser.js';
+import { uniqueViolationErrorParser } from './UniqueViolationError/parser.js';
+
+export const dbErrorParser = {
+  error: DBError,
+
+  parse: (err) => {
+    // db-errors was written for the `mssql` package, which wraps the errors of
+    // tedious in `originalError`. knex uses tedious directly, so we parse those.
+    if (err.code === 'EREQUEST' && mssqlErrorCodes.has(getCode(err))) {
+      return {
+        nativeError: err,
+        client: 'mssql',
+      };
+    }
+
+    // tedious throws an AggregateError with an empty message when SQL Server
+    // reports several errors for one statement, and knex only prepends the SQL
+    // to it. Add the messages of its errors, to give the reasons.
+    if (isTediousAggregateError(err)) {
+      return {
+        nativeError: err,
+        client: 'mssql',
+        message: err.message + err.errors.map((error) => error.message).join(' '),
+      };
+    }
+
+    return null;
+  },
+
+  subclassParsers: [
+    checkViolationErrorParser,
+    dataErrorParser,
+    foreignKeyViolationErrorParser,
+    notNullViolationErrorParser,
+    uniqueViolationErrorParser,
+  ],
+};
+
+function isTediousAggregateError(err) {
+  return (
+    err instanceof AggregateError &&
+    err.errors.every((error) => error?.code === 'EREQUEST' && Number.isInteger(error.number))
+  );
+}

package/lib/dbErrors/parsers/mssql/DBError/util.js

@@ -0,0 +1,16 @@
+export function getCode(error) {
+  return {
+    errorCode: error.number,
+    severity: error.class,
+  };
+}
+
+export function isCode(error, severity, errorCode) {
+  const code = getCode(error);
+
+  if (code) {
+    return code.errorCode === errorCode && code.severity === severity;
+  }
+
+  return false;
+}

package/lib/dbErrors/parsers/mysql/DBError/ConstraintViolationError/ForeignKeyViolationError/parser.js

@@ -0,0 +1,43 @@
+import { ForeignKeyViolationError } from '../../../../../errors/ForeignKeyViolationError.js';
+
+const NO_REFERENCED_REGEX =
+  /a foreign key constraint fails \(`(.+)`\.`(.+)`, CONSTRAINT `(.+)` FOREIGN KEY \(`(.+)`\) REFERENCES `(.+)` \(`(.+)`\)/;
+const ROW_IS_REFERENCED_REGEX =
+  /Cannot delete or update a parent row: a foreign key constraint fails \(`(.+)`\.`(.+)`, CONSTRAINT `(.+)` FOREIGN KEY \(`(.+)`\) REFERENCES `(.+)` \(`(.+)`\)/;
+
+export const foreignKeyViolationErrorParser = {
+  error: ForeignKeyViolationError,
+
+  parse: (err) => {
+    let match = null;
+
+    if (err.code === 'ER_NO_REFERENCED_ROW' || err.code === 'ER_ROW_IS_REFERENCED') {
+      // For these variants, there is no table or constraint information available.
+      // These seem to be mostly thrown on mysql 8 when the db user doesn't have
+      // priviledges to the parent table. There seems to be a bug however that
+      // causes these generic errors to be thrown even in some cases where the
+      // user DOES have priviledges.
+      return {
+        table: null,
+        constraint: null,
+      };
+    }
+
+    if (err.code === 'ER_NO_REFERENCED_ROW_2') {
+      match = NO_REFERENCED_REGEX.exec(err.sqlMessage);
+    } else if (err.code === 'ER_ROW_IS_REFERENCED_2') {
+      match = ROW_IS_REFERENCED_REGEX.exec(err.sqlMessage);
+    }
+
+    if (!match) {
+      return null;
+    }
+
+    return {
+      table: match[2],
+      constraint: match[3],
+    };
+  },
+
+  subclassParsers: [],
+};

package/lib/dbErrors/parsers/mysql/DBError/ConstraintViolationError/NotNullViolationError/parser.js

@@ -0,0 +1,29 @@
+import { NotNullViolationError } from '../../../../../errors/NotNullViolationError.js';
+
+const COLUMN_REGEX_BAD_NULL_ERROR = /Column '(.+)' cannot be null/;
+const COLUMN_REGEX_NO_DEFAULT_FOR_FIELD = /Field '(.+)' doesn't have a default value/;
+
+export const notNullViolationErrorParser = {
+  error: NotNullViolationError,
+
+  parse: (err) => {
+    let columnMatch = null;
+
+    if (err.code === 'ER_BAD_NULL_ERROR') {
+      columnMatch = COLUMN_REGEX_BAD_NULL_ERROR.exec(err.sqlMessage);
+    } else if (err.code === 'ER_NO_DEFAULT_FOR_FIELD') {
+      columnMatch = COLUMN_REGEX_NO_DEFAULT_FOR_FIELD.exec(err.sqlMessage);
+    }
+
+    if (!columnMatch) {
+      return null;
+    }
+
+    // No way to reliably get `table` from mysql error.
+    return {
+      column: columnMatch[1],
+    };
+  },
+
+  subclassParsers: [],
+};