objection 3.6.0 → 3.8.0

package/lib/utils/wrapDbError.js

@@ -2,35 +2,49 @@
 
 const { wrapError, DBError, UniqueViolationError } = require('db-errors');
 
-// db-errors only recognizes mssql unique key violations, but the same error
-// number (2627) is also used for primary key violations (#2688).
+// db-errors only recognizes mssql unique key violations, but primary key
+// violations have the same error number, with a different message (#2688).
 const MSSQL_PRIMARY_KEY_REGEX =
   /Violation of PRIMARY KEY constraint '(.+)'\. Cannot insert duplicate key in object '(.+)\.(.+)'\. The duplicate key value is \((.+)\)/;
 
 function wrapDbError(err) {
-  const wrapped = wrapError(err);
-
-  if (wrapped.constructor === DBError && wrapped.client === 'mssql') {
-    const { nativeError } = wrapped;
-    const match =
-      nativeError.info &&
-      nativeError.info.number === 2627 &&
-      MSSQL_PRIMARY_KEY_REGEX.exec(nativeError.message);
-
-    if (match) {
-      return new UniqueViolationError({
-        nativeError,
-        client: 'mssql',
-        table: match[3],
-        schema: match[2],
-        constraint: match[1],
-      });
-    }
+  if (!isTediousError(err)) {
+    return wrapError(err);
+  }
+
+  // db-errors parses the errors of the `mssql` package, which wraps the errors
+  // of tedious and keeps their number and class in `originalError.info`. knex
+  // uses tedious directly, so its errors are passed on in that shape.
+  const wrapped = wrapError({
+    code: err.code,
+    originalError: { message: err.message, info: { number: err.number, class: err.class } },
+  });
+
+  if (!(wrapped instanceof DBError)) {
+    return err;
+  }
+
+  wrapped.nativeError = err;
+
+  const match = wrapped.constructor === DBError && MSSQL_PRIMARY_KEY_REGEX.exec(err.message);
+
+  if (match) {
+    return new UniqueViolationError({
+      nativeError: err,
+      client: 'mssql',
+      table: match[3],
+      schema: match[2],
+      constraint: match[1],
+    });
   }
 
   return wrapped;
 }
 
+function isTediousError(err) {
+  return err?.code === 'EREQUEST' && Number.isInteger(err.number);
+}
+
 module.exports = {
   wrapDbError,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objection",
-  "version": "3.6.0",
+  "version": "3.8.0",
   "description": "An SQL-friendly ORM for Node.js",
   "main": "lib/objection.js",
   "license": "MIT",
@@ -9,7 +9,7 @@
     "test:fast": "mocha --slow 10 --timeout 15000 --reporter spec --recursive tests --bail --exclude \"tests/unit/relations/files/**\"",
     "test:typings": "tsc && prettier --check \"typings/**/*.ts\" \"tests/ts/**/*.ts\"",
     "db:up": "docker compose up -d --wait",
-    "db:down": "docker compose down -v",
+    "db:down": "docker compose --profile mssql down -v",
     "build:parsers": "npx --yes peggy@5.1.0 --format commonjs -o lib/queryBuilder/parsers/jsonFieldExpressionParser.js lib/queryBuilder/parsers/jsonFieldExpressionParser.pegjs && npx --yes peggy@5.1.0 --format commonjs -o lib/queryBuilder/parsers/relationExpressionParser.js lib/queryBuilder/parsers/relationExpressionParser.pegjs && prettier --write \"lib/queryBuilder/parsers/*Parser.js\"",
     "prettier": "prettier --write \"{examples,lib,tests,testUtils,typings,doc}/**/*.{js,ts}\"",
     "eslint": "eslint --format codeframe \"examples/**/*.js\" \"lib/**/*.js\" \"tests/**/*.js\" \"testUtils/**/*.js\" \"*.js\"",
@@ -66,7 +66,7 @@
     "db-errors": "^0.2.3"
   },
   "peerDependencies": {
-    "knex": ">=2.3.0"
+    "knex": ">=2.3.0 <4"
   },
   "devDependencies": {
     "@types/node": "^22.15.3",
@@ -82,7 +82,8 @@
     "pg": "^8.15.6",
     "prettier": "3.9.9",
     "sqlite3": "^5.1.7",
-    "typescript": ">=5.8.3",
+    "tedious": "^20.3.7",
+    "typescript": "^5.8.3",
     "vitepress": "1.6.4"
   }
 }

package/typings/objection/index.d.ts

@@ -374,7 +374,8 @@ declare namespace Objection {
 
   /**
    * Converts the query builder NQB to the same result kind as QB:
-   * array, single, maybe-single or page.
+   * array, single, maybe-single or page. Any other result type, e.g. after
+   * `castTo()` or `patch()`, falls back to QB, without narrowing.
    */
   type WithResultKind<QB extends AnyQueryBuilder, NQB extends AnyQueryBuilder> = [
     ResultType<QB>,
@@ -423,7 +424,9 @@ declare namespace Objection {
         ? I extends Model
           ? I[] | PartialModelObject<I>[]
           : Expression<T[K]>
-        : Expression<T[K]>;
+        : NonNullable<T[K]> extends Model
+          ? Expression<T[K]> | PartialModelObject<NonNullable<T[K]>> // nullable to-one relations
+          : Expression<T[K]>;
   };
 
   /**
@@ -1000,14 +1003,39 @@ declare namespace Objection {
     includeTriggerModifications?: boolean;
   }
 
+  type ReturningColumn = string | Raw | readonly (string | Raw)[];
+
+  /**
+   * The arguments of `returning()`: any number of columns or column arrays,
+   * optionally followed by an options object.
+   */
+  type ReturningArgs =
+    ReturningColumn[] | [ReturningColumn, ...ReturningColumn[], ReturningOptions | undefined];
+
   interface ReturningMethod {
     <QB extends AnyQueryBuilder>(
       this: QB,
-      column: string | Raw | (string | Raw)[] | readonly (string | Raw)[],
-      options?: ReturningOptions,
+      ...args: ReturningArgs
     ): QB extends NumberQueryBuilder<QB> ? ArrayQueryBuilder<QB> : QB;
   }
 
+  /**
+   * With `returning()`, `relate()` returns the inserted join rows for
+   * many-to-many relations, the updated related rows for has-many relations
+   * and the updated owner rows for belongs-to-one relations. MySQL has no
+   * `returning`: there, many-to-many relations return the join rows built from
+   * the input, without columns generated by the database, and the other
+   * relations still return the number of affected rows. The typings can't tell
+   * these apart, so the rows are typed as `any`.
+   */
+  interface RelateReturningMethod<M extends Model> {
+    (...args: ReturningArgs): QueryBuilder<M, any[]>;
+  }
+
+  type RelateQueryBuilder<QB extends AnyQueryBuilder> = {
+    returning: RelateReturningMethod<ModelType<QB>>;
+  } & NumberQueryBuilder<QB>;
+
   interface TimeoutOptions {
     cancel: boolean;
   }
@@ -1060,6 +1088,11 @@ declare namespace Objection {
   export interface InsertGraphOptions {
     relate?: boolean | string | string[];
     allowRefs?: boolean;
+    /**
+     * @deprecated Has no effect, since `insertGraph()` rejects `#unrelate` and
+     * `#delete` markers. Removed in objection 4.0.
+     */
+    allowMarkers?: boolean;
   }
 
   interface InsertGraphMethod<M extends Model> {
@@ -1087,6 +1120,7 @@ declare namespace Objection {
     noRelate?: boolean | string | string[];
     noUnrelate?: boolean | string | string[];
     allowRefs?: boolean;
+    allowMarkers?: boolean;
   }
 
   interface UpsertGraphMethod<M extends Model> {
@@ -1113,6 +1147,7 @@ declare namespace Objection {
     aliases?: { [key: string]: string };
     joinOperation?: string;
     maxBatchSize?: number;
+    limitPerParent?: boolean;
   }
 
   export interface WithGraphOptions extends GraphOptions {
@@ -1386,7 +1421,7 @@ declare namespace Objection {
 
     relate(
       ids: MaybeCompositeId | MaybeCompositeId[] | PartialModelObject<M> | PartialModelObject<M>[],
-    ): NumberQueryBuilder<this>;
+    ): RelateQueryBuilder<this>;
 
     unrelate(): NumberQueryBuilder<this>;
     for(ids: ForIdValue | ForIdValue[]): this;
@@ -1718,34 +1753,25 @@ declare namespace Objection {
     constructor(config: AjvConfig);
   }
 
-  export interface SnakeCaseMappersOptions {
+  /**
+   * The options shared by `snakeCaseMappers` and `knexSnakeCaseMappers`.
+   */
+  export interface SnakeCaseOptions {
     upperCase?: boolean;
     underscoreBeforeDigits?: boolean;
     underscoreBetweenUppercaseLetters?: boolean;
     noDoubleUnderscores?: boolean;
+  }
+
+  export interface SnakeCaseMappersOptions extends SnakeCaseOptions {
     /**
      * Only convert the column part of field expressions like
      * `jsonColumn:someKey` and keep their JSON keys as written.
-     * Only used by `snakeCaseMappers`.
      */
     preserveJsonKeys?: boolean;
-    /**
-     * Also convert the keys of plain objects one level down in the results,
-     * e.g. the rows of knex's `nestTables: true` option on MySQL. Also applies
-     * to JSON columns parsed by the driver.
-     * Only used by `knexSnakeCaseMappers`.
-     */
-    mapNestedKeys?: boolean;
   }
 
-  export interface KnexIdentifierMappingOptions {
-    /**
-     * Also convert the keys of plain objects one level down in the results,
-     * e.g. the rows of knex's `nestTables: true` option on MySQL. Also applies
-     * to JSON columns parsed by the driver.
-     */
-    mapNestedKeys?: boolean;
-  }
+  export interface KnexSnakeCaseMappersOptions extends SnakeCaseOptions {}
 
   export interface ColumnNameMappers {
     parse(json: Pojo): Pojo;
@@ -1762,11 +1788,11 @@ declare namespace Objection {
   }
 
   export interface KnexSnakeCaseMappersFactory {
-    (options?: SnakeCaseMappersOptions): KnexMappers;
+    (options?: KnexSnakeCaseMappersOptions): KnexMappers;
   }
 
   export interface KnexIdentifierMappingFactory {
-    (colToProp: Record<string, string>, options?: KnexIdentifierMappingOptions): KnexMappers;
+    (colToProp: Record<string, string>): KnexMappers;
   }
 
   export type ValidationErrorType =
@@ -2040,14 +2066,16 @@ declare namespace Objection {
     static bindKnex<M>(this: M, trxOrKnex: TransactionOrKnex): M;
     static bindTransaction<M>(this: M, trxOrKnex: TransactionOrKnex): M;
 
-    static fetchGraph<M extends Model, const E extends RelationExpression<M>>(
+    // E defaults to `string` so that `fetchGraph<Person>(...)` still compiles,
+    // without narrowing, as TypeScript doesn't infer the remaining arguments.
+    static fetchGraph<M extends Model, const E extends RelationExpression<M> = string>(
       this: ConstructorType<M>,
       modelOrObject: PartialModelObject<M>,
       expression: E,
       options?: FetchGraphOptions,
     ): SingleQueryBuilder<WithGraphModelQueryBuilder<M, E>>;
 
-    static fetchGraph<M extends Model, const E extends RelationExpression<M>>(
+    static fetchGraph<M extends Model, const E extends RelationExpression<M> = string>(
       this: ConstructorType<M>,
       modelOrObject: PartialModelObject<M>[],
       expression: E,

package/lib/relations/manyToMany/ManyToManyPostgresModifyMixin.js

@@ -1,27 +0,0 @@
-'use strict';
-
-const { ManyToManyModifyMixin } = require('./ManyToManyModifyMixin');
-
-// Like `ManyToManySqliteModifyMixin`, this identifies the join rows to modify
-// by their physical row id, so that only the join rows that match the filters
-// are modified (#1853). `tableoid` makes `ctid` unique for partitioned tables.
-const ManyToManyPostgresModifyMixin = (Operation) => {
-  return class extends ManyToManyModifyMixin(Operation) {
-    applyModifyFilterForJoinTable(builder) {
-      const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
-      const tableRef = builder.tableRefFor(this.relation.getJoinModelClass(builder));
-      const rowIdRefs = [`${tableRef}.tableoid`, `${tableRef}.ctid`];
-
-      const ownerValues = this.owner.getProps(this.relation);
-      const subquery = this.modifyFilterSubquery.clone().select(rowIdRefs);
-
-      return builder
-        .whereInComposite(rowIdRefs, subquery)
-        .whereInComposite(joinTableOwnerRefs, ownerValues);
-    }
-  };
-};
-
-module.exports = {
-  ManyToManyPostgresModifyMixin,
-};

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelatePostgresOperation.js

@@ -1,16 +0,0 @@
-'use strict';
-
-const { ManyToManyUnrelateOperationBase } = require('./ManyToManyUnrelateOperationBase');
-const { ManyToManyPostgresModifyMixin } = require('../ManyToManyPostgresModifyMixin');
-
-class ManyToManyUnrelatePostgresOperation extends ManyToManyPostgresModifyMixin(
-  ManyToManyUnrelateOperationBase,
-) {
-  get modifyMainQuery() {
-    return false;
-  }
-}
-
-module.exports = {
-  ManyToManyUnrelatePostgresOperation,
-};

package/lib/relations/manyToMany/update/ManyToManyUpdatePostgresOperation.js

@@ -1,12 +0,0 @@
-'use strict';
-
-const { ManyToManyUpdateOperationBase } = require('./ManyToManyUpdateOperationBase');
-const { ManyToManyPostgresModifyMixin } = require('../ManyToManyPostgresModifyMixin');
-
-class ManyToManyUpdatePostgresOperation extends ManyToManyPostgresModifyMixin(
-  ManyToManyUpdateOperationBase,
-) {}
-
-module.exports = {
-  ManyToManyUpdatePostgresOperation,
-};

package/lib/utils/deprecate.js

@@ -1,21 +0,0 @@
-'use strict';
-
-const LOGGED_DEPRECATIONS = new Set();
-
-function deprecate(message) {
-  // Only log deprecation messages once.
-  if (!LOGGED_DEPRECATIONS.has(message)) {
-    LOGGED_DEPRECATIONS.add(message);
-    console.warn(message);
-  }
-}
-
-// Only meant for tests that need to see a deprecation message again.
-function resetDeprecations() {
-  LOGGED_DEPRECATIONS.clear();
-}
-
-module.exports = {
-  deprecate,
-  resetDeprecations,
-};