objection 3.7.0 → 3.8.0

package/lib/relations/manyToMany/find/ManyToManyFindOperation.js

@@ -2,7 +2,7 @@
 
 const { RelationFindOperation } = require('../../RelationFindOperation');
 const { getTempColumn } = require('../../../utils/tmpColumnUtils');
-const { deprecate } = require('../../../utils/deprecate');
+const { warnOnce } = require('../../../utils/warnings');
 
 class ManyToManyFindOperation extends RelationFindOperation {
   constructor(name, opt) {
@@ -83,6 +83,11 @@ class ManyToManyFindOperation extends RelationFindOperation {
     return related;
   }
 
+  // @override
+  ownerKeyColumns() {
+    return this.ownerJoinColumnAlias;
+  }
+
   // The related models are assigned to their owners by the owner join columns
   // selected from the join table. If they get lost, e.g. in a custom
   // `$parseDatabaseJson()`, the related models are silently dropped (#2258).
@@ -93,7 +98,7 @@ class ManyToManyFindOperation extends RelationFindOperation {
       const alias = this.ownerJoinColumnAlias[c];
 
       if (related.some((rel) => rel[alias] === undefined)) {
-        deprecate(
+        warnOnce(
           `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
             `some related models are missing the join table column ` +
             `"${joinTableOwnerProp.propDescription(c)}" selected as "${alias}", so they are not ` +

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

@@ -3,9 +3,24 @@
 const { ManyToManyUpdateOperationBase } = require('./ManyToManyUpdateOperationBase');
 const { ManyToManyMySqlModifyMixin } = require('../ManyToManyMySqlModifyMixin');
 
+const LimitSelector = /^(orderBy\w*|limit|offset)$/;
+
 class ManyToManyUpdateMySqlOperation extends ManyToManyMySqlModifyMixin(
   ManyToManyUpdateOperationBase,
-) {}
+) {
+  // MySQL is the only database that supports a limit in updates. Updates that
+  // modify the join rows too update the related rows by their ids, so the limit
+  // and the order pick these ids instead of limiting each batch of them. Without
+  // a limit or an offset, the order picks nothing and the query stays as it is.
+  onBuild(builder) {
+    super.onBuild(builder);
+
+    if (this.relatedIdsQuery && builder.has(/^(limit|offset)$/)) {
+      this.relatedIdsQuery.copyFrom(builder, LimitSelector);
+      builder.clear(LimitSelector);
+    }
+  }
+}
 
 module.exports = {
   ManyToManyUpdateMySqlOperation,

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

@@ -2,6 +2,11 @@
 
 const { UpdateOperation } = require('../../../queryBuilder/operations/UpdateOperation');
 const { addWhereGroup } = require('../../../queryBuilder/whereGroups');
+const { chunk } = require('../../../utils/objectUtils');
+
+// Stay below the limits of bound values per statement of SQLite before 3.32
+// (999) and SQL Server (2100), leaving room for the patched values:
+const maxBatchValues = 500;
 
 class ManyToManyUpdateOperationBase extends UpdateOperation {
   constructor(name, opt) {
@@ -11,6 +16,8 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     this.owner = opt.owner;
 
     this.hasExtraProps = false;
+    this.relatedIdsQuery = null;
+    this.relatedIds = null;
     this.joinTablePatch = {};
     this.joinTablePatchFilterQuery = null;
   }
@@ -50,32 +57,93 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     return res;
   }
 
-  async onAfter1(builder, result) {
-    // A query resolved without updating anything, e.g. with `none()`, leaves
-    // the join rows untouched too.
+  onBuild(builder) {
+    if (this.modifiesJoinTable && this.modifyFilterSubquery) {
+      // The related rows to update are identified by their ids first, see
+      // `onAfterBuild()`.
+      this.relatedIdsQuery = this.createRelatedIdsQuery(builder);
+    }
+
+    return super.onBuild(builder);
+  }
+
+  // Selects the ids of the related rows to update. Fetch raw rows, so that no
+  // hooks run for them.
+  createRelatedIdsQuery(builder) {
+    const relatedIdsQuery = this.relation.relatedModelClass.query().childQueryOf(builder);
+    const idRefs = this.relation.relatedModelClass.getIdRelationProperty().refs(relatedIdsQuery);
+
+    return this.applyModifyFilterForRelatedTable(relatedIdsQuery).select(idRefs);
+  }
+
+  // Update the join rows before the related rows, while the filters still
+  // match them (#161). A query resolved without updating anything, e.g. with
+  // `none()`, leaves the join rows untouched too.
+  async onAfterBuild(builder) {
     if (this.hasExtraProps && !this.isResolvedWithoutUpdate(builder)) {
-      const joinTableUpdateQuery = this.relation
-        .getJoinModelClass(builder.knex())
-        .query()
-        .childQueryOf(builder)
-        .patch(this.joinTablePatch);
+      if (this.relatedIdsQuery) {
+        // The filters can also reference the extras that the join rows change,
+        // so identify the related rows to modify first.
+        const rows = await this.relatedIdsQuery.toKnexQuery();
+        this.relatedIds = rows.map((row) => Object.values(row));
+      }
 
+      if (this.relatedIdsQuery?.has(/^(limit|offset)$/)) {
+        // The filters match the join rows of more related rows than the limit
+        // picks, so only update the join rows of the picked ones.
+        for (const ids of this.relatedIdBatches()) {
+          await this.updateJoinRows(builder, ids);
+        }
+      } else {
+        await this.updateJoinRows(builder);
+      }
+    }
+  }
+
+  updateJoinRows(builder, relatedIds = null) {
+    const joinTableUpdateQuery = this.relation
+      .getJoinModelClass(builder.knex())
+      .query()
+      .childQueryOf(builder)
+      .patch(this.joinTablePatch);
+
+    addWhereGroup(joinTableUpdateQuery, () =>
+      this.skipRelationFilter
+        ? this.applyIdFilterForJoinTable(joinTableUpdateQuery)
+        : this.applyModifyFilterForJoinTable(joinTableUpdateQuery),
+    );
+    if (relatedIds) {
       addWhereGroup(joinTableUpdateQuery, () =>
-        this.skipRelationFilter
-          ? this.applyIdFilterForJoinTable(joinTableUpdateQuery)
-          : this.applyModifyFilterForJoinTable(joinTableUpdateQuery),
-      );
-      addWhereGroup(joinTableUpdateQuery, () =>
-        joinTableUpdateQuery.modify(this.relation.joinTableModify),
+        joinTableUpdateQuery.whereInComposite(
+          this.relation.joinTableRelatedProp.refs(joinTableUpdateQuery),
+          relatedIds,
+        ),
       );
+    }
+    addWhereGroup(joinTableUpdateQuery, () =>
+      joinTableUpdateQuery.modify(this.relation.joinTableModify),
+    );
+
+    return joinTableUpdateQuery;
+  }
 
-      await joinTableUpdateQuery;
-      return result;
+  // Update the related rows in batches of their ids, as databases limit the
+  // number of values in one statement.
+  queryBatches(builder) {
+    if (this.relatedIds) {
+      const batches = this.relatedIdBatches();
+      // Without ids, still execute the query once for the dialect's result:
+      return batches.length > 0 ? batches : [[]];
     } else {
-      return result;
+      return null;
     }
   }
 
+  relatedIdBatches() {
+    const idSize = this.relation.relatedModelClass.getIdRelationProperty().size;
+    return chunk(this.relatedIds, Math.floor(maxBatchValues / idSize));
+  }
+
   // Filters the join rows by the ids of the owner and the updated model.
   applyIdFilterForJoinTable(builder) {
     return builder
@@ -103,6 +171,8 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     const clone = super.clone();
 
     clone.hasExtraProps = this.hasExtraProps;
+    clone.relatedIdsQuery = this.relatedIdsQuery;
+    clone.relatedIds = this.relatedIds;
     clone.joinTablePatch = this.joinTablePatch;
     clone.joinTablePatchFilterQuery = this.joinTablePatchFilterQuery;
 

package/lib/utils/identifierMapping.js

@@ -171,8 +171,8 @@ function keyMapper(mapper) {
 // Returns a function that only calls `mapper` for the part of the input string
 // before the first `separator`, and leaves the rest untouched. For field
 // expressions like `jsonColumn:some.jsonPath` this maps the column but keeps
-// the json path as is. Column names can't contain `:`, so the first one marks
-// the boundary.
+// the json path as is. The mapper doesn't know the schema, so the first `:`
+// marks the boundary also in a declared column name like `ns:name`.
 function mapFirstPart(mapper, separator) {
   return (str) => {
     const idx = str.indexOf(separator);

package/lib/utils/knexUtils.js

@@ -36,6 +36,19 @@ function isMsSql(knex) {
   return getDialect(knex) === 'mssql';
 }
 
+// MySQL supports window functions since 8.0, MariaDB since 10.2. Without a
+// version, knex assumes the latest one, and so do we.
+function hasWindowFunctions(knex) {
+  const { version, isMariaDB } = knex.client;
+
+  if (isMySql(knex) && version) {
+    const [major, minor] = version.split('.').map(Number);
+    return isMariaDB ? major > 10 || (major === 10 && minor >= 2) : major >= 8;
+  } else {
+    return true;
+  }
+}
+
 function isKnexQueryBuilder(value) {
   return (
     hasConstructor(value) &&
@@ -69,6 +82,7 @@ module.exports = {
   isSqlite,
   isMsSql,
   isOracle,
+  hasWindowFunctions,
   isKnexQueryBuilder,
   isKnexJoinBuilder,
   isKnexRaw,

package/lib/utils/parseFieldExpression.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const jsonFieldExpressionParser = require('../queryBuilder/parsers/jsonFieldExpressionParser');
+const { isObject } = require('./objectUtils');
 const cache = new Map();
 
 function parseFieldExpression(expr) {
@@ -46,6 +47,16 @@ function freezeParsedExpr(parsedExpr) {
   return parsedExpr;
 }
 
+// Keys with a ':' in the data of patches and updates are field expressions like
+// `'meta:a.b'` that write into json columns, unless they are `declared`: the
+// `properties` of the schema, or an object with their column names as keys.
+function isFieldExpressionKey(key, declared) {
+  return (
+    key.includes(':') &&
+    !(isObject(declared) && Object.prototype.hasOwnProperty.call(declared, key))
+  );
+}
+
 // Formats the json path of a parsed field expression as a Postgres text array
 // literal, e.g. `{a,"",b}`. Keys that would otherwise be misread (empty keys,
 // keys with whitespace, delimiters, quotes or backslashes and `NULL`) are
@@ -81,6 +92,7 @@ function toPostgresJsonPathLiteral(access) {
 
 module.exports = {
   parseFieldExpression,
+  isFieldExpressionKey,
   toPostgresJsonPath,
   toPostgresJsonPathLiteral,
 };

package/lib/utils/warnings.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const LOGGED_WARNINGS = new Set();
+
+// Log each warning only once.
+function warnOnce(message) {
+  if (!LOGGED_WARNINGS.has(message)) {
+    LOGGED_WARNINGS.add(message);
+    console.warn(`[objection] ${message}`);
+  }
+}
+
+function deprecate(message) {
+  warnOnce(message);
+}
+
+// Only meant for tests that need to see a warning again.
+function resetWarnings() {
+  LOGGED_WARNINGS.clear();
+}
+
+module.exports = {
+  warnOnce,
+  deprecate,
+  resetWarnings,
+};

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.7.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

@@ -1022,8 +1022,11 @@ declare namespace Objection {
   /**
    * 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. The typings can't
-   * tell these apart, so the rows are typed as `any`.
+   * 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[]>;
@@ -1085,6 +1088,10 @@ 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;
   }
 
@@ -1140,6 +1147,7 @@ declare namespace Objection {
     aliases?: { [key: string]: string };
     joinOperation?: string;
     maxBatchSize?: number;
+    limitPerParent?: boolean;
   }
 
   export interface WithGraphOptions extends GraphOptions {

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