objection 3.8.0 → 3.9.0

package/lib/queryBuilder/graph/GraphOptions.js

@@ -161,8 +161,11 @@ class GraphOptions {
 
     return (
       !node &&
+      !hasIgnoredOtherModel(currentNode, graphData) &&
       !this._hasOption(currentNode, NO_UNRELATE) &&
-      this.shouldUnrelateIgnoreDisable(currentNode)
+      (this.shouldUnrelateIgnoreDisable(currentNode) ||
+        // The unrelate replaces a delete, so `noDelete` disables it too.
+        (!this._hasOption(currentNode, NO_DELETE) && shouldUnrelateKeptRow(currentNode, graphData)))
     );
   }
 
@@ -173,8 +176,11 @@ class GraphOptions {
 
     return (
       !node &&
+      !hasIgnoredOtherModel(currentNode, graphData) &&
       !this._hasOption(currentNode, NO_DELETE) &&
-      !this.shouldUnrelateIgnoreDisable(currentNode)
+      !this.shouldUnrelateIgnoreDisable(currentNode) &&
+      // Rows that the graph keeps in another place must not be deleted (#214).
+      !graphData.keptNodeForRow(currentNode)
     );
   }
 
@@ -182,6 +188,18 @@ class GraphOptions {
     return this.shouldInsert(node, graphData) || this.shouldRelate(node, graphData);
   }
 
+  // The graph ignores models that it neither inserts, relates nor patches, like
+  // models marked with `#unrelate` or `#delete` and models skipped by `noInsert`
+  // or `noRelate`. Inserted models have ids and can look like models to relate
+  // afterwards, so we check that they were inserted too.
+  shouldIgnore(node, graphData) {
+    return (
+      !node.userData.inserted &&
+      !this.shouldInsertOrRelate(node, graphData) &&
+      !this.shouldPatchOrUpdateIgnoreDisable(node, graphData)
+    );
+  }
+
   shouldDeleteOrUnrelate(currentNode, graphData) {
     return this.shouldDelete(currentNode, graphData) || this.shouldUnrelate(currentNode, graphData);
   }
@@ -264,27 +282,30 @@ function parseRelationExpression(optionName, expression) {
   }
 
   // Relation paths are matched by relation name, so aliases would never match.
-  const alias = findAlias(parsedExpression.node);
+  const alias = findNode(parsedExpression.node, (node) => node.$name !== node.$relation);
 
   if (alias) {
     throw createError(`aliases like "${alias.$relation} as ${alias.$name}" are not supported`);
   }
 
+  // `*` and `^` only have a meaning at the end of a relation path. Anywhere else
+  // they are parsed as relation names that would never match.
+  const token = findNode(parsedExpression.node, (node) => /^(\*|\^\d*)$/.test(node.$relation));
+
+  if (token) {
+    throw createError(`"${token.$relation}" is only supported at the end of a relation path`);
+  }
+
   return parsedExpression;
 }
 
-function findAlias(node) {
+function findNode(node, predicate) {
   for (const childName of node.$childNames) {
     const child = node[childName];
+    const found = predicate(child) ? child : findNode(child, predicate);
 
-    if (child.$name !== child.$relation) {
-      return child;
-    }
-
-    const alias = findAlias(child);
-
-    if (alias) {
-      return alias;
+    if (found) {
+      return found;
     }
   }
 
@@ -344,6 +365,39 @@ function hasRelateProp(node) {
   }
 }
 
+// An ignored model that isn't the current model of a BelongsToOneRelation
+// doesn't replace it, so we keep the current one instead of removing it as
+// missing.
+function hasIgnoredOtherModel(currentNode, graphData) {
+  const { relation } = currentNode.parentEdge;
+  const parentNode = getNode(currentNode.parentNode, graphData.graph);
+
+  return (
+    relation.isObjectionBelongsToOneRelation &&
+    !!parentNode &&
+    parentNode.edges.some(
+      (edge) =>
+        edge.relation === relation &&
+        edge.isOwnerNode(parentNode) &&
+        graphData.graphOptions.shouldIgnore(edge.relatedNode, graphData),
+    )
+  );
+}
+
+// A row that the graph keeps in another place is unrelated here instead of
+// being deleted, unless it's a has-many row that the graph relates through the
+// same relation: That relate moves it by overwriting the foreign key, which
+// may not be nullable.
+function shouldUnrelateKeptRow(currentNode, graphData) {
+  const keptNode = graphData.keptNodeForRow(currentNode);
+  const { relation } = currentNode.parentEdge;
+
+  return (
+    !!keptNode &&
+    !(relation.isObjectionHasManyRelation && keptNode.parentEdge?.relation === relation)
+  );
+}
+
 function getNode(currentNode, graph) {
   if (!graph || !currentNode) {
     return null;

package/lib/queryBuilder/graph/GraphUpsert.js

@@ -6,7 +6,7 @@ const { createNotModelError } = require('../../model/graph/ModelGraphBuilder');
 const { GraphFetcher } = require('../graph/GraphFetcher');
 const { GraphInsert } = require('./insert/GraphInsert');
 const { GraphPatch } = require('./patch/GraphPatch');
-const { GraphDelete } = require('./delete/GraphDelete');
+const { GraphDelete, GraphDereferencedBelongsToOneDelete } = require('./delete/GraphDelete');
 const { GraphRecursiveUpsert } = require('./recursiveUpsert/GraphRecursiveUpsert');
 const { GraphOptions, OPTION_NAMES } = require('./GraphOptions');
 const { ValidationErrorType } = require('../../model/ValidationError');
@@ -37,7 +37,7 @@ class GraphUpsert {
   // by `ignore()` aren't returned, which leaves the root models without ids,
   // so that related rows would be inserted with missing or wrong foreign keys.
   // The clause is ignored, and a warning is logged once per method.
-  // TODO: Throw an error instead in objection 4.0.
+  // TODO: Throw an error instead in objection 4.0 (#53).
   static warnOnConflict(builder, method) {
     if (builder.has(isOnConflictOperation)) {
       warnOnce(
@@ -60,13 +60,14 @@ class GraphUpsert {
       .then(pruneGraphs())
       .then(checkForJoinTableRelatedTableErrors(builder))
       .then(executeOperations(builder))
+      .then(removeReferenceProps(graph.nodes))
       .then(returnResult(this.objects, this.isArray));
   }
 }
 
 // Misspelled options are silently ignored, so the operation runs with the
 // default behaviour instead (#84). A warning is logged once per option.
-// TODO: Throw an error instead in objection 4.0.
+// TODO: Throw an error instead in objection 4.0 (#53).
 function warnOnUnknownOptions(upsertOptions) {
   // Recursive upserts pass on the already checked options of their parent.
   if (upsertOptions instanceof GraphOptions) {
@@ -128,6 +129,7 @@ function fetchCurrentGraph(builder, graphOptions, graph) {
 function pruneGraphs() {
   return (graphData) => {
     pruneRelatedBranches(graphData);
+    pruneSkippedBranches(graphData);
 
     if (!graphData.graphOptions.isInsertOnly()) {
       pruneDeletedBranches(graphData);
@@ -149,6 +151,31 @@ function pruneRelatedBranches(graphData) {
   removeBranchesFromGraph(findRoots(relateNodes), graphData.graph);
 }
 
+// Nothing is written below nodes that `noInsert` skips, as their descendants
+// would be orphans (#215). Branches that references from outside point into
+// are kept, since the references need their models.
+function pruneSkippedBranches(graphData) {
+  const { graph, graphOptions } = graphData;
+
+  const skippedNodes = graph.nodes.filter((node) => {
+    return (
+      graphOptions.shouldInsertIgnoreDisable(node, graphData) &&
+      !graphOptions.shouldInsert(node, graphData) &&
+      !isReferencedFromOutside(node.descendantRelationNodes)
+    );
+  });
+
+  removeBranchesFromGraph(findRoots(skippedNodes), graph);
+}
+
+function isReferencedFromOutside(nodes) {
+  const nodeSet = new Set(nodes);
+
+  return nodes.some((node) =>
+    node.refEdges.some((edge) => edge.isRelatedNode(node) && !nodeSet.has(edge.ownerNode)),
+  );
+}
+
 function pruneDeletedBranches(graphData) {
   const { graph, currentGraph } = graphData;
 
@@ -253,6 +280,7 @@ function checkForErrors(builder) {
 
     if (graphData.graphOptions.isInsertOnly()) {
       checkForHasManyRelateErrors(graphData);
+      warnOnInsertBelowRelate(graphData);
     }
 
     return graphData;
@@ -290,10 +318,18 @@ function checkForJoinTableRelatedTableErrors(builder) {
 
 function checkForNotFoundErrors(graphData, builder) {
   const { graphOptions, currentGraph, graph } = graphData;
+  // The branches below related nodes are upserted and checked by nested
+  // `upsertGraph` calls, against the current graphs of the related nodes:
+  const nestedNodes = new Set(
+    graph.nodes
+      .filter((node) => graphOptions.shouldRelate(node, graphData))
+      .flatMap((node) => node.descendantRelationNodes),
+  );
 
   for (const node of graph.nodes) {
     if (
       node.obj.$hasId() &&
+      !nestedNodes.has(node) &&
       !node.toBeUnrelatedOrDeleted &&
       !graphOptions.shouldInsertIgnoreDisable(node, graphData) &&
       !graphOptions.shouldRelateIgnoreDisable(node, graphData) &&
@@ -400,11 +436,41 @@ function checkForHasManyRelateErrors(graphData) {
   }
 }
 
+// `upsertGraph` upserts the branches below related models recursively, but
+// `insertGraph` prunes them, which drops the models that would be inserted
+// there (#217). A warning is logged once.
+// TODO: Throw an error instead in objection 4.0 (#53).
+function warnOnInsertBelowRelate(graphData) {
+  const { graph, graphOptions } = graphData;
+
+  const hasInsertBelowRelate = graph.nodes.some(
+    (node) =>
+      graphOptions.shouldRelate(node, graphData) &&
+      node.descendantRelationNodes.some((descendantNode) =>
+        graphOptions.shouldInsert(descendantNode, graphData),
+      ),
+  );
+
+  if (hasInsertBelowRelate) {
+    warnOnce(
+      'insertGraph() ignores new models below related models. ' +
+        'Insert them with a separate query or use upsertGraph() instead. ' +
+        'This will throw in objection 4.0.',
+    );
+  }
+}
+
 function executeOperations(builder) {
   return (graphData) => {
     const operations = graphData.graphOptions.isInsertOnly()
       ? [GraphInsert]
-      : [GraphDelete, GraphInsert, GraphPatch, GraphRecursiveUpsert];
+      : [
+          GraphDelete,
+          GraphInsert,
+          GraphPatch,
+          GraphDereferencedBelongsToOneDelete,
+          GraphRecursiveUpsert,
+        ];
 
     return operations.reduce((promise, Operation) => {
       const operation = new Operation(graphData);
@@ -422,6 +488,18 @@ function executeActions(builder, actions) {
   );
 }
 
+// The reference markers only describe the input graph, don't return them.
+// `nodes` are the nodes before pruning, since the results of pruned branches
+// contain markers too.
+function removeReferenceProps(nodes) {
+  return () => {
+    for (const node of nodes) {
+      delete node.obj[node.modelClass.uidRefProp];
+      delete node.obj[node.modelClass.dbRefProp];
+    }
+  };
+}
+
 function isOnConflictOperation(op) {
   return op.name === 'onConflict' || op.name === 'ignore' || op.name === 'merge';
 }

package/lib/queryBuilder/graph/delete/GraphDelete.js

@@ -2,19 +2,72 @@
 
 const { GraphOperation } = require('../GraphOperation');
 const { GraphDeleteAction } = require('./GraphDeleteAction');
+const { getPropertyTypes } = require('../../../model/modelJsonAttributes');
 
 class GraphDelete extends GraphOperation {
+  // The owner of a BelongsToOneRelation row references it until `GraphPatch`
+  // points the owner to a new row or to null. These rows are deleted
+  // afterwards by `GraphDereferencedBelongsToOneDelete`, all others before.
+  get deletesDereferencedRows() {
+    return false;
+  }
+
   createActions() {
     return [
       new GraphDeleteAction(this.graphData, {
-        nodes: this.currentGraph.nodes.filter((currentNode) =>
-          this.graphOptions.shouldDeleteOrUnrelate(currentNode, this.graphData),
+        nodes: this.currentGraph.nodes.filter(
+          (currentNode) =>
+            this.graphOptions.shouldDeleteOrUnrelate(currentNode, this.graphData) &&
+            isDereferencedBelongsToOneNode(currentNode, this.graphData) ===
+              this.deletesDereferencedRows,
         ),
+        areReferenced: !this.deletesDereferencedRows,
       }),
     ];
   }
 }
 
+class GraphDereferencedBelongsToOneDelete extends GraphDelete {
+  get deletesDereferencedRows() {
+    return true;
+  }
+}
+
+function isDereferencedBelongsToOneNode(currentNode, graphData) {
+  const { graph, graphOptions } = graphData;
+  const relation = currentNode.parentEdge?.relation;
+  const parentNode = graph.nodeForNode(currentNode.parentNode);
+
+  if (relation?.isObjectionBelongsToOneRelation && parentNode) {
+    const node = graph.nodeForNode(currentNode);
+    const isReplaced = parentNode.edges.some(
+      (edge) =>
+        edge.relation === relation &&
+        edge.isOwnerNode(parentNode) &&
+        !graphOptions.shouldIgnore(edge.relatedNode, graphData),
+    );
+    const isRemoved =
+      parentNode.obj[relation.name] === null || (!!node && node.toBeUnrelatedOrDeleted);
+
+    // Removing the row sets the owner's foreign key to null, but only where
+    // its schema allows it. Otherwise we delete the row first and leave the
+    // owner's reference to the database, as the column may be `NOT NULL`.
+    return (
+      isReplaced ||
+      (isRemoved &&
+        relation.ownerProp.props.every((prop) => isNullable(relation.ownerModelClass, prop)))
+    );
+  } else {
+    return false;
+  }
+}
+
+function isNullable(modelClass, prop) {
+  const schema = modelClass.getJsonSchema()?.properties?.[prop];
+  return !!schema && (schema.nullable === true || getPropertyTypes(schema).includes('null'));
+}
+
 module.exports = {
   GraphDelete,
+  GraphDereferencedBelongsToOneDelete,
 };

package/lib/queryBuilder/graph/delete/GraphDeleteAction.js

@@ -5,10 +5,14 @@ const { groupBy } = require('../../../utils/objectUtils');
 const promiseUtils = require('../../../utils/promiseUtils');
 
 class GraphDeleteAction extends GraphAction {
-  constructor(graphData, { nodes }) {
+  constructor(graphData, { nodes, areReferenced = true }) {
     super(graphData);
     // Nodes to delete.
     this.nodes = nodes;
+    // Whether the parents still reference the nodes. Rows of
+    // BelongsToOneRelations can be deleted after their owners were patched to
+    // reference new rows or null, so they can't be found through the relation.
+    this.areReferenced = areReferenced;
   }
 
   run(builder) {
@@ -47,10 +51,14 @@ class GraphDeleteAction extends GraphAction {
         );
 
         nodesByShouldUnrelate.forEach((nodes, shouldUnrelate) => {
-          const builder = parentNode.obj.$relatedQuery(relation.name).childQueryOf(parentBuilder);
-
-          if (!relation.isObjectionBelongsToOneRelation) {
-            // This is useless in case of BelongsToOneRelation.
+          const builder = (
+            this.areReferenced
+              ? parentNode.obj.$relatedQuery(relation.name)
+              : relation.relatedModelClass.query()
+          ).childQueryOf(parentBuilder);
+
+          if (!this.areReferenced || !relation.isObjectionBelongsToOneRelation) {
+            // This is useless in case of a referenced BelongsToOneRelation.
             builder.findByIds(nodes.map((node) => node.obj.$id()));
           }
 

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

@@ -46,7 +46,12 @@ class GraphInsert extends GraphOperation {
       // In case of HasManyRelation the related node depends on the owner node
       // because the related node has the foreign key.
       this._addDependency(edge.relatedNode, edge, dependencies);
-    } else if (edge.relation.isObjectionBelongsToOneRelation) {
+    } else if (
+      edge.relation.isObjectionBelongsToOneRelation &&
+      // Ignored models don't replace the current one, so their keys must not
+      // be copied to the owner either.
+      !this.graphOptions.shouldIgnore(edge.relatedNode, this.graphData)
+    ) {
       // In case of BelongsToOneRelation the owner node depends on the related
       // node because the owner node has the foreign key.
       this._addDependency(edge.ownerNode, edge, dependencies);

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

@@ -128,8 +128,9 @@ class GraphPatchAction extends GraphAction {
         edge.relation &&
         edge.relation.isObjectionBelongsToOneRelation &&
         edge.relation.relatedProp.hasProps(edge.relatedNode.obj) &&
-        // Models marked with `#unrelate` or `#delete` are handled below.
-        !edge.relatedNode.toBeUnrelatedOrDeleted
+        // Ignored models don't replace the current one, and models marked with
+        // `#unrelate` or `#delete` are handled below.
+        !this.graphOptions.shouldIgnore(edge.relatedNode, this.graphData)
       ) {
         const { relation } = edge;
 

package/lib/queryBuilder/join/JoinResultParser.js

@@ -9,7 +9,7 @@ class JoinResultParser {
     this.omitColumnAliases = new Set(omitColumnAliases);
 
     this.columnsByTableNode = null;
-    this.parentMap = null;
+    this.modelsByTableNode = null;
     this.rootModels = null;
   }
 
@@ -25,7 +25,8 @@ class JoinResultParser {
     this._checkIdColumns(flatRows[0]);
 
     this.columnsByTableNode = this._createColumns(flatRows[0]);
-    this.parentMap = new Map();
+    // Key the models of each table node by the ids on their path from the root:
+    this.modelsByTableNode = new Map(this.tableTree.nodes.map((node) => [node, new Map()]));
     this.rootModels = [];
 
     for (const flatRow of flatRows) {
@@ -42,14 +43,15 @@ class JoinResultParser {
       return;
     }
 
-    const key = getKey(parentKey, id, tableNode);
-    let model = this.parentMap.get(key);
+    const key = getKey(parentKey, id);
+    const models = this.modelsByTableNode.get(tableNode);
+    let model = models.get(key);
 
     if (!model) {
       model = this._createModel(tableNode, flatRow);
 
       this._addToParent(tableNode, model, parentModel);
-      this.parentMap.set(key, model);
+      models.set(key, model);
     }
 
     for (const childNode of tableNode.childNodes) {
@@ -128,11 +130,14 @@ function getTableNode(column) {
   return column.tableNode;
 }
 
-function getKey(parentKey, id, tableNode) {
+// Escape the separator in the ids, since string ids can contain it.
+function getKey(parentKey, id) {
+  const escapedId = id.includes('/') || id.includes('\\') ? id.replace(/[/\\]/g, '\\$&') : id;
+
   if (parentKey !== null) {
-    return `${parentKey}/${tableNode.relationProperty}/${id}`;
+    return `${parentKey}/${escapedId}`;
   } else {
-    return `/${id}`;
+    return escapedId;
   }
 }
 

package/lib/queryBuilder/join/RelationJoiner.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { uniqBy } = require('../../utils/objectUtils');
-const { Selection, mapIdentifier } = require('../operations/select/Selection');
+const { Selection, isSameTable, mapIdentifier } = require('../operations/select/Selection');
 const { SelectOperation } = require('../operations/select/SelectOperation');
 const { createModifier } = require('../../utils/createModifier');
 const { map: mapPromise } = require('../../utils/promiseUtils');
@@ -487,7 +487,8 @@ function getIdSelectionsForNode({ tableNode }) {
 function removeRootSelectAll(builder) {
   const tableRef = builder.tableRef();
   const isRootSelectAll = (selection) =>
-    selection.column === '*' && (!selection.table || selection.table === tableRef);
+    selection.column === '*' &&
+    (!selection.table || isSameTable(builder, selection.table, tableRef));
   const isSelect = (op) =>
     op.constructor === SelectOperation && !isAggregateOperation(op) && !op.isDistinctOn;
 

package/lib/queryBuilder/join/TableNode.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { propKey, hasProps } = require('../../model/modelValues');
+
 class TableNode {
   constructor({ tableTree, modelClass, expression, parentNode = null, relation = null }) {
     this.tableTree = tableTree;
@@ -86,78 +88,14 @@ class TableNode {
   }
 
   _createIdGetter() {
-    const idColumns = this.modelClass.getIdColumnArray();
-    const columnAliases = idColumns.map((column) => this.getColumnAliasForColumn(column));
-
-    if (idColumns.length === 1) {
-      return createIdGetter(columnAliases);
-    } else {
-      return createCompositeIdGetter(columnAliases);
-    }
-  }
-}
-
-function createIdGetter(columnAliases) {
-  const columnAlias = columnAliases[0];
+    const columnAliases = this.modelClass
+      .getIdColumnArray()
+      .map((column) => this.getColumnAliasForColumn(column));
 
-  return (flatRow) => {
-    const id = flatRow[columnAlias];
-
-    if (id === null) {
-      return null;
-    }
-
-    return `${id}`;
-  };
-}
-
-function createCompositeIdGetter(columnAliases) {
-  if (columnAliases.length === 2) {
-    return createTwoIdGetter(columnAliases);
-  } else {
-    return createMultiIdGetter(columnAliases);
+    return (flatRow) => (hasProps(flatRow, columnAliases) ? propKey(flatRow, columnAliases) : null);
   }
 }
 
-function createTwoIdGetter(columnAliases) {
-  const columnAlias1 = columnAliases[0];
-  const columnAlias2 = columnAliases[1];
-
-  return (flatRow) => {
-    const id1 = flatRow[columnAlias1];
-    const id2 = flatRow[columnAlias2];
-
-    if (id1 === null || id2 === null) {
-      return null;
-    }
-
-    return `${id1},${id2}`;
-  };
-}
-
-function createMultiIdGetter(columnAliases) {
-  return (flatRow) => {
-    let idStr = '';
-
-    for (let i = 0, l = columnAliases.length; i < l; ++i) {
-      const columnAlias = columnAliases[i];
-      const id = flatRow[columnAlias];
-
-      if (id === null) {
-        return null;
-      }
-
-      idStr += id;
-
-      if (i !== l - 1) {
-        idStr += ',';
-      }
-    }
-
-    return idStr;
-  };
-}
-
 module.exports = {
   TableNode,
 };

package/lib/queryBuilder/operations/DeleteOperation.js

@@ -2,6 +2,8 @@
 
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 const { StaticHookArguments } = require('../StaticHookArguments');
+const { isMySql } = require('../../utils/knexUtils');
+const { warnOnce } = require('../../utils/warnings');
 
 class DeleteOperation extends QueryBuilderOperation {
   async onBefore2(builder, result) {
@@ -9,6 +11,17 @@ 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.
+  onAfterBuild(builder) {
+    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 ' +
+          'deletes rows in any order. This will throw an error in objection 4.0.',
+      );
+    }
+  }
+
   onBuildKnex(knexBuilder) {
     return knexBuilder.delete();
   }

package/lib/queryBuilder/operations/InsertOperation.js

@@ -3,7 +3,7 @@
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 const { StaticHookArguments } = require('../StaticHookArguments');
 const { after, mapAfterAllReturn } = require('../../utils/promiseUtils');
-const { isPostgres, isSqlite, isMySql, isMsSql } = require('../../utils/knexUtils');
+const { isSqlite, isMySql, hasBatchInsert } = require('../../utils/knexUtils');
 const { isObject, isString } = require('../../utils/objectUtils');
 
 // Base class for all insert operations.
@@ -27,7 +27,7 @@ class InsertOperation extends QueryBuilderOperation {
   }
 
   async onBefore2(builder, result) {
-    if (this.models.length > 1 && !isPostgres(builder.knex()) && !isMsSql(builder.knex())) {
+    if (this.models.length > 1 && !hasBatchInsert(builder.knex())) {
       throw new Error('batch insert only works with Postgresql and SQL Server');
     } else {
       await callBeforeInsert(builder, this.models);

package/lib/queryBuilder/operations/InstanceUpdateOperation.js

@@ -5,6 +5,7 @@ const { InstanceFindOperation } = require('./InstanceFindOperation');
 const { assertHasId } = require('../../utils/assert');
 const { isObject } = require('../../utils/objectUtils');
 const { addWhereGroup } = require('../whereGroups');
+const { removeOverriddenQueryProps } = require('../../model/modelQueryProps');
 
 class InstanceUpdateOperation extends UpdateOperation {
   constructor(name, opt) {
@@ -19,6 +20,7 @@ class InstanceUpdateOperation extends UpdateOperation {
 
     if (!this.model) {
       this.model = this.instance;
+      removeOverriddenQueryProps(this.model);
     }
 
     return retVal;