objection 3.6.0 → 3.8.0

package/lib/queryBuilder/StaticHookArguments.js

@@ -26,9 +26,12 @@ class StaticHookArguments {
     return () => {
       // The `runAfter()` callbacks of the query being executed (including the
       // ones installed by `throwIfNotFound()` and `traverse()`) are meant for
-      // its result, not for the result of this find query.
+      // its result, not for the result of this find query. The same goes for
+      // the value it was resolved with, e.g. the 0 of an update that only
+      // changes the join rows of a many-to-many relation.
       return this[BUILDER_SYMBOL].toFindQuery()
         .clear('runAfter')
+        .clearResolve()
         .clearWithGraphFetched()
         .runAfter(toArray);
     };

package/lib/queryBuilder/graph/GraphOptions.js

@@ -15,20 +15,7 @@ const UNRELATE = 'unrelate';
 const INSERT_MISSING = 'insertMissing';
 const FETCH_STRATEGY = 'fetchStrategy';
 const ALLOW_REFS = 'allowRefs';
-
-const OPTION_NAMES = [
-  NO_RELATE,
-  NO_UNRELATE,
-  NO_INSERT,
-  NO_UPDATE,
-  NO_DELETE,
-  UPDATE,
-  RELATE,
-  UNRELATE,
-  INSERT_MISSING,
-  FETCH_STRATEGY,
-  ALLOW_REFS,
-];
+const ALLOW_MARKERS = 'allowMarkers';
 
 // The options that are matched against the relation path of each node, see
 // `_hasOption()`.
@@ -44,6 +31,8 @@ const NODE_OPTION_NAMES = [
   INSERT_MISSING,
 ];
 
+const OPTION_NAMES = [...NODE_OPTION_NAMES, FETCH_STRATEGY, ALLOW_REFS, ALLOW_MARKERS];
+
 const FetchStrategy = {
   OnlyIdentifiers: 'OnlyIdentifiers',
   Everything: 'Everything',
@@ -52,19 +41,19 @@ const FetchStrategy = {
 
 class GraphOptions {
   // `rootRelationPath` is the relation path of the root node of a recursive
-  // upsert in the original graph, against which relation expressions match.
-  constructor(options, rootRelationPath = []) {
+  // upsert in the original graph, against which the relation paths and
+  // expressions of the options match. `insertOnly` is only set by
+  // `insertGraph`, which never fetches, updates or removes existing rows.
+  constructor(options, rootRelationPath = [], insertOnly = false) {
     if (options instanceof GraphOptions) {
       this.options = options.options;
       this.rootRelationPath = options.rootRelationPath;
+      this.insertOnly = options.insertOnly;
     } else {
       this.options = parseRelationExpressions(options);
       this.rootRelationPath = rootRelationPath;
+      this.insertOnly = insertOnly;
     }
-
-    // Caches the result of matching relation expressions against relation
-    // paths, by option name and relation path key.
-    this.expressionMatches = new Map();
   }
 
   isFetchStrategy(strategy) {
@@ -80,17 +69,12 @@ class GraphOptions {
   }
 
   isInsertOnly() {
-    // NO_RELATE is not in the list, since the `insert only` mode does
-    // relate things that can be related using inserts.
-    // TODO: Use a special key for this.
-    return [NO_DELETE, NO_UPDATE, NO_UNRELATE, INSERT_MISSING].every((opt) => {
-      return this.options[opt] === true;
-    });
+    return this.insertOnly;
   }
 
   // Like `shouldRelate` but ignores settings that explicitly disable relate operations.
   shouldRelateIgnoreDisable(node, graphData) {
-    if (node.toBeUnrelated || node.toBeDeleted) {
+    if (node.toBeUnrelatedOrDeleted) {
       return false;
     }
 
@@ -114,7 +98,7 @@ class GraphOptions {
 
   // Like `shouldInsert` but ignores settings that explicitly disable insert operations.
   shouldInsertIgnoreDisable(node, graphData) {
-    if (node.toBeUnrelated || node.toBeDeleted) {
+    if (node.toBeUnrelatedOrDeleted) {
       return false;
     }
 
@@ -136,7 +120,7 @@ class GraphOptions {
   // Like `shouldPatch() || shouldUpdate()` but ignores settings that explicitly disable
   // update or patch operations.
   shouldPatchOrUpdateIgnoreDisable(node, graphData) {
-    if (node.toBeUnrelated || node.toBeDeleted) {
+    if (node.toBeUnrelatedOrDeleted) {
       return false;
     }
 
@@ -206,33 +190,23 @@ 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 === newRootRelationPath || 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, [...this.rootRelationPath, ...newRoot.relationPath]);
+  // 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 (isRelationExpression(option)) {
-      return this._matchesRelationExpression(node, optionName, option);
+      return matchesRelationExpression(option, this._relationPath(node));
     } else if (Array.isArray(option)) {
-      return option.indexOf(node.relationPathKey) !== -1;
+      return option.includes(this._relationPath(node).join('.'));
     } else if (typeof option === 'boolean') {
       return option;
     } else if (option === undefined) {
@@ -244,36 +218,9 @@ class GraphOptions {
     }
   }
 
-  // A node matches a relation expression when its relation path 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.
-  _matchesRelationExpression(node, optionName, expression) {
-    const relationPath = [...this.rootRelationPath, ...node.relationPath];
-
-    if (relationPath.length === 0) {
-      return false;
-    }
-
-    const relationPathKey = relationPath.join('.');
-
-    let matches = this.expressionMatches.get(optionName);
-
-    if (!matches) {
-      matches = new Map();
-      this.expressionMatches.set(optionName, matches);
-    }
-
-    let isMatch = matches.get(relationPathKey);
-
-    if (isMatch === undefined) {
-      isMatch = matchesRelationPath(expression, relationPath);
-      matches.set(relationPathKey, isMatch);
-    }
-
-    return isMatch;
+  // The relation path of the node in the original graph, see `rebasedOptions()`.
+  _relationPath(node) {
+    return [...this.rootRelationPath, ...node.relationPath];
   }
 }
 
@@ -344,7 +291,17 @@ function findAlias(node) {
   return null;
 }
 
-function matchesRelationPath(expression, relationPath) {
+// 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);
 

package/lib/queryBuilder/graph/GraphUpsert.js

@@ -14,16 +14,17 @@ const { RelationExpression } = require('../RelationExpression');
 const { GraphNodeDbExistence } = require('./GraphNodeDbExistence');
 const { GraphData } = require('./GraphData');
 const { uniqBy, asArray, isObject } = require('../../utils/objectUtils');
-const { deprecate } = require('../../utils/deprecate');
+const { warnOnce } = require('../../utils/warnings');
 
 class GraphUpsert {
-  constructor({ rootModelClass, objects, upsertOptions }) {
+  constructor({ rootModelClass, objects, upsertOptions, insertOnly = false }) {
     checkCanBeConvertedToModels(rootModelClass, objects);
     warnOnUnknownOptions(upsertOptions);
 
     this.objects = rootModelClass.ensureModelArray(objects, GraphUpsert.modelOptions);
     this.isArray = Array.isArray(objects);
     this.upsertOpt = upsertOptions;
+    this.insertOnly = insertOnly;
   }
 
   static get modelOptions() {
@@ -39,7 +40,7 @@ class GraphUpsert {
   // TODO: Throw an error instead in objection 4.0.
   static warnOnConflict(builder, method) {
     if (builder.has(isOnConflictOperation)) {
-      deprecate(
+      warnOnce(
         `onConflict(), ignore() and merge() are not supported by ${method}(). ` +
           'Insert the conflicting rows with a separate insert() query instead. ' +
           'This will throw in objection 4.0.',
@@ -49,7 +50,7 @@ class GraphUpsert {
 
   run(builder) {
     const modelClass = builder.modelClass();
-    const graphOptions = new GraphOptions(this.upsertOpt);
+    const graphOptions = new GraphOptions(this.upsertOpt, [], this.insertOnly);
 
     const graph = ModelGraph.create(modelClass, this.objects);
     assignDbRefsAsRelateProps(graph);
@@ -74,7 +75,7 @@ function warnOnUnknownOptions(upsertOptions) {
 
   for (const name of Object.keys(upsertOptions)) {
     if (!OPTION_NAMES.includes(name)) {
-      deprecate(
+      warnOnce(
         `Unknown graph option "${name}" is ignored. ` +
           `Valid options are: ${OPTION_NAMES.join(', ')}. This will throw in objection 4.0.`,
       );
@@ -245,7 +246,10 @@ function checkForErrors(builder) {
     checkForNotFoundErrors(graphData, builder);
     checkForUnallowedRelationErrors(graphData, builder);
     checkForUnallowedReferenceErrors(graphData, builder);
+    // Root models can't be marked even with `allowMarkers`, so report that
+    // first instead of pointing to the option.
     checkForRootUnrelateOrDeleteErrors(graphData, builder);
+    checkForUnallowedMarkerErrors(graphData, builder);
 
     if (graphData.graphOptions.isInsertOnly()) {
       checkForHasManyRelateErrors(graphData);
@@ -290,8 +294,7 @@ function checkForNotFoundErrors(graphData, builder) {
   for (const node of graph.nodes) {
     if (
       node.obj.$hasId() &&
-      !node.toBeUnrelated &&
-      !node.toBeDeleted &&
+      !node.toBeUnrelatedOrDeleted &&
       !graphOptions.shouldInsertIgnoreDisable(node, graphData) &&
       !graphOptions.shouldRelateIgnoreDisable(node, graphData) &&
       !currentGraph.nodeForNode(node)
@@ -344,6 +347,31 @@ 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).
+// An insert has nothing to unrelate or delete, so `insertGraph` rejects them.
+function checkForUnallowedMarkerErrors(graphData, builder) {
+  const { graph, graphOptions } = graphData;
+  const isInsertOnly = graphOptions.isInsertOnly();
+
+  if (graphOptions.allowMarkers() && !isInsertOnly) {
+    return;
+  }
+
+  const node = graph.nodes.find((node) => node.toBeUnrelatedOrDeleted);
+
+  if (node) {
+    const { graphUnrelateProp, graphDeleteProp } = node.modelClass;
+
+    throw builder.modelClass().createValidationError({
+      type: ValidationErrorType.InvalidGraph,
+      message: isInsertOnly
+        ? `${graphUnrelateProp} and ${graphDeleteProp} can only be used in upsertGraph, not in insertGraph`
+        : `${graphUnrelateProp} and ${graphDeleteProp} markers are not allowed in a graph by default. see the allowMarkers upsertGraph 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/join/RelationJoiner.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { uniqBy } = require('../../utils/objectUtils');
-const { Selection } = require('../operations/select/Selection');
+const { Selection, mapIdentifier } = require('../operations/select/Selection');
 const { SelectOperation } = require('../operations/select/SelectOperation');
 const { createModifier } = require('../../utils/createModifier');
 const { map: mapPromise } = require('../../utils/promiseUtils');
@@ -89,6 +89,13 @@ class RelationJoiner {
     }
   }
 
+  // Whether the joins can return more than one row per root model.
+  hasToManyJoins(builder) {
+    return this._getTableTree(builder).nodes.some(
+      (tableNode) => tableNode.relation && !tableNode.relation.isOneToOne(),
+    );
+  }
+
   parseResult(builder, flatRows) {
     const parser = JoinResultParser.create({
       tableTree: this._getTableTree(builder),
@@ -203,7 +210,60 @@ class RelationJoiner {
       }
     }
 
-    builder.select(selectionsToStrings(selections));
+    // Each name is selected only once, as SQL Server returns duplicate names as
+    // arrays of values, and the other databases silently return one of them.
+    removeRootSelectAll(builder);
+    const tableTree = this._getTableTree(builder);
+    const userSelectionsByName = new Map();
+
+    for (const selection of findJoinSelections(builder)) {
+      // Only the columns of the joined tables are known for `table.*`:
+      const node = isSelectAll(selection) ? tableTree.nodesByAlias.get(selection.table) : null;
+      const names = node
+        ? getAllColumnSelectionsForNode({ builder, tableNode: node }).map((it) => it.column)
+        : [selection.name];
+
+      for (const name of names) {
+        userSelectionsByName.set(mapIdentifier(builder, name), { selection, name });
+      }
+    }
+
+    const idAliases = new Set(
+      tableTree.nodes.flatMap((node) =>
+        getIdSelectionsForNode({ tableNode: node }).map((it) => it.alias),
+      ),
+    );
+
+    builder.select(
+      selectionsToStrings(
+        selections.filter(({ table, column, alias }) => {
+          const { selection, name } = userSelectionsByName.get(mapIdentifier(builder, alias)) || {};
+
+          if (!selection) {
+            return true;
+          } else if (selection.column) {
+            if (!Selection.doesSelect(builder, selection, `${table}.${column}`)) {
+              throw new Error(
+                `withGraphJoined: the selection '${selectionToString(selection)}' selects '${name}', ` +
+                  `the name under which the column '${table}.${column}' is selected. ` +
+                  'Select it under a different name.',
+              );
+            }
+          } else if (idAliases.has(alias)) {
+            // Raws, subqueries and aggregates select values that we can't see
+            // into. They replace our columns, but not the ids that we need to
+            // parse the result.
+            throw new Error(
+              `withGraphJoined: a raw, subquery or aggregate selection selects '${name}', ` +
+                `the name under which the id column '${table}.${column}' is selected. ` +
+                'Select it under a different name, or select the id column itself.',
+            );
+          }
+
+          return false;
+        }),
+      ),
+    );
   }
 }
 
@@ -268,8 +328,9 @@ function ensureIdAndRelationPropsAreSelected({ builder, tableNode }) {
     ),
   ];
 
+  const hasSelectionAs = createHasSelectionAs(builder);
   const selectStrings = uniqBy(cols)
-    .filter((col) => !hasSelectionAs(builder, col))
+    .filter((col) => !hasSelectionAs(col))
     .map((col) => `${tableRef}.${col}`);
 
   return builder.select(selectStrings);
@@ -297,9 +358,10 @@ function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
     selections = allColumnSelections.concat(selections);
   } else {
     const idSelections = getIdSelectionsForNode({ tableNode });
+    const hasUserSelectionAs = createHasUserSelectionAs(userSelectQuery, tableNode);
 
     for (const idSelection of idSelections) {
-      if (!hasUserSelectionAs(userSelectQuery, tableNode, idSelection.column)) {
+      if (!hasUserSelectionAs(idSelection.column)) {
         selections.push(idSelection);
         internalSelections.push(idSelection);
       }
@@ -334,14 +396,16 @@ function findJoinSelections(builder) {
   return selections;
 }
 
-// Like `builder.hasSelectionAs(column, column)`, but ignoring the columns
-// passed to aggregates, as they don't select them.
-function hasSelectionAs(builder, column) {
+// Create a `(column) => builder.hasSelectionAs(column, column)` function that
+// ignores the columns passed to aggregates, as they don't select them. Clone
+// the builder once, not once per column.
+function createHasSelectionAs(builder) {
   if (builder.has(isAggregateOperation)) {
+    const selectionQuery = builder.clone().clear(isAggregateOperation);
     // Explicit, as a query with only aggregates doesn't select all columns.
-    return builder.clone().clear(isAggregateOperation).hasSelectionAs(column, column, true);
+    return (column) => selectionQuery.hasSelectionAs(column, column, true);
   } else {
-    return builder.hasSelectionAs(column, column);
+    return (column) => builder.hasSelectionAs(column, column);
   }
 }
 
@@ -355,11 +419,12 @@ function findUserSelections(builder, tableNode) {
   }
 }
 
-function hasUserSelectionAs(builder, tableNode, column) {
+function createHasUserSelectionAs(builder, tableNode) {
   if (tableNode.parentNode) {
-    return hasSelectionAs(builder, column);
+    return createHasSelectionAs(builder);
   } else {
-    return builder.hasSelectionAs(column, column);
+    // Qualified, as the root query can also select the columns of the joined tables.
+    return (column) => builder.hasSelectionAs(`${tableNode.alias}.${column}`, column);
   }
 }
 
@@ -416,6 +481,28 @@ function getIdSelectionsForNode({ tableNode }) {
   });
 }
 
+// The selections of all columns of the root table replace the user's `*`, which
+// would select them a second time, and a bare `*` also the columns of the
+// joined tables under the same names.
+function removeRootSelectAll(builder) {
+  const tableRef = builder.tableRef();
+  const isRootSelectAll = (selection) =>
+    selection.column === '*' && (!selection.table || selection.table === tableRef);
+  const isSelect = (op) =>
+    op.constructor === SelectOperation && !isAggregateOperation(op) && !op.isDistinctOn;
+
+  builder.forEachOperation(isSelect, (op) => {
+    op.args = op.args.filter((arg) => {
+      const selection = Selection.create(arg);
+      return !selection || !isRootSelectAll(selection);
+    });
+    op.selections = op.selections.filter((selection) => !isRootSelectAll(selection));
+  });
+
+  // An empty `distinct()` still makes the whole select distinct.
+  builder.clear((op) => isSelect(op) && op.name !== 'distinct' && op.args.length === 0);
+}
+
 function selectionsToStrings(selections) {
   return selections.map((selection) => {
     const selectStr = `${selection.table}.${selection.column}`;
@@ -423,6 +510,11 @@ function selectionsToStrings(selections) {
   });
 }
 
+function selectionToString({ table, column, alias }) {
+  const selection = table ? `${table}.${column}` : column;
+  return alias ? `${selection} as ${alias}` : selection;
+}
+
 function isSelectAll(selection) {
   return selection.column === '*';
 }

package/lib/queryBuilder/join/utils.js

@@ -6,8 +6,8 @@ const { isPostgres, isMySql, isMsSql, isSqlite } = require('../../utils/knexUtil
 const RELATION_RECURSION_LIMIT = 64;
 
 // The maximum length of the column aliases of the joined relations, after
-// which the database would truncate them. Unknown databases use the strictest
-// of the known limits, the one of postgres.
+// which the database would truncate them. Other databases keep the limit of
+// postgres, which isn't the strictest one: Oracle before 12.2 only allows 30.
 function getIdentifierLengthLimit(knex) {
   if (isPostgres(knex)) {
     return 63;

package/lib/queryBuilder/operations/DelegateOperation.js

@@ -55,6 +55,17 @@ class DelegateOperation extends QueryBuilderOperation {
     return this.onBuild !== DelegateOperation.prototype.onBuild || this.delegate.hasOnBuild();
   }
 
+  onAfterBuild(builder) {
+    return this.delegate.onAfterBuild(builder);
+  }
+
+  hasOnAfterBuild() {
+    return (
+      this.onAfterBuild !== DelegateOperation.prototype.onAfterBuild ||
+      this.delegate.hasOnAfterBuild()
+    );
+  }
+
   onBuildKnex(knexBuilder, builder) {
     return this.delegate.onBuildKnex(knexBuilder, builder);
   }
@@ -110,6 +121,17 @@ class DelegateOperation extends QueryBuilderOperation {
     );
   }
 
+  queryBatches(builder) {
+    return this.delegate.queryBatches(builder);
+  }
+
+  hasQueryBatches() {
+    return (
+      this.queryBatches !== DelegateOperation.prototype.queryBatches ||
+      this.delegate.hasQueryBatches()
+    );
+  }
+
   onError(builder, error) {
     return this.delegate.onError(builder, error);
   }

package/lib/queryBuilder/operations/FirstOperation.js

@@ -3,10 +3,12 @@
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 
 class FirstOperation extends QueryBuilderOperation {
-  onBuildKnex(knexBuilder, builder) {
-    const modelClass = builder.modelClass();
+  shouldLimit(builder) {
+    return builder.isFind() && builder.modelClass().useLimitInFirst;
+  }
 
-    if (builder.isFind() && modelClass.useLimitInFirst) {
+  onBuildKnex(knexBuilder, builder) {
+    if (this.shouldLimit(builder)) {
       knexBuilder = knexBuilder.limit(1);
     }
 

package/lib/queryBuilder/operations/InsertGraphOperation.js

@@ -42,6 +42,7 @@ class InsertGraphOperation extends DelegateOperation {
         noUnrelate: true,
         insertMissing: true,
       }),
+      insertOnly: true,
     });
 
     // We resolve this query here and will not execute it. This is because the root

package/lib/queryBuilder/operations/InstanceDeleteOperation.js

@@ -3,6 +3,7 @@
 const { DeleteOperation } = require('./DeleteOperation');
 const { InstanceFindOperation } = require('./InstanceFindOperation');
 const { assertHasId } = require('../../utils/assert');
+const { addWhereGroup } = require('../whereGroups');
 
 class InstanceDeleteOperation extends DeleteOperation {
   constructor(name, opt) {
@@ -20,7 +21,7 @@ class InstanceDeleteOperation extends DeleteOperation {
     super.onBuild(builder);
 
     assertHasId(this.instance);
-    builder.findById(this.instance.$id());
+    addWhereGroup(builder, () => builder.findById(this.instance.$id()));
   }
 
   async onAfter2(builder, result) {

package/lib/queryBuilder/operations/InstanceFindOperation.js

@@ -2,6 +2,7 @@
 
 const { FindOperation } = require('./FindOperation');
 const { assertHasId } = require('../../utils/assert');
+const { addWhereGroup } = require('../whereGroups');
 
 class InstanceFindOperation extends FindOperation {
   constructor(name, opt) {
@@ -11,7 +12,7 @@ class InstanceFindOperation extends FindOperation {
 
   onBuild(builder) {
     assertHasId(this.instance);
-    builder.findById(this.instance.$id());
+    addWhereGroup(builder, () => builder.findById(this.instance.$id()));
   }
 }
 

package/lib/queryBuilder/operations/InstanceUpdateOperation.js

@@ -4,6 +4,7 @@ const { UpdateOperation } = require('./UpdateOperation');
 const { InstanceFindOperation } = require('./InstanceFindOperation');
 const { assertHasId } = require('../../utils/assert');
 const { isObject } = require('../../utils/objectUtils');
+const { addWhereGroup } = require('../whereGroups');
 
 class InstanceUpdateOperation extends UpdateOperation {
   constructor(name, opt) {
@@ -27,7 +28,7 @@ class InstanceUpdateOperation extends UpdateOperation {
     super.onBuild(builder);
 
     assertHasId(this.instance);
-    builder.findById(this.instance.$id());
+    addWhereGroup(builder, () => builder.findById(this.instance.$id()));
   }
 
   async onAfter2(builder, result) {
@@ -37,7 +38,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);