objection 3.9.1 → 4.0.0-rc.2

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

@@ -0,0 +1,27 @@
+import { UniqueViolationError } from '../../../../../errors/UniqueViolationError.js';
+
+const CODES = ['ER_DUP_ENTRY', 'ER_DUP_ENTRY_WITH_KEY_NAME'];
+const CONSTRAINT_REGEX = /Duplicate entry '(.+)' for key '(.+)'/;
+
+export const uniqueViolationErrorParser = {
+  error: UniqueViolationError,
+
+  parse: (err) => {
+    if (CODES.indexOf(err.code) === -1) {
+      return null;
+    }
+
+    const constraintMatch = CONSTRAINT_REGEX.exec(err.sqlMessage);
+
+    if (!constraintMatch) {
+      return null;
+    }
+
+    // No way to reliably get `table` and `columns` from mysql error.
+    return {
+      constraint: constraintMatch[2],
+    };
+  },
+
+  subclassParsers: [],
+};

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

@@ -0,0 +1,23 @@
+import { ConstraintViolationError } from '../../../../errors/ConstraintViolationError.js';
+import { getSqlStateClass } from '../../../../utils/sqlState.js';
+import { uniqueViolationErrorParser } from './UniqueViolationError/parser.js';
+import { notNullViolationErrorParser } from './NotNullViolationError/parser.js';
+import { foreignKeyViolationErrorParser } from './ForeignKeyViolationError/parser.js';
+
+export const constraintViolationErrorParser = {
+  error: ConstraintViolationError,
+
+  parse: (err) => {
+    if (getSqlStateClass(err.sqlState) === '23' || err.code === 'ER_NO_DEFAULT_FOR_FIELD') {
+      return {};
+    } else {
+      return null;
+    }
+  },
+
+  subclassParsers: [
+    uniqueViolationErrorParser,
+    notNullViolationErrorParser,
+    foreignKeyViolationErrorParser,
+  ],
+};

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

@@ -0,0 +1,24 @@
+import { DataError } from '../../../../errors/DataError.js';
+import { getSqlStateClass } from '../../../../utils/sqlState.js';
+
+const ERROR_CODES = [
+  'ER_DATA_TOO_LONG',
+  'ER_TRUNCATED_WRONG_VALUE',
+  'ER_TRUNCATED_WRONG_VALUE_FOR_FIELD',
+];
+
+export const dataErrorParser = {
+  error: DataError,
+
+  parse: (err) => {
+    // MySQL mainly uses the SQLSTATE codes, but some errors don't have
+    // an SQLSTATE equivalent.
+    if (getSqlStateClass(err.sqlState) === '22' || ERROR_CODES.includes(err.code)) {
+      return {};
+    } else {
+      return null;
+    }
+  },
+
+  subclassParsers: [],
+};

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

@@ -0,0 +1,28 @@
+import { DBError } from '../../../errors/DBError.js';
+import { mysqlErrorCodes } from '../../../errorCodes/mysql.js';
+import { constraintViolationErrorParser } from './ConstraintViolationError/parser.js';
+import { dataErrorParser } from './DataError/parser.js';
+
+export const dbErrorParser = {
+  error: DBError,
+
+  parse: (err) => {
+    if (
+      typeof err.code === 'string' &&
+      'sqlMessage' in err &&
+      'sqlState' in err &&
+      err.sqlState.length === 5 &&
+      mysqlErrorCodes.has(err.code) &&
+      typeof err.errno === 'number'
+    ) {
+      return {
+        nativeError: err,
+        client: 'mysql',
+      };
+    }
+
+    return null;
+  },
+
+  subclassParsers: [constraintViolationErrorParser, dataErrorParser],
+};

package/lib/dbErrors/parsers/postgres/DBError/ConstraintViolationError/CheckViolationError/parser.js

@@ -0,0 +1,18 @@
+import { CheckViolationError } from '../../../../../errors/CheckViolationError.js';
+
+export const checkViolationErrorParser = {
+  error: CheckViolationError,
+
+  parse: (err) => {
+    if (err.code === '23514') {
+      return {
+        table: err.table,
+        constraint: err.constraint,
+      };
+    } else {
+      return null;
+    }
+  },
+
+  subclassParsers: [],
+};

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

@@ -0,0 +1,18 @@
+import { ForeignKeyViolationError } from '../../../../../errors/ForeignKeyViolationError.js';
+
+export const foreignKeyViolationErrorParser = {
+  error: ForeignKeyViolationError,
+
+  parse: (err) => {
+    if (err.code === '23503') {
+      return {
+        table: err.table,
+        constraint: err.constraint,
+      };
+    } else {
+      return null;
+    }
+  },
+
+  subclassParsers: [],
+};

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

@@ -0,0 +1,18 @@
+import { NotNullViolationError } from '../../../../../errors/NotNullViolationError.js';
+
+export const notNullViolationErrorParser = {
+  error: NotNullViolationError,
+
+  parse: (err) => {
+    if (err.code === '23502') {
+      return {
+        table: err.table,
+        column: err.column,
+      };
+    } else {
+      return null;
+    }
+  },
+
+  subclassParsers: [],
+};

package/lib/dbErrors/parsers/postgres/DBError/ConstraintViolationError/UniqueViolationError/parser.js

@@ -0,0 +1,40 @@
+import { UniqueViolationError } from '../../../../../errors/UniqueViolationError.js';
+
+const UNIQUE_COLUMNS_REGEX = /Key \((.+)\)=\(.+\) already exists/;
+
+export const uniqueViolationErrorParser = {
+  error: UniqueViolationError,
+
+  parse: (err) => {
+    if (err.code !== '23505') {
+      return null;
+    }
+
+    const colsMatch = UNIQUE_COLUMNS_REGEX.exec(err.detail);
+
+    if (!colsMatch) {
+      return null;
+    }
+
+    const cols = colsMatch[1]
+      .split(',')
+      .map((it) => it.trim())
+      .map((it) => stripQuotes(it));
+
+    return {
+      table: err.table,
+      columns: cols,
+      constraint: err.constraint,
+    };
+  },
+
+  subclassParsers: [],
+};
+
+function stripQuotes(it) {
+  if (it[0] === '"' && it[it.length - 1] === '"') {
+    return it.substr(1, it.length - 2);
+  } else {
+    return it;
+  }
+}

package/lib/dbErrors/parsers/postgres/DBError/ConstraintViolationError/parser.js

@@ -0,0 +1,25 @@
+import { ConstraintViolationError } from '../../../../errors/ConstraintViolationError.js';
+import { getSqlStateClass } from '../../../../utils/sqlState.js';
+import { uniqueViolationErrorParser } from './UniqueViolationError/parser.js';
+import { notNullViolationErrorParser } from './NotNullViolationError/parser.js';
+import { foreignKeyViolationErrorParser } from './ForeignKeyViolationError/parser.js';
+import { checkViolationErrorParser } from './CheckViolationError/parser.js';
+
+export const constraintViolationErrorParser = {
+  error: ConstraintViolationError,
+
+  parse: (err) => {
+    if (getSqlStateClass(err.code) === '23') {
+      return {};
+    } else {
+      return null;
+    }
+  },
+
+  subclassParsers: [
+    uniqueViolationErrorParser,
+    notNullViolationErrorParser,
+    foreignKeyViolationErrorParser,
+    checkViolationErrorParser,
+  ],
+};

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

@@ -0,0 +1,16 @@
+import { DataError } from '../../../../errors/DataError.js';
+import { getSqlStateClass } from '../../../../utils/sqlState.js';
+
+export const dataErrorParser = {
+  error: DataError,
+
+  parse: (err) => {
+    if (getSqlStateClass(err.code) === '22') {
+      return {};
+    } else {
+      return null;
+    }
+  },
+
+  subclassParsers: [],
+};

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

@@ -0,0 +1,27 @@
+import { DBError } from '../../../errors/DBError.js';
+import { postgresErrorCodes } from '../../../errorCodes/postgres.js';
+import { constraintViolationErrorParser } from './ConstraintViolationError/parser.js';
+import { dataErrorParser } from './DataError/parser.js';
+
+export const dbErrorParser = {
+  error: DBError,
+
+  parse: (err) => {
+    if (
+      typeof err.code === 'string' &&
+      err.code.length === 5 &&
+      postgresErrorCodes.has(err.code) &&
+      'internalQuery' in err &&
+      'table' in err
+    ) {
+      return {
+        nativeError: err,
+        client: 'postgres',
+      };
+    }
+
+    return null;
+  },
+
+  subclassParsers: [constraintViolationErrorParser, dataErrorParser],
+};

package/lib/dbErrors/parsers/sqlite/DBError/ConstraintViolationError/CheckViolationError/parser.js

@@ -0,0 +1,20 @@
+import { CheckViolationError } from '../../../../../errors/CheckViolationError.js';
+
+const REGEX = /SQLITE_CONSTRAINT: CHECK constraint failed/;
+
+export const checkViolationErrorParser = {
+  error: CheckViolationError,
+
+  parse: (err) => {
+    const match = REGEX.exec(err.message);
+
+    if (!match) {
+      return null;
+    }
+
+    // No way to extract anything reliably.
+    return {};
+  },
+
+  subclassParsers: [],
+};

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

@@ -0,0 +1,20 @@
+import { ForeignKeyViolationError } from '../../../../../errors/ForeignKeyViolationError.js';
+
+const REGEX = /SQLITE_CONSTRAINT: FOREIGN KEY constraint failed/;
+
+export const foreignKeyViolationErrorParser = {
+  error: ForeignKeyViolationError,
+
+  parse: (err) => {
+    const match = REGEX.exec(err.message);
+
+    if (!match) {
+      return null;
+    }
+
+    // No way to extract anything reliably.
+    return {};
+  },
+
+  subclassParsers: [],
+};

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

@@ -0,0 +1,27 @@
+import { NotNullViolationError } from '../../../../../errors/NotNullViolationError.js';
+
+const NOT_COLUMN_REGEX = /SQLITE_CONSTRAINT: NOT NULL constraint failed: (.+)$/;
+
+export const notNullViolationErrorParser = {
+  error: NotNullViolationError,
+
+  parse: (err) => {
+    const colMatch = NOT_COLUMN_REGEX.exec(err.message);
+
+    if (!colMatch) {
+      return null;
+    }
+
+    const parts = colMatch[1]
+      .trim()
+      .split('.')
+      .map((it) => it.trim());
+
+    return {
+      table: parts[0],
+      column: parts[1],
+    };
+  },
+
+  subclassParsers: [],
+};

package/lib/dbErrors/parsers/sqlite/DBError/ConstraintViolationError/UniqueViolationError/parser.js

@@ -0,0 +1,28 @@
+import { UniqueViolationError } from '../../../../../errors/UniqueViolationError.js';
+
+const UNIQUE_COLUMNS_REGEX = /SQLITE_CONSTRAINT: UNIQUE constraint failed: (.+)$/;
+
+export const uniqueViolationErrorParser = {
+  error: UniqueViolationError,
+
+  parse: (err) => {
+    const colsMatch = UNIQUE_COLUMNS_REGEX.exec(err.message);
+
+    if (!colsMatch) {
+      return null;
+    }
+
+    const cols = colsMatch[1]
+      .split(',')
+      .map((it) => it.trim())
+      .map((it) => it.split('.'))
+      .map((it) => it.map((it) => it.trim()));
+
+    return {
+      table: cols[0][0],
+      columns: cols.map((it) => it[1]),
+    };
+  },
+
+  subclassParsers: [],
+};

package/lib/dbErrors/parsers/sqlite/DBError/ConstraintViolationError/parser.js

@@ -0,0 +1,24 @@
+import { ConstraintViolationError } from '../../../../errors/ConstraintViolationError.js';
+import { uniqueViolationErrorParser } from './UniqueViolationError/parser.js';
+import { notNullViolationErrorParser } from './NotNullViolationError/parser.js';
+import { foreignKeyViolationErrorParser } from './ForeignKeyViolationError/parser.js';
+import { checkViolationErrorParser } from './CheckViolationError/parser.js';
+
+export const constraintViolationErrorParser = {
+  error: ConstraintViolationError,
+
+  parse: (err) => {
+    if (err.code === 'SQLITE_CONSTRAINT') {
+      return {};
+    } else {
+      return null;
+    }
+  },
+
+  subclassParsers: [
+    uniqueViolationErrorParser,
+    notNullViolationErrorParser,
+    foreignKeyViolationErrorParser,
+    checkViolationErrorParser,
+  ],
+};

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

@@ -0,0 +1,23 @@
+import { DBError } from '../../../errors/DBError.js';
+import { constraintViolationErrorParser } from './ConstraintViolationError/parser.js';
+
+export const dbErrorParser = {
+  error: DBError,
+
+  parse: (err) => {
+    if (
+      typeof err.code === 'string' &&
+      err.code.startsWith('SQLITE_') &&
+      typeof err.errno === 'number'
+    ) {
+      return {
+        nativeError: err,
+        client: 'sqlite',
+      };
+    }
+
+    return null;
+  },
+
+  subclassParsers: [constraintViolationErrorParser],
+};

package/lib/dbErrors/utils/sqlState.js

@@ -0,0 +1,3 @@
+export function getSqlStateClass(sqlState) {
+  return sqlState.substr(0, 2);
+}

package/lib/initialize.js

@@ -1,6 +1,4 @@
-'use strict';
-
-async function initialize(knex, modelClasses) {
+export async function initialize(knex, modelClasses) {
   if (!modelClasses) {
     modelClasses = knex;
     knex = modelClasses[0].knex();
@@ -8,7 +6,3 @@ async function initialize(knex, modelClasses) {
 
   await Promise.all(modelClasses.map((modelClass) => modelClass.fetchTableMetadata({ knex })));
 }
-
-module.exports = {
-  initialize,
-};