objection 3.9.0 → 3.9.1

package/lib/model/graph/ModelGraphNode.js

@@ -143,21 +143,6 @@ class ModelGraphNode {
     return null;
   }
 
-  /**
-   * Returns all nodes that are references to this node.
-   */
-  get referencingNodes() {
-    const nodes = [];
-
-    for (const edge of this.refEdges) {
-      if (edge.refType === ModelGraphEdge.ReferenceType.Object && edge.isRelatedNode(this)) {
-        nodes.push(edge.ownerNode);
-      }
-    }
-
-    return nodes;
-  }
-
   get descendantRelationNodes() {
     return this._collectDescendantRelationNodes([]);
   }

package/lib/model/modelQueryProps.js

@@ -3,9 +3,12 @@
 const { isObject, isFunction, omit } = require('../utils/objectUtils');
 const { defineNonEnumerableProperty } = require('./modelUtils');
 const { isKnexRaw, isKnexQueryBuilder } = require('../utils/knexUtils');
-const { parseFieldExpression, isFieldExpressionKey } = require('../utils/parseFieldExpression');
+const { getFieldExpressionColumn } = require('../utils/parseFieldExpression');
 
 const QUERY_PROPS_PROPERTY = '$$queryProps';
+// The keys of the field expression query properties like `'data:a'` that were
+// given while their json column `data` had a value:
+const COMBINED_QUERY_PROPS_PROPERTY = '$$combinedQueryProps';
 
 // Moves the query properties of `json` into a hidden property of `model` so
 // that they can be later merged back to its database json. A key holds either
@@ -17,13 +20,24 @@ function splitQueryProps(model, json) {
 
   if (!json.$isObjectionModel && hasQueryProps(json, keys)) {
     const queryProps = Object.assign({}, oldQueryProps);
+    const combinedKeys = new Set(model[COMBINED_QUERY_PROPS_PROPERTY]);
     const modelProps = {};
+    const jsonSchema = model.constructor.getJsonSchema();
+    const properties = jsonSchema && jsonSchema.properties;
 
     for (let i = 0, l = keys.length; i < l; ++i) {
       const key = keys[i];
       const value = json[key];
 
       if (isQueryProp(value)) {
+        const column = getFieldExpressionColumn(key, properties);
+
+        if (column !== null && (json[column] !== undefined || model[column] !== undefined)) {
+          combinedKeys.add(key);
+        } else {
+          combinedKeys.delete(key);
+        }
+
         queryProps[key] = value;
         delete model[key];
       } else {
@@ -33,6 +47,7 @@ function splitQueryProps(model, json) {
     }
 
     defineNonEnumerableProperty(model, QUERY_PROPS_PROPERTY, queryProps);
+    defineNonEnumerableProperty(model, COMBINED_QUERY_PROPS_PROPERTY, [...combinedKeys]);
 
     return modelProps;
   } else {
@@ -61,13 +76,16 @@ function removeOverriddenQueryProps(model) {
   if (queryProps) {
     const jsonSchema = model.constructor.getJsonSchema();
     const properties = jsonSchema && jsonSchema.properties;
-    // The json column of a field expression key like `data:a` overrides it too:
-    const keys = Object.keys(queryProps).filter(
-      (key) =>
+    const combinedKeys = model[COMBINED_QUERY_PROPS_PROPERTY] || [];
+    const keys = Object.keys(queryProps).filter((key) => {
+      const column = getFieldExpressionColumn(key, properties);
+      return (
         model[key] !== undefined ||
-        (isFieldExpressionKey(key, properties) &&
-          model[parseFieldExpression(key).column] !== undefined),
-    );
+        // The json column of a field expression key like `data:a` overrides it
+        // too, unless it was given while the column had a value (#206):
+        (column !== null && !combinedKeys.includes(key) && model[column] !== undefined)
+      );
+    });
 
     if (keys.length > 0) {
       defineNonEnumerableProperty(model, QUERY_PROPS_PROPERTY, omit(queryProps, keys));
@@ -75,6 +93,15 @@ function removeOverriddenQueryProps(model) {
   }
 }
 
+// Removes the values that the hooks of a write set for the keys that `model`
+// holds query properties for. The query properties are written instead, so the
+// values must not count as given in later writes.
+function removeOverriddenValues(model) {
+  for (const key of getQueryPropKeys(model)) {
+    delete model[key];
+  }
+}
+
 function hasQueryProps(json, keys) {
   for (let i = 0, l = keys.length; i < l; ++i) {
     if (isQueryProp(json[keys[i]])) {
@@ -192,6 +219,7 @@ module.exports = {
   splitQueryProps,
   omitQueryProps,
   removeOverriddenQueryProps,
+  removeOverriddenValues,
   mergeQueryProps,
   getQueryPropKeys,
   isQueryProp,

package/lib/model/modelToJson.js

@@ -3,7 +3,7 @@
 const { isInternalProp } = require('../utils/internalPropUtils');
 const { mergeQueryProps } = require('./modelQueryProps');
 const { isObject, hasOwn, cloneDeep, isFunction } = require('../utils/objectUtils');
-const { parseFieldExpression, isFieldExpressionKey } = require('../utils/parseFieldExpression');
+const { getFieldExpressionColumn } = require('../utils/parseFieldExpression');
 const EMPTY_ARRAY = [];
 
 function toJson(model, optIn) {
@@ -140,16 +140,8 @@ function shouldPick(opt, key) {
 
 // Pick field expressions like `'meta:a'` by their json column.
 function isPickedFieldExpression(pick, key) {
-  if (isFieldExpressionKey(key, pick)) {
-    try {
-      return hasOwn(pick, parseFieldExpression(key).column);
-    } catch (err) {
-      // Not a valid field expression.
-      return false;
-    }
-  } else {
-    return false;
-  }
+  const column = getFieldExpressionColumn(key, pick);
+  return column !== null && hasOwn(pick, column);
 }
 
 function assignVirtualAttributes(json, model, vAttr, opt) {

package/lib/model/modelUtils.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const hiddenProps = ['$$queryProps'];
+const hiddenProps = ['$$queryProps', '$$combinedQueryProps'];
 
 const staticHiddenProps = [
   '$$knex',

package/lib/queryBuilder/graph/GraphFetcher.js

@@ -5,7 +5,7 @@ const { ModelGraph } = require('../../model/graph/ModelGraph');
 const { FetchStrategy } = require('./GraphOptions');
 const { RelationExpression } = require('../RelationExpression');
 const { getDeclaredColumns } = require('../operations/UpdateOperation');
-const { parseFieldExpression, isFieldExpressionKey } = require('../../utils/parseFieldExpression');
+const { getFieldExpressionColumn } = require('../../utils/parseFieldExpression');
 
 class GraphFetcher {
   /**
@@ -112,9 +112,7 @@ function createInputColumnSelector(nodes) {
 
       for (const key of Object.keys(databaseJson)) {
         // Select the json column of field expressions like `'meta:a'`:
-        const column = isFieldExpressionKey(key, declaredColumns)
-          ? parseFieldExpression(key).column
-          : key;
+        const column = getFieldExpressionColumn(key, declaredColumns) ?? key;
 
         if (!shouldSelectColumn(column, selects, node)) {
           continue;

package/lib/queryBuilder/graph/GraphUpsert.js

@@ -472,12 +472,16 @@ function executeOperations(builder) {
           GraphRecursiveUpsert,
         ];
 
-    return operations.reduce((promise, Operation) => {
-      const operation = new Operation(graphData);
-      const actions = operation.createActions();
+    // Create all actions before chaining the first ones, which would run even
+    // if creating the actions of a later operation throws, e.g. for a cycle.
+    const operationActions = operations.map((Operation) =>
+      new Operation(graphData).createActions(),
+    );
 
-      return promise.then(() => executeActions(builder, actions));
-    }, Promise.resolve());
+    return operationActions.reduce(
+      (promise, actions) => promise.then(() => executeActions(builder, actions)),
+      Promise.resolve(),
+    );
   };
 }
 

package/lib/queryBuilder/graph/insert/DeferredRelationGraphInsertAction.js

@@ -7,9 +7,8 @@ const promiseUtils = require('../../../utils/promiseUtils');
 /**
  * Patches in the foreign keys of `BelongsToOneRelation` edges that `GraphInsert`
  * had to defer to break a dependency cycle. The owner nodes of these edges were
- * inserted without the foreign keys. `GraphInsertAction` already copied them to
- * the owner objects once the related nodes were inserted, so all that's left to
- * do is one patch query per owner.
+ * inserted without the foreign keys, which are copied from the related nodes
+ * and patched in with one query per owner.
  */
 class DeferredRelationGraphInsertAction extends GraphAction {
   constructor(graphData, { edges }) {
@@ -36,11 +35,13 @@ class DeferredRelationGraphInsertAction extends GraphAction {
     const ownerIdProp = modelClass.getIdRelationProperty();
     const patch = {};
 
-    for (const { relation } of edges) {
-      const { ownerProp } = relation;
+    for (const { relation, relatedNode } of edges) {
+      const { ownerProp, relatedProp } = relation;
 
       ownerProp.forEach((i) => {
-        ownerProp.patch(patch, i, ownerProp.getProp(ownerNode.obj, i));
+        const value = relatedProp.getProp(relatedNode.obj, i);
+        ownerProp.setProp(ownerNode.obj, i, value);
+        ownerProp.patch(patch, i, value);
       });
     }
 

package/lib/queryBuilder/graph/insert/GraphInsert.js

@@ -83,10 +83,23 @@ class GraphInsert extends GraphOperation {
       // new ones. We need to pass all nodes to `GraphInsertActions` so that we
       // can resolve all dependencies.
       const nodesToInsert = this.graph.nodes.filter((node) => {
-        return !this._isHandled(node, handledNodes) && !this._hasDependencies(node, handledNodes);
+        return (
+          !node.isReference && !handledNodes.has(node) && !this._hasDependencies(node, handledNodes)
+        );
       });
 
-      if (nodesToInsert.length === 0) {
+      // `#ref` nodes aren't inserted, so they can be resolved in the same
+      // action as the nodes they depend on, once these are inserted.
+      const insertedNodes = new Set([...handledNodes, ...nodesToInsert]);
+      const refNodes = this.graph.nodes.filter((node) => {
+        return (
+          node.isReference && !handledNodes.has(node) && !this._hasDependencies(node, insertedNodes)
+        );
+      });
+
+      const nodes = [...nodesToInsert, ...refNodes];
+
+      if (nodes.length === 0) {
         if (handledNodes.size !== this.graph.nodes.length && this._breakCycle(handledNodes)) {
           continue;
         }
@@ -97,13 +110,14 @@ class GraphInsert extends GraphOperation {
       actions.push(
         new GraphInsertAction(this.graphData, {
           nodes: nodesToInsert,
+          refNodes,
           dependencies: this.dependencies,
           deferredEdges: this.deferredEdges,
         }),
       );
 
-      for (const node of nodesToInsert) {
-        this._markHandled(node, handledNodes);
+      for (const node of nodes) {
+        handledNodes.add(node);
       }
     }
 
@@ -121,7 +135,7 @@ class GraphInsert extends GraphOperation {
   // `#ref` nodes, since the graph is a tree otherwise.
   _breakCycle(handledNodes) {
     for (const node of this.graph.nodes) {
-      if (this._isHandled(node, handledNodes)) {
+      if (handledNodes.has(node)) {
         continue;
       }
 
@@ -200,16 +214,12 @@ class GraphInsert extends GraphOperation {
     ];
   }
 
-  _isHandled(node, handledNodes) {
-    return handledNodes.has(node);
-  }
-
   _hasDependencies(node, handledNodes) {
     return this._pendingDependencyEdges(node, handledNodes).length > 0;
   }
 
   // Returns the dependency edges of `node` whose other node still needs to be
-  // inserted first. Deferred edges are ignored.
+  // handled first. Deferred edges are ignored.
   _pendingDependencyEdges(node, handledNodes) {
     const edges = this.dependencies.get(node) || [];
 
@@ -219,22 +229,51 @@ class GraphInsert extends GraphOperation {
       return (
         !this.deferredEdges.has(edge) &&
         !handledNodes.has(dependencyNode) &&
-        !this.currentGraph.nodeForNode(dependencyNode)
+        (!this.currentGraph.nodeForNode(dependencyNode) ||
+          this._readsFilledProps(edge, dependencyNode))
       );
     });
   }
 
-  _markHandled(node, handledNodes) {
-    handledNodes.add(node);
-
-    // The referencing nodes are all references that don't
-    // represent any real entity. They are simply intermediate nodes
-    // that depend on this node. Once this node is handled, we can
-    // also mark those nodes as handled as there is nothing to actually
-    // insert.
-    for (const refNode of node.referencingNodes) {
-      this._markHandled(refNode, handledNodes);
+  // Returns true if the reference `edge` reads props that the graph fills into
+  // `node`. The keys of existing models are known right away, but these props
+  // only once they're filled in (#356).
+  _readsFilledProps(edge, node) {
+    if (edge.type === ModelGraphEdge.Type.Relation) {
+      return false;
     }
+
+    const filledProps = this._getFilledProps(node);
+    // A `#ref` node stands in for `node` in its relations, which read only
+    // their keys from it:
+    const readProps =
+      edge.refType === ModelGraphEdge.ReferenceType.Property
+        ? [edge.refRelatedDataPath[0]]
+        : this._getRelationProps(edge.ownerNode.edges, edge.ownerNode);
+
+    return readProps.some((prop) => filledProps.includes(prop));
+  }
+
+  // Returns the props of `node` that the graph fills in from other models,
+  // through its relations and its property references.
+  _getFilledProps(node) {
+    const edges = this.dependencies.get(node) || [];
+
+    return [
+      ...this._getRelationProps(edges, node),
+      ...edges
+        .filter((edge) => edge.refType === ModelGraphEdge.ReferenceType.Property)
+        .map((edge) => edge.refOwnerDataPath[0]),
+    ];
+  }
+
+  // Returns the props of `node` that the relation edges among `edges` join on.
+  _getRelationProps(edges, node) {
+    return edges
+      .filter((edge) => edge.type === ModelGraphEdge.Type.Relation)
+      .flatMap((edge) => {
+        return (edge.isOwnerNode(node) ? edge.relation.ownerProp : edge.relation.relatedProp).props;
+      });
   }
 
   _createJoinRowActions() {

package/lib/queryBuilder/graph/insert/GraphInsertAction.js

@@ -14,22 +14,24 @@ const promiseUtils = require('../../../utils/promiseUtils');
  * when needed.
  */
 class GraphInsertAction extends GraphAction {
-  constructor(graphData, { nodes, dependencies, deferredEdges }) {
+  constructor(graphData, { nodes, refNodes, dependencies, deferredEdges }) {
     super(graphData);
 
-    // Nodes to insert.
+    // Nodes to insert, and `#ref` nodes to resolve once they are inserted.
     this.nodes = nodes;
+    this.refNodes = refNodes;
     this.dependencies = dependencies;
     // Dependency edges that are resolved once the dependency node has been
     // inserted, and are patched in by `DeferredRelationGraphInsertAction`.
     this.deferredEdges = deferredEdges;
   }
 
-  run(builder) {
+  async run(builder) {
     const batches = this._createInsertBatches(builder);
     const concurrency = this._getConcurrency(builder, this.nodes);
 
-    return promiseUtils.map(batches, (batch) => this._insertBatch(builder, batch), { concurrency });
+    await promiseUtils.map(batches, (batch) => this._insertBatch(builder, batch), { concurrency });
+    this._resolveDependencies(this.refNodes);
   }
 
   _createInsertBatches(builder) {
@@ -49,7 +51,6 @@ class GraphInsertAction extends GraphAction {
   async _insertBatch(parentBuilder, nodes) {
     await this._beforeInsert(nodes);
     await this._insert(parentBuilder, nodes);
-    await this._afterInsert(nodes);
   }
 
   _beforeInsert(nodes) {
@@ -82,6 +83,8 @@ class GraphInsertAction extends GraphAction {
   _resolveDependency(dependencyNode, edge) {
     if (edge.type === ModelGraphEdge.Type.Relation && !edge.relation.joinTable) {
       this._resolveRelationDependency(dependencyNode, edge);
+    } else if (edge.refType === ModelGraphEdge.ReferenceType.Object) {
+      this._resolveReferences(edge.getOtherNode(dependencyNode));
     } else if (edge.refType === ModelGraphEdge.ReferenceType.Property) {
       this._resolvePropertyReferenceNode(dependencyNode, edge);
     }
@@ -219,14 +222,6 @@ class GraphInsertAction extends GraphAction {
       }),
     );
   }
-
-  _afterInsert(nodes) {
-    for (const node of nodes) {
-      for (const refNode of node.referencingNodes) {
-        this._resolveDependency(refNode, refNode.parentEdge);
-      }
-    }
-  }
 }
 
 function getModelClass(node) {

package/lib/queryBuilder/graph/patch/GraphPatchAction.js

@@ -31,6 +31,14 @@ class GraphPatchAction extends GraphAction {
     // properties. That's why we handle them here.
     const changePropsBecauseOfBelongsToOneDelete = this._handleBelongsToOneDeletes(node);
 
+    // HasManyRelation and HasOneRelation relates write the related object's
+    // foreign keys, also with `noUpdate`.
+    const changedPropsBecauseOfRelate =
+      this.graphOptions.shouldRelate(node, this.graphData) &&
+      node.parentEdge.relation.isObjectionHasManyRelation
+        ? node.parentEdge.relation.relatedProp.props
+        : [];
+
     const handleUpdate = () => {
       const { changedProps, unchangedProps } = this._findChanges(node);
       const allProps = [...changedProps, ...unchangedProps];
@@ -38,7 +46,11 @@ class GraphPatchAction extends GraphAction {
       const propsToUpdate = difference(
         shouldPatch || shouldUpdate
           ? changedProps
-          : [...changedPropsBecauseOfBelongsToOneInsert, ...changePropsBecauseOfBelongsToOneDelete],
+          : [
+              ...changedPropsBecauseOfBelongsToOneInsert,
+              ...changePropsBecauseOfBelongsToOneDelete,
+              ...changedPropsBecauseOfRelate,
+            ],
 
         // Remove id properties from the props to update. With upsertGraph
         // it never makes sense to change the id.

package/lib/queryBuilder/operations/DeleteOperation.js

@@ -11,9 +11,16 @@ class DeleteOperation extends QueryBuilderOperation {
     return result;
   }
 
-  // knex leaves the order out of deletes on MySQL, but keeps their limit, so
-  // the order doesn't pick the deleted rows. Warn when the query is executed.
+  // knex leaves the offset out of deletes. On MySQL, it leaves out the order as
+  // well, but keeps the limit, so the order doesn't pick the deleted rows. Warn
+  // when the query is executed.
   onAfterBuild(builder) {
+    if (builder.has('offset')) {
+      warnOnce(
+        'offset() has no effect in delete queries, so no rows are skipped. ' +
+          'This will throw an error in objection 4.0.',
+      );
+    }
     if (isMySql(builder.knex()) && builder.has('limit') && builder.has(/^orderBy/)) {
       warnOnce(
         'orderBy() has no effect in delete queries with limit() on MySQL, so the limit ' +

package/lib/queryBuilder/operations/InsertOperation.js

@@ -5,6 +5,7 @@ const { StaticHookArguments } = require('../StaticHookArguments');
 const { after, mapAfterAllReturn } = require('../../utils/promiseUtils');
 const { isSqlite, isMySql, hasBatchInsert } = require('../../utils/knexUtils');
 const { isObject, isString } = require('../../utils/objectUtils');
+const { removeOverriddenValues } = require('../../model/modelQueryProps');
 
 // Base class for all insert operations.
 class InsertOperation extends QueryBuilderOperation {
@@ -31,6 +32,7 @@ class InsertOperation extends QueryBuilderOperation {
       throw new Error('batch insert only works with Postgresql and SQL Server');
     } else {
       await callBeforeInsert(builder, this.models);
+      this.models.forEach(removeOverriddenValues);
       return result;
     }
   }

package/lib/queryBuilder/operations/UpdateOperation.js

@@ -11,6 +11,8 @@ const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 const { warnIfNotPostgres } = require('./jsonApi/postgresJsonApi');
 const { StaticHookArguments } = require('../StaticHookArguments');
 const { ValidationErrorType } = require('../../model/ValidationError');
+const { removeOverriddenValues } = require('../../model/modelQueryProps');
+const { warnOnce } = require('../../utils/warnings');
 
 class UpdateOperation extends QueryBuilderOperation {
   constructor(name, opt) {
@@ -31,6 +33,7 @@ class UpdateOperation extends QueryBuilderOperation {
 
   async onBefore2(builder, result) {
     await callBeforeUpdate(builder, this.model, this.modelOptions);
+    removeOverriddenValues(this.model);
     return result;
   }
 
@@ -52,6 +55,17 @@ class UpdateOperation extends QueryBuilderOperation {
     return builder.isExplicitlyResolvedOrRejected() && !this.hasNothingToUpdate;
   }
 
+  // knex leaves the offset out of updates, and on SQL Server the limit as well.
+  // Warn when the query is executed.
+  onAfterBuild(builder) {
+    if (builder.has('offset')) {
+      warnOnce(
+        'offset() has no effect in update queries, so no rows are skipped, and on SQL Server ' +
+          'limit() is ignored too. This will throw an error in objection 4.0.',
+      );
+    }
+  }
+
   onBuildKnex(knexBuilder, builder) {
     const json = this.model.$toDatabaseJson(builder);
     const convertedJson = convertFieldExpressionsToRaw(builder, this.model, json);

package/lib/relations/hasMany/HasManyInsertOperation.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { RelationInsertOperation } = require('../RelationInsertOperation');
+const { removeOverriddenQueryProps } = require('../../model/modelQueryProps');
 
 class HasManyInsertOperation extends RelationInsertOperation {
   onAdd(builder, args) {
@@ -14,6 +15,9 @@ class HasManyInsertOperation extends RelationInsertOperation {
       for (let j = 0, lp = relatedProp.size; j < lp; ++j) {
         relatedProp.setProp(model, j, ownerValues[0][j]);
       }
+
+      // The foreign keys set here beat query properties given for them:
+      removeOverriddenQueryProps(model);
     }
 
     return retVal;

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

@@ -10,6 +10,8 @@ const { isMySql, isMsSql } = require('../../../utils/knexUtils');
 const maxBatchValues = 500;
 
 const LimitSelector = /^(orderBy\w*|limit|offset)$/;
+// Without underscores, so that column name mappers don't change it.
+const relatedPropColumn = 'objectiontmprelated';
 
 class ManyToManyUpdateOperationBase extends UpdateOperation {
   constructor(name, opt) {
@@ -85,14 +87,23 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
   // Selects the ids of the related rows to update. Fetch raw rows, so that no
   // hooks run for them.
   createRelatedIdsQuery(builder, hasLimit) {
-    const { relatedModelClass } = this.relation;
+    const { relatedModelClass, relatedProp } = this.relation;
 
     if (hasLimit) {
       // The limit picks related rows, not join rows, so filter the related
-      // table by the ids of the matching join rows:
+      // table by the ids of the matching join rows. The join rows refer to the
+      // related rows by their `relatedProp`, which isn't necessarily their id
+      // (#360). We select it after the ids, aliased as it can be the same
+      // columns:
       const relatedIdsQuery = relatedModelClass.query().childQueryOf(builder);
       const idRefs = relatedModelClass.getIdRelationProperty().refs(relatedIdsQuery);
-      return this.applyModifyFilterForRelatedTable(relatedIdsQuery).select(idRefs);
+      const relatedPropRefs = relatedProp
+        .refs(relatedIdsQuery)
+        .map((ref, index) => ref.as(`${relatedPropColumn}${index}`));
+      return this.applyModifyFilterForRelatedTable(relatedIdsQuery).select([
+        ...idRefs,
+        ...relatedPropRefs,
+      ]);
     } else {
       // Select the ids from the filter subquery itself. Filtering the related
       // table by them again lets Postgres pick plans that run the subquery
@@ -107,20 +118,30 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
   // match them (#161). A query resolved without updating anything, e.g. with
   // `none()`, leaves the join rows untouched too.
   async onAfterBuild(builder) {
+    // An offset that `onBuild()` moved to the ids query is honoured, and
+    // doesn't warn.
+    super.onAfterBuild(builder);
     if (this.hasExtraProps && !this.isResolvedWithoutUpdate(builder)) {
+      let relatedValues = null;
       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));
+        const values = rows.map((row) => Object.values(row));
+        const { size } = this.relation.relatedModelClass.getIdRelationProperty();
+        this.relatedIds = values.map((row) => row.slice(0, size));
+        if (this.relatedIdsQuery.has(/^(limit|offset)$/)) {
+          relatedValues = values.map((row) => row.slice(size));
+        }
       }
 
       let numJoinRowsUpdated;
-      if (this.relatedIdsQuery?.has(/^(limit|offset)$/)) {
+      if (relatedValues) {
         // 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);
+        // picks, so only update the join rows of the picked ones, by the
+        // `relatedProp` values that follow their ids.
+        for (const values of chunkKeys(relatedValues, this.relation.relatedProp.size)) {
+          await this.updateJoinRows(builder, values);
         }
       } else {
         numJoinRowsUpdated = await this.updateJoinRows(builder);
@@ -136,7 +157,7 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     }
   }
 
-  updateJoinRows(builder, relatedIds = null) {
+  updateJoinRows(builder, relatedValues = null) {
     const joinTableUpdateQuery = this.relation
       .getJoinModelClass(builder.knex())
       .query()
@@ -148,11 +169,11 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
         ? this.applyIdFilterForJoinTable(joinTableUpdateQuery)
         : this.applyModifyFilterForJoinTable(joinTableUpdateQuery),
     );
-    if (relatedIds) {
+    if (relatedValues) {
       addWhereGroup(joinTableUpdateQuery, () =>
         joinTableUpdateQuery.whereInComposite(
           this.relation.joinTableRelatedProp.refs(joinTableUpdateQuery),
-          relatedIds,
+          relatedValues,
         ),
       );
     }
@@ -167,7 +188,10 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
   // number of values in one statement.
   queryBatches(builder) {
     if (this.relatedIds) {
-      const batches = this.relatedIdBatches();
+      const batches = chunkKeys(
+        this.relatedIds,
+        this.relation.relatedModelClass.getIdRelationProperty().size,
+      );
       // Without ids, still execute the query once for the dialect's result:
       return batches.length > 0 ? batches : [[]];
     } else {
@@ -175,11 +199,6 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     }
   }
 
-  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
@@ -216,6 +235,10 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
   }
 }
 
+function chunkKeys(keys, size) {
+  return chunk(keys, Math.floor(maxBatchValues / size));
+}
+
 module.exports = {
   ManyToManyUpdateOperationBase,
 };

package/lib/utils/parseFieldExpression.js

@@ -54,6 +54,20 @@ function isFieldExpressionKey(key, declared) {
   return key.includes(':') && !(isObject(declared) && hasOwn(declared, key));
 }
 
+// Returns the json column of a field expression key like `'meta:a'`, or `null`
+// if the key isn't a field expression or doesn't parse as one.
+function getFieldExpressionColumn(key, declared) {
+  if (isFieldExpressionKey(key, declared)) {
+    try {
+      return parseFieldExpression(key).column;
+    } catch (err) {
+      return null;
+    }
+  } else {
+    return null;
+  }
+}
+
 // 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
@@ -90,6 +104,7 @@ function toPostgresJsonPathLiteral(access) {
 module.exports = {
   parseFieldExpression,
   isFieldExpressionKey,
+  getFieldExpressionColumn,
   toPostgresJsonPath,
   toPostgresJsonPathLiteral,
 };

package/lib/utils/promiseUtils/map.js

@@ -43,7 +43,8 @@ function mapMany(items, mapper, opt = {}) {
     const ctx = {
       reject,
       resolve,
-      rejected: false,
+      failed: false,
+      error: null,
       index: 0,
       numFinished: 0,
       results: new Array(items.length),
@@ -51,7 +52,7 @@ function mapMany(items, mapper, opt = {}) {
       mapper,
     };
 
-    while (ctx.index < concurrency && ctx.index < items.length && !ctx.rejected) {
+    while (ctx.index < concurrency && ctx.index < items.length && !ctx.failed) {
       executeNext(ctx);
     }
   });
@@ -59,7 +60,7 @@ function mapMany(items, mapper, opt = {}) {
 
 function executeNext(ctx) {
   try {
-    if (ctx.rejected) {
+    if (ctx.failed) {
       return;
     }
 
@@ -82,12 +83,14 @@ function executeNext(ctx) {
 }
 
 function afterExecute(ctx, result, index) {
-  if (ctx.rejected) {
+  ctx.numFinished++;
+
+  if (ctx.failed) {
+    rejectWhenFinished(ctx);
     return null;
   }
 
   ctx.results[index] = result;
-  ctx.numFinished++;
 
   if (ctx.numFinished === ctx.items.length) {
     ctx.resolve(ctx.results);
@@ -101,8 +104,22 @@ function afterExecute(ctx, result, index) {
 }
 
 function onError(ctx, err) {
-  ctx.rejected = true;
-  ctx.reject(err);
+  ctx.numFinished++;
+
+  if (!ctx.failed) {
+    ctx.failed = true;
+    ctx.error = err;
+  }
+
+  rejectWhenFinished(ctx);
+}
+
+// Wait for all started mappers before rejecting: They may run queries in a
+// transaction that the caller rolls back on rejection.
+function rejectWhenFinished(ctx) {
+  if (ctx.numFinished === ctx.index) {
+    ctx.reject(ctx.error);
+  }
 }
 
 module.exports = {

package/lib/utils/wrapDbError.js

@@ -8,6 +8,15 @@ const MSSQL_PRIMARY_KEY_REGEX =
   /Violation of PRIMARY KEY constraint '(.+)'\. Cannot insert duplicate key in object '(.+)\.(.+)'\. The duplicate key value is \((.+)\)/;
 
 function wrapDbError(err) {
+  // 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)) {
+    const wrapped = new DBError({ nativeError: err, client: 'mssql' });
+    wrapped.message += err.errors.map((error) => error.message).join(' ');
+    return wrapped;
+  }
+
   if (!isTediousError(err)) {
     return wrapError(err);
   }
@@ -45,6 +54,11 @@ function isTediousError(err) {
   return err?.code === 'EREQUEST' && Number.isInteger(err.number);
 }
 
+// Check the name, as AggregateError isn't defined on Node 14.
+function isTediousAggregateError(err) {
+  return err?.name === 'AggregateError' && err.errors.every(isTediousError);
+}
+
 module.exports = {
   wrapDbError,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objection",
-  "version": "3.9.0",
+  "version": "3.9.1",
   "description": "An SQL-friendly ORM for Node.js",
   "main": "lib/objection.js",
   "license": "MIT",