objection 3.5.0 → 3.7.0

package/README.md

@@ -36,9 +36,9 @@ What objection.js **doesn't** give you:
   For simple things it is useful that the database schema is automatically generated from the model definitions,
   but usually just gets in your way when doing anything non-trivial. Objection.js leaves the schema related things
   to you. knex has a great [migration tool](https://knexjs.org/guide/migrations.html) that we recommend for this job. Check
-  out the [example project](https://github.com/Vincit/objection.js/tree/main/examples/koa-ts).
+  out the [example project](https://github.com/ditojs/objection/tree/main/examples/koa-ts).
 
-The best way to get started is to clone our [example project](https://github.com/Vincit/objection.js/tree/main/examples/koa) and start playing with it. There's also a [typescript version](https://github.com/Vincit/objection.js/tree/main/examples/koa-ts) available.
+The best way to get started is to clone our [example project](https://github.com/ditojs/objection/tree/main/examples/koa) and start playing with it. There's also a [typescript version](https://github.com/ditojs/objection/tree/main/examples/koa-ts) available.
 
 Check out [this issue](https://github.com/Vincit/objection.js/issues/1069) to see who is using objection and what they think about it.
 
@@ -46,7 +46,7 @@ Shortcuts:
 
 - [Who uses objection.js](https://github.com/Vincit/objection.js/discussions/2464)
 - [API reference](https://ditojs.github.io/objection/api/query-builder/)
-- [Example projects](https://github.com/Vincit/objection.js/tree/main/examples)
+- [Example projects](https://github.com/ditojs/objection/tree/main/examples)
 - [Changelog](https://ditojs.github.io/objection/release-notes/changelog.html)
 - [v1 -> v2 -> v3 migration guide](https://ditojs.github.io/objection/release-notes/migration.html)
 - [Contribution guide](https://ditojs.github.io/objection/guide/contributing.html)

package/lib/model/AjvValidator.js

@@ -215,7 +215,22 @@ class AjvValidator extends Validator {
       this.setupAjv(this.ajvQueryProps);
     }
 
-    return this.ajvQueryProps.compile(jsonSchema);
+    for (;;) {
+      try {
+        return this.ajvQueryProps.compile(jsonSchema);
+      } catch (err) {
+        // The schemas of other model classes that `$ref`s point to aren't added
+        // to this instance. Copy them over from the normal instance when needed.
+        const validator =
+          err instanceof Ajv.MissingRefError && this.ajv.getSchema(err.missingSchema);
+
+        if (!validator) {
+          throw err;
+        }
+
+        this.ajvQueryProps.addSchema(validator.schema, err.missingSchema);
+      }
+    }
   }
 }
 
@@ -357,7 +372,9 @@ function fieldExpressionPath(key) {
     return [key];
   }
 
-  if (parsed.access.some((access) => access.type !== 'object')) {
+  // Numeric keys like the `0` in `tags:0` also access array elements when the
+  // json value is an array, so treat them like `[0]`.
+  if (parsed.access.some((access) => access.type !== 'object' || /^-?\d+$/.test(access.ref))) {
     return null;
   }
 
@@ -470,6 +487,11 @@ function jsonSchemaWithoutRequiredKeys(jsonSchema, keys) {
 }
 
 function jsonSchemaWithoutRequired(jsonSchema) {
+  // Boolean schemas (`true` / `false`) have no `required` to strip.
+  if (!isObject(jsonSchema)) {
+    return jsonSchema;
+  }
+
   // `not` is intentionally left untouched: Stripping `required` inside it
   // would turn it into a schema that rejects everything (e.g.
   // `not: { required: ['a'] }` -> `not: {}`). Kept as is, it still holds for
@@ -506,17 +528,18 @@ function definitionsWithoutRequired(jsonSchema, prop) {
 }
 
 function subSchemaWithoutRequired(jsonSchema, prop) {
-  if (jsonSchema[prop]) {
+  if (jsonSchema[prop] !== undefined) {
     if (Array.isArray(jsonSchema[prop])) {
       const schemaArray = jsonSchema[prop].map(jsonSchemaWithoutRequired);
-      const nonEmptySchemaArray = schemaArray.filter(isNotEmptyObject);
+      const nonEmptySchemaArray = schemaArray.filter((schema) => !matchesAnything(schema));
 
       // An `anyOf` or `oneOf` option that only consisted of `required` is
       // empty once `required` is stripped, and an empty schema matches any
-      // patch, just like the stripped `required` keywords elsewhere. Drop the
-      // whole keyword then: requiring the patch to match one of the remaining
-      // options would reject valid patches, and with `oneOf` keeping the empty
-      // option would fail every patch that also matches another option.
+      // patch, just like the stripped `required` keywords elsewhere and the
+      // `true` schema. Drop the whole keyword then: requiring the patch to
+      // match one of the remaining options would reject valid patches, and
+      // with `oneOf` keeping the empty option would fail every patch that also
+      // matches another option.
       if (prop !== 'allOf' && nonEmptySchemaArray.length !== schemaArray.length) {
         return {};
       } else if (nonEmptySchemaArray.length !== 0) {
@@ -548,8 +571,8 @@ function subSchemaWithoutRequired(jsonSchema, prop) {
   }
 }
 
-function isNotEmptyObject(obj) {
-  return Object.keys(obj).length !== 0;
+function matchesAnything(schema) {
+  return schema === true || (isObject(schema) && Object.keys(schema).length === 0);
 }
 
 module.exports = {

package/lib/model/modelClone.js

@@ -81,8 +81,6 @@ function cloneObject(value) {
     return cloneArray(value);
   } else if (value.$isObjectionModel) {
     return clone(value, false, false);
-  } else if (Buffer.isBuffer(value)) {
-    return new Buffer(value);
   } else {
     return cloneDeep(value);
   }

package/lib/queryBuilder/InternalOptions.js

@@ -6,6 +6,7 @@ class InternalOptions {
     this.keepImplicitJoinProps = false;
     this.returnImmediatelyValue = undefined;
     this.isInternalQuery = false;
+    this.skipRelationFilter = false;
     this.debug = false;
     this.schema = undefined;
   }
@@ -17,6 +18,7 @@ class InternalOptions {
     copy.keepImplicitJoinProps = this.keepImplicitJoinProps;
     copy.returnImmediatelyValue = this.returnImmediatelyValue;
     copy.isInternalQuery = this.isInternalQuery;
+    copy.skipRelationFilter = this.skipRelationFilter;
     copy.debug = this.debug;
     copy.schema = this.schema;
 

package/lib/queryBuilder/QueryBuilder.js

@@ -8,6 +8,7 @@ const { ValidationErrorType } = require('../model/ValidationError');
 const { isObject, isString, isFunction, last, flatten } = require('../utils/objectUtils');
 const { RelationExpression, DuplicateRelationError } = require('./RelationExpression');
 const { assertIdNotUndefined, assertHasIdColumn } = require('../utils/assert');
+const { deprecate } = require('../utils/deprecate');
 
 const { Selection } = require('./operations/select/Selection');
 
@@ -176,7 +177,7 @@ class QueryBuilder extends QueryBuilderBase {
   }
 
   isExplicitlyResolvedOrRejected() {
-    return !!(this._explicitRejectValue || this._explicitResolveValue);
+    return this._explicitRejectValue !== null || this._explicitResolveValue !== null;
   }
 
   isExecutable() {
@@ -261,7 +262,14 @@ class QueryBuilder extends QueryBuilderBase {
     eagerOp.graphOptions = { ...eagerOp.graphOptions, ...graphOptions };
 
     if (joinOperation) {
-      eagerOp.joinOperations.push({ expression: parsedExp, joinOperation });
+      if (eagerOp instanceof JoinEagerOperation) {
+        eagerOp.joinOperations.push({ expression: parsedExp, joinOperation });
+      } else {
+        deprecate(
+          'The joinOperation option only applies to withGraphJoined() and is ignored for the ' +
+            `fetched relations "${parsedExp.toString()}".`,
+        );
+      }
     }
 
     checkMixedEager(this);
@@ -501,17 +509,31 @@ class QueryBuilder extends QueryBuilderBase {
       await joinEagerOp.onBefore3(builder);
     }
 
-    const countQuery = knex.count('* as count').from((knexBuilder) => {
-      // Also clear the order on the built knex query, since `orderBy` calls
-      // can be added at build time, e.g. by a relation's `modify`.
-      knexBuilder = builder.toKnexQuery(knexBuilder).clearOrder();
+    // Also clear the order on the built knex query, since `orderBy` calls
+    // can be added at build time, e.g. by a relation's `modify`.
+    const buildQuery = (knexBuilder) => builder.toKnexQuery(knexBuilder).clearOrder();
 
-      if (joinEagerOp) {
+    const countQuery = knex.count('* as count').from((knexBuilder) => {
+      if (!joinEagerOp) {
+        buildQuery(knexBuilder);
+      } else {
         // The joins of `withGraphJoined` return one row per joined child.
         // Count the distinct root models instead.
-        const tableRef = builder.tableRef();
         const idColumns = builder.modelClass().getIdColumnArray();
-        knexBuilder.clearSelect().distinct(idColumns.map((col) => `${tableRef}.${col}`));
+
+        if (refersToSelections(builder)) {
+          // `having`, and `groupBy` with an alias, may refer to aliased
+          // selections, so keep them and select the distinct ids from the
+          // result instead.
+          knexBuilder.distinct(idColumns).from((knexBuilder) => {
+            buildQuery(knexBuilder).as('inner');
+          });
+        } else {
+          const tableRef = builder.tableRef();
+          buildQuery(knexBuilder)
+            .clearSelect()
+            .distinct(idColumns.map((col) => `${tableRef}.${col}`));
+        }
       }
 
       knexBuilder.as('temp');
@@ -1171,6 +1193,29 @@ function getEagerAlgorithmByName(builder, name) {
   }
 }
 
+// Returns true if the `having` or `groupBy` clauses of `builder` may refer to
+// aliased selections (#2329).
+function refersToSelections(builder) {
+  if (builder.has(/having/)) {
+    return true;
+  }
+
+  const aliases = builder
+    .findAllSelections()
+    .map((selection) => selection.alias)
+    .filter((alias) => !!alias);
+
+  let refersToAlias = false;
+
+  builder.forEachOperation(/^groupBy$/, (op) => {
+    if (flatten(op.args).some((arg) => aliases.includes(arg))) {
+      refersToAlias = true;
+    }
+  });
+
+  return refersToAlias;
+}
+
 function getEagerAlgorithmOfOperation(builder, eagerOp) {
   if (eagerOp instanceof JoinEagerOperation) {
     return getJoinEagerAlgorithm(builder);
@@ -1198,7 +1243,8 @@ function groupByEagerAlgorithm(builder, expression) {
 
   for (const childName of node.$childNames) {
     const eagerOp = findEagerOperations(builder).find(
-      (op) => op.expression.node.$allRecursive || op.expression.node[childName],
+      (op) =>
+        op.expression.node.$allRecursive || op.expression.node.$childNames.includes(childName),
     );
 
     const algorithm = eagerOp ? getEagerAlgorithmOfOperation(builder, eagerOp) : defaultAlgorithm;

package/lib/queryBuilder/RelationExpression.js

@@ -129,7 +129,8 @@ class RelationExpression {
       return new RelationExpression(this.node, this.recursionDepth + 1);
     }
 
-    const child = this.node[childName];
+    // Don't mistake inherited properties like `constructor` for children.
+    const child = this.node.$childNames.includes(childName) ? this.node[childName] : null;
 
     if (child) {
       return new RelationExpression(child);
@@ -292,7 +293,7 @@ function modelToNode(model, node) {
     const relName = relationNames[r];
 
     if (model[relName] !== undefined) {
-      let childNode = node[relName];
+      let childNode = node.$childNames.includes(relName) ? node[relName] : null;
 
       if (!childNode) {
         childNode = newNode(relName);
@@ -402,8 +403,9 @@ function mergeNodes(node1, node2) {
     node.$childNames = union(node1.$childNames, node2.$childNames);
 
     for (const childName of node.$childNames) {
-      const child1 = node1[childName];
-      const child2 = node2[childName];
+      // Don't mistake inherited properties like `constructor` for children.
+      const child1 = node1.$childNames.includes(childName) ? node1[childName] : null;
+      const child2 = node2.$childNames.includes(childName) ? node2[childName] : null;
 
       if (child1 && child2) {
         node[childName] = mergeNodes(child1, child2);

package/lib/queryBuilder/graph/GraphOptions.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const { RelationExpression } = require('../RelationExpression');
+const { isString } = require('../../utils/objectUtils');
+
 const NO_RELATE = 'noRelate';
 const NO_UNRELATE = 'noUnrelate';
 const NO_INSERT = 'noInsert';
@@ -12,6 +15,7 @@ const UNRELATE = 'unrelate';
 const INSERT_MISSING = 'insertMissing';
 const FETCH_STRATEGY = 'fetchStrategy';
 const ALLOW_REFS = 'allowRefs';
+const ALLOW_MARKERS = 'allowMarkers';
 
 const OPTION_NAMES = [
   NO_RELATE,
@@ -25,6 +29,21 @@ const OPTION_NAMES = [
   INSERT_MISSING,
   FETCH_STRATEGY,
   ALLOW_REFS,
+  ALLOW_MARKERS,
+];
+
+// The options that are matched against the relation path of each node, see
+// `_hasOption()`.
+const NODE_OPTION_NAMES = [
+  NO_RELATE,
+  NO_UNRELATE,
+  NO_INSERT,
+  NO_UPDATE,
+  NO_DELETE,
+  UPDATE,
+  RELATE,
+  UNRELATE,
+  INSERT_MISSING,
 ];
 
 const FetchStrategy = {
@@ -34,11 +53,16 @@ const FetchStrategy = {
 };
 
 class GraphOptions {
-  constructor(options) {
+  // `rootRelationPath` is the relation path of the root node of a recursive
+  // upsert in the original graph, against which the relation paths and
+  // expressions of the options match.
+  constructor(options, rootRelationPath = []) {
     if (options instanceof GraphOptions) {
       this.options = options.options;
+      this.rootRelationPath = options.rootRelationPath;
     } else {
-      this.options = options;
+      this.options = parseRelationExpressions(options);
+      this.rootRelationPath = rootRelationPath;
     }
   }
 
@@ -181,41 +205,136 @@ class GraphOptions {
     return !!this.options[ALLOW_REFS];
   }
 
-  rebasedOptions(newRoot) {
-    const newOpt = {};
-    const newRootRelationPath = newRoot.relationPathKey;
-
-    for (const name of Object.keys(this.options)) {
-      const value = this.options[name];
-
-      if (Array.isArray(value)) {
-        newOpt[name] = value
-          .filter((it) => it.startsWith(newRootRelationPath))
-          .map((it) => it.slice(newRootRelationPath.length + 1))
-          .filter((it) => !!it);
-      } else {
-        newOpt[name] = value;
-      }
-    }
+  allowMarkers() {
+    return !!this.options[ALLOW_MARKERS];
+  }
 
-    return new GraphOptions(newOpt);
+  // The options of recursive upserts keep matching against the relation paths
+  // of the original graph, which the relation paths of the new root lead to.
+  rebasedOptions(newRoot) {
+    return new GraphOptions(this.options, [...this.rootRelationPath, ...newRoot.relationPath]);
   }
 
   _hasOption(node, optionName) {
     const option = this.options[optionName];
 
-    if (Array.isArray(option)) {
-      return option.indexOf(node.relationPathKey) !== -1;
+    if (isRelationExpression(option)) {
+      return matchesRelationExpression(option, this._relationPath(node));
+    } else if (Array.isArray(option)) {
+      return option.includes(this._relationPath(node).join('.'));
     } else if (typeof option === 'boolean') {
       return option;
     } else if (option === undefined) {
       return false;
     } else {
       throw new Error(
-        `expected ${optionName} option value "${option}" to be an instance of boolean or array of strings`,
+        `expected ${optionName} option value "${option}" to be a boolean, an array of relation paths or a relation expression`,
       );
     }
   }
+
+  // The relation path of the node in the original graph, see `rebasedOptions()`.
+  _relationPath(node) {
+    return [...this.rootRelationPath, ...node.relationPath];
+  }
+}
+
+// Parses the string values of the node options into relation expressions,
+// once per operation.
+function parseRelationExpressions(options) {
+  let parsedOptions = options;
+
+  for (const optionName of NODE_OPTION_NAMES) {
+    const option = options[optionName];
+
+    if (isString(option)) {
+      if (parsedOptions === options) {
+        parsedOptions = { ...options };
+      }
+
+      parsedOptions[optionName] = parseRelationExpression(optionName, option);
+    }
+  }
+
+  return parsedOptions;
+}
+
+function parseRelationExpression(optionName, expression) {
+  const createError = (message) => {
+    return new Error(
+      `invalid relation expression "${expression}" in ${optionName} option: ${message}`,
+    );
+  };
+
+  let parsedExpression;
+
+  try {
+    parsedExpression = RelationExpression.create(expression);
+  } catch (err) {
+    throw createError(err.message);
+  }
+
+  if (parsedExpression.isEmpty && !parsedExpression.node.$allRecursive) {
+    throw createError('the expression is empty');
+  }
+
+  // Relation paths are matched by relation name, so aliases would never match.
+  const alias = findAlias(parsedExpression.node);
+
+  if (alias) {
+    throw createError(`aliases like "${alias.$relation} as ${alias.$name}" are not supported`);
+  }
+
+  return parsedExpression;
+}
+
+function findAlias(node) {
+  for (const childName of node.$childNames) {
+    const child = node[childName];
+
+    if (child.$name !== child.$relation) {
+      return child;
+    }
+
+    const alias = findAlias(child);
+
+    if (alias) {
+      return alias;
+    }
+  }
+
+  return null;
+}
+
+// A relation path matches a relation expression when it leads to a leaf of
+// the expression, like it would match the same relation paths in an array:
+// `'movies.reviews'` matches `movies.reviews` but not `movies`. `'*'` matches
+// all relations below it and recursive expressions like `'parent.^'` match
+// every level of the recursion. The root has no relation path and never
+// matches.
+function matchesRelationExpression(expression, relationPath) {
+  if (relationPath.length === 0) {
+    return false;
+  }
+
+  for (const relationName of relationPath) {
+    expression = expression.childExpression(relationName);
+
+    if (!expression) {
+      return false;
+    }
+  }
+
+  // Below `*`, the expression stays on the same node with increasing depth.
+  if (expression.node.$allRecursive) {
+    return expression.recursionDepth > 0;
+  } else {
+    return expression.isEmpty;
+  }
+}
+
+function isRelationExpression(value) {
+  return !!value && value.isObjectionRelationExpression === true;
 }
 
 function getCurrentNode(node, graphData) {

package/lib/queryBuilder/graph/GraphUpsert.js

@@ -57,6 +57,7 @@ class GraphUpsert {
     return createGraphData(builder, graphOptions, graph)
       .then(checkForErrors(builder))
       .then(pruneGraphs())
+      .then(checkForJoinTableRelatedTableErrors(builder))
       .then(executeOperations(builder))
       .then(returnResult(this.objects, this.isArray));
   }
@@ -66,6 +67,11 @@ class GraphUpsert {
 // default behaviour instead (#84). A warning is logged once per option.
 // TODO: Throw an error instead in objection 4.0.
 function warnOnUnknownOptions(upsertOptions) {
+  // Recursive upserts pass on the already checked options of their parent.
+  if (upsertOptions instanceof GraphOptions) {
+    return;
+  }
+
   for (const name of Object.keys(upsertOptions)) {
     if (!OPTION_NAMES.includes(name)) {
       deprecate(
@@ -239,6 +245,7 @@ function checkForErrors(builder) {
     checkForNotFoundErrors(graphData, builder);
     checkForUnallowedRelationErrors(graphData, builder);
     checkForUnallowedReferenceErrors(graphData, builder);
+    checkForUnallowedMarkerErrors(graphData, builder);
     checkForRootUnrelateOrDeleteErrors(graphData, builder);
 
     if (graphData.graphOptions.isInsertOnly()) {
@@ -249,6 +256,35 @@ function checkForErrors(builder) {
   };
 }
 
+// Inserting or relating a node of a many-to-many relation inserts a join row,
+// which would be a new related row if the join table is also the related
+// table (#133). Check this before this graph is written. It runs after
+// pruning, as the branches below related nodes are upserted and checked by
+// nested `upsertGraph` calls against their own current graphs.
+function checkForJoinTableRelatedTableErrors(builder) {
+  return (graphData) => {
+    const { graphOptions, currentGraph, graph } = graphData;
+
+    for (const node of graph.nodes) {
+      const relation = node.parentEdge && node.parentEdge.relation;
+
+      if (
+        relation &&
+        relation.isObjectionManyToManyRelation &&
+        !currentGraph.nodeForNode(node) &&
+        graphOptions.shouldInsertOrRelate(node, graphData)
+      ) {
+        relation.assertCanModifyJoinTable(
+          builder,
+          graphOptions.shouldRelate(node, graphData) ? 'relate' : 'insert',
+        );
+      }
+    }
+
+    return graphData;
+  };
+}
+
 function checkForNotFoundErrors(graphData, builder) {
   const { graphOptions, currentGraph, graph } = graphData;
 
@@ -309,6 +345,27 @@ function checkForUnallowedReferenceErrors(graphData, builder) {
   }
 }
 
+// `#unrelate` and `#delete` markers come from the graph data, which may be
+// untrusted input. Like `#ref`, they have to be allowed explicitly (#2410).
+function checkForUnallowedMarkerErrors(graphData, builder) {
+  const { graph, graphOptions } = graphData;
+
+  if (graphOptions.allowMarkers()) {
+    return;
+  }
+
+  const node = graph.nodes.find((node) => node.toBeUnrelatedOrDeleted);
+
+  if (node) {
+    const { graphUnrelateProp, graphDeleteProp } = node.modelClass;
+
+    throw builder.modelClass().createValidationError({
+      type: ValidationErrorType.InvalidGraph,
+      message: `${graphUnrelateProp} and ${graphDeleteProp} markers are not allowed in a graph by default. see the allowMarkers insert/upsert graph option`,
+    });
+  }
+}
+
 function checkForRootUnrelateOrDeleteErrors(graphData, builder) {
   for (const node of graphData.graph.nodes) {
     if (!node.parentEdge && node.toBeUnrelatedOrDeleted) {

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

@@ -140,6 +140,8 @@ class GraphInsert extends GraphOperation {
       edge.relation.isObjectionBelongsToOneRelation &&
       edge.isOwnerNode(node) &&
       edge.relatedNode.isReference &&
+      // The owner is patched by its id, which models without one don't have (#2305).
+      node.modelClass.getIdColumnArray().length > 0 &&
       // Both ends need to be inserted for the foreign key to be patched in later.
       this.graphOptions.shouldInsert(node, this.graphData) &&
       this.graphOptions.shouldInsert(edge.relatedNode.referencedNode, this.graphData) &&

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

@@ -85,6 +85,9 @@ class GraphPatchAction extends GraphAction {
 
     const updateBuilder = this._createBuilder(node)
       .childQueryOf(builder, childQueryOptions())
+      // The current graph was fetched through the relations, so the patched
+      // models are known to be related to their parents.
+      .internalOptions({ skipRelationFilter: true })
       .copyFrom(builder, GraphAction.ReturningAllSelector);
 
     if (hasBeforeUpdate) {

package/lib/queryBuilder/operations/InstanceUpdateOperation.js

@@ -37,7 +37,12 @@ class InstanceUpdateOperation extends UpdateOperation {
     }
 
     result = await super.onAfter2(builder, result);
-    this.instance.$set(this.model);
+
+    // A query resolved without updating anything, e.g. with `none()`, leaves
+    // the instance untouched.
+    if (!this.isResolvedWithoutUpdate(builder)) {
+      this.instance.$set(this.model);
+    }
 
     if (isObject(result)) {
       this.instance.$set(result);

package/lib/queryBuilder/operations/UpdateOperation.js

@@ -14,6 +14,7 @@ class UpdateOperation extends QueryBuilderOperation {
 
     this.model = null;
     this.modelOptions = Object.assign({}, this.opt.modelOptions || {});
+    this.hasNothingToUpdate = false;
   }
 
   onAdd(builder, args) {
@@ -34,10 +35,19 @@ class UpdateOperation extends QueryBuilderOperation {
 
     if (isEmpty(row)) {
       // Resolve the query if there is nothing to update.
+      this.hasNothingToUpdate = !builder.isExplicitlyResolvedOrRejected();
       builder.resolve(0);
     }
   }
 
+  // Returns true if the query was resolved without updating anything, e.g.
+  // with `none()` or `resolve()` in a hook, but not if it was only resolved
+  // because there is nothing to update in the table, as the update still
+  // applies to everything else (#2184).
+  isResolvedWithoutUpdate(builder) {
+    return builder.isExplicitlyResolvedOrRejected() && !this.hasNothingToUpdate;
+  }
+
   onBuildKnex(knexBuilder, builder) {
     const json = this.model.$toDatabaseJson(builder);
     const convertedJson = convertFieldExpressionsToRaw(builder, this.model, json);
@@ -56,6 +66,7 @@ class UpdateOperation extends QueryBuilderOperation {
   clone() {
     const clone = super.clone();
     clone.model = this.model;
+    clone.hasNothingToUpdate = this.hasNothingToUpdate;
     return clone;
   }
 }

package/lib/queryBuilder/operations/whereInComposite/WhereInCompositeMsSqlOperation.js

@@ -42,7 +42,9 @@ class WhereInCompositeMsSqlOperation extends ObjectionToKnexConvertingOperation
         knexBuilder,
         columns,
         helperColumns,
-        values.as(knex.raw(`V(${helperColumns.map((_) => '??')})`, helperColumns)),
+        // knex only accepts strings as aliases, so the subquery is aliased in
+        // a raw query.
+        knex.raw(`? AS V(${helperColumns.map((_) => '??')})`, [values, ...helperColumns]),
       );
     }
   }