objection 4.0.0-rc.1 → 4.0.0-rc.3

package/lib/queryBuilder/graph/GraphPlan.js

@@ -1,22 +1,14 @@
+import { hasOwnerKey, hasSameColumns, hasSameKey } from './graphKeys.js';
+import { groupBy } from '../../utils/objectUtils.js';
+
 // What a graph insert or upsert does with each model of the graph and each row
 // of the current graph: The rules that decide it, and the pruning of branches
 // that nothing is written in.
 export class GraphPlan {
-  constructor({ nodes, graphOptions, keptNodes = new Map() }) {
+  constructor({ nodes, graphOptions }) {
     this.nodes = nodes;
-    this.currentNodes = [];
-    this.deferredNodes = new Set();
-    // The nodes that earlier passes of the graph decided to keep, by row:
-    this.earlierKeptNodes = keptNodes;
     this.graphOptions = graphOptions;
-    this.actions = null;
-    // The decisions only change while the current graph is loaded, and are
-    // cached once it is, see `cacheDecisions()`:
-    this._intents = null;
-    this._nodeActions = null;
-    this._activeNodes = null;
-    this._activeCurrentNodes = null;
-    this._keptNodesByRowKey = null;
+    this.reset();
   }
 
   get activeNodes() {
@@ -29,16 +21,24 @@ export class GraphPlan {
     ));
   }
 
-  // Leave `nodes` to a later pass of the graph.
-  defer(nodes) {
-    this.deferredNodes = new Set(nodes);
-    this.nodes = this.nodes.filter((node) => !this.deferredNodes.has(node));
-    this._activeNodes = null;
-  }
+  // Forget the current graph and what was decided with it, before it's loaded.
+  // The decisions only change while it's loaded, and are cached once it is,
+  // see `plan()`.
+  reset() {
+    for (const node of this.nodes) {
+      node.current = null;
+      node.row = null;
+      node.isMissing = false;
+      node.isPruned = false;
+    }
 
-  cacheDecisions() {
-    this._intents = new Map();
-    this._nodeActions = new Map();
+    this.currentNodes = [];
+    this.actions = null;
+    this._intents = null;
+    this._nodeActions = null;
+    this._activeNodes = null;
+    this._activeCurrentNodes = null;
+    this._keptNodesByRowKey = null;
   }
 
   // What the data asks to do with `node`, before the options that disable it:
@@ -60,23 +60,49 @@ export class GraphPlan {
   _getIntent(node) {
     const insertMissing = this.graphOptions.has(node, 'insertMissing');
 
-    return node.toBeUnrelatedOrDeleted
-      ? 'remove'
-      : node.isReference
-        ? 'relate'
-        : node.isMissing
-          ? insertMissing
-            ? 'insert'
-            : this.findInsertingNode(node)
-              ? 'relate'
-              : 'missing'
-          : node.isDbReference || this._canRelate(node)
-            ? 'relate'
-            : node.current
-              ? 'patch'
-              : !node.hasId || insertMissing
-                ? 'insert'
-                : 'missing';
+    if (node.toBeUnrelatedOrDeleted) {
+      return 'remove';
+    } else if (node.isReference) {
+      return 'relate';
+    } else if (node.isMissing) {
+      return insertMissing ? 'insert' : this.findInsertingNode(node) ? 'relate' : 'missing';
+    } else if (node.isDbReference || this._canRelate(node)) {
+      return 'relate';
+    } else if (node.current) {
+      return 'patch';
+    } else if (!node.hasId || insertMissing) {
+      return 'insert';
+    } else {
+      return this._isRelatedByOthers(node) ? 'relate' : 'missing';
+    }
+  }
+
+  // Return true if another model of the graph relates the row of `node` to the
+  // same place, the same relation of the same row, as below the owner that a
+  // moved row names.
+  _isRelatedByOthers(node) {
+    return this.nodes.some(
+      (other) =>
+        other !== node &&
+        other.rowKey === node.rowKey &&
+        other.relation === node.relation &&
+        other.parent?.rowKey === node.parent?.rowKey &&
+        this._canRelate(other),
+    );
+  }
+
+  // Return true if the model of the `#ref` model `node` writes what `node`
+  // would write to the row: The model is inserted, or it's written and its path
+  // allows any write that the path of `node` allows.
+  isCoveredByModel(node) {
+    const { actions, graphOptions } = this;
+    const { referencedNode } = node;
+    const action = actions.get(referencedNode);
+    const allowsWrite = (node) => graphOptions.shouldPatch(node) || graphOptions.shouldUpdate(node);
+    return (
+      action === 'insert' ||
+      (['relate', 'patch'].includes(action) && (allowsWrite(referencedNode) || !allowsWrite(node)))
+    );
   }
 
   // Return true if the graph writes the branch below `node`: below models at
@@ -146,11 +172,11 @@ export class GraphPlan {
     } else if (this._hasIgnoredOtherModel(currentNode)) {
       return 'keep';
     } else {
-      const keptNode = this.keptNodeForRow(currentNode);
+      const keptNodes = this.getKeptNodes(currentNode);
 
-      if (keptNode && !this._isUnrelatedWhenKept(currentNode, keptNode)) {
+      if (keptNodes.some((keptNode) => !this._isUnrelatedWhenKept(currentNode, keptNode))) {
         return 'keep';
-      } else if (keptNode || has('unrelate')) {
+      } else if (keptNodes.length > 0 || has('unrelate')) {
         // Rows that the graph keeps in another place must not be deleted
         // (#214). They're unrelated instead, which replaces the delete, so
         // `noDelete` disables it too, unless the `unrelate` option asks for it.
@@ -163,13 +189,11 @@ export class GraphPlan {
 
   // Leave out the branches that require no writes. We never do anything below
   // models that are removed, and we never delete recursively.
-  prune() {
+  _prune() {
     const isInsertOnly = this.graphOptions.isInsertOnly();
-    const passNodes = new Set([...this.nodes, ...this.currentNodes]);
-    // The rows that were fetched for pruned nodes are left alone too. Nodes of
-    // later passes aren't pruned here:
+    // The rows that were fetched for pruned nodes are left alone too:
     const pruneNodes = (nodes) => {
-      for (const node of nodes.filter((node) => passNodes.has(node))) {
+      for (const node of nodes) {
         node.isPruned = true;
 
         for (const row of node.row ? [node.row, ...node.row.descendants] : []) {
@@ -191,10 +215,7 @@ export class GraphPlan {
         (node) =>
           !node.current &&
           this.intentFor(node) !== 'insert' &&
-          !(
-            this.actionFor(node) === 'relate' &&
-            (node.row || (node.isReference && !this.graphOptions.isInsertOnly()))
-          ),
+          !(this.actionFor(node) === 'relate' && (node.row || (node.isReference && !isInsertOnly))),
       ),
     );
 
@@ -270,14 +291,16 @@ export class GraphPlan {
       pruneDescendants(markedNodes);
       pruneDescendants(markedNodes.map((node) => node.current).filter(Boolean));
     }
-
-    return this;
   }
 
-  // Decide what to do with each node once, before the first write, since the
-  // writes change the models that the rules read. Only call this after
-  // pruning.
+  // Decide what to do with each node once the current graph is loaded, and
+  // before the first write, since the writes change the models that the rules
+  // read: Cache the decisions, leave out the branches that require no writes,
+  // and set `actions`.
   plan() {
+    this._intents = new Map();
+    this._nodeActions = new Map();
+    this._prune();
     const actions = new Map();
 
     for (const node of this.activeNodes) {
@@ -289,7 +312,6 @@ export class GraphPlan {
     }
 
     this.actions = actions;
-    return this;
   }
 
   _canRelate(node) {
@@ -317,21 +339,32 @@ export class GraphPlan {
     );
   }
 
-  // A row that the graph keeps in another place is unrelated here, unless the
-  // other place relates or patches it through the same key column: Then that
-  // place writes the key, which may not be nullable. A has-one row that a
-  // later pass moves is still unrelated if this pass writes another row into
-  // its slot, as the foreign key may be unique (#398).
+  // A row that the graph keeps in another place is unrelated here, unless one
+  // of these places sets the same key column, by relating, patching or
+  // inserting it through such a relation, or through its own
+  // BelongsToOneRelation, e.g. `parent` for `children`: Then that place writes
+  // the key, which may not be nullable. A has-one row that its own
+  // BelongsToOneRelation keeps is still unrelated if the graph fills its slot
+  // with another row, as the foreign key may be unique (#398).
   _isUnrelatedWhenKept(currentNode, keptNode) {
     const { relation } = currentNode;
+    const isKeptInRelation = hasSameKey(relation, keptNode.relation);
+    const isKeptByOwner =
+      !isKeptInRelation &&
+      keptNode.activeChildren.some(
+        (child) =>
+          child.relation.keySide === 'owner' &&
+          this.actionFor(child) !== 'ignore' &&
+          hasSameColumns(child.relation.ownerProp, relation.relatedProp),
+      );
     return (
       relation.keySide !== 'related' ||
-      !hasSameKey(relation, keptNode.relation) ||
-      (this.deferredNodes.has(keptNode) && this._hasNewRowInSlot(currentNode))
+      !(isKeptInRelation || isKeptByOwner) ||
+      (isKeptByOwner && this._hasNewRowInSlot(currentNode))
     );
   }
 
-  // Return true if this pass inserts or relates a row into the slot of the
+  // Return true if the graph inserts or relates a row into the slot of the
   // has-one relation that `currentNode` is in.
   _hasNewRowInSlot(currentNode) {
     return (
@@ -345,46 +378,33 @@ export class GraphPlan {
     );
   }
 
-  // Find the node that keeps the row of `currentNode` in another place of the
-  // graph, by relating or patching it there, also in another pass.
-  keptNodeForRow(currentNode) {
-    return this.keptNodes.get(currentNode.rowKey) || null;
+  // The BelongsToOne relations whose current rows `node` removes with `null`,
+  // `#unrelate` or `#delete`, and whose keys it clears.
+  getRemovedOwnerRelations(node) {
+    return (node.existing?.activeChildren || [])
+      .filter(
+        (currentChild) =>
+          hasOwnerKey(currentChild.relation) &&
+          (node.obj[currentChild.relation.name] === null ||
+            currentChild.node?.toBeUnrelatedOrDeleted) &&
+          this.actions.get(currentChild) !== 'keep',
+      )
+      .map(({ relation }) => relation);
   }
 
-  // The nodes that keep their rows, by row, also the ones that earlier passes
-  // decided to keep.
-  get keptNodes() {
-    if (!this._keptNodesByRowKey) {
-      this._keptNodesByRowKey = new Map(this.earlierKeptNodes);
-
-      for (const node of [...this.activeNodes, ...this.deferredNodes]) {
-        const action = this.actionFor(node);
-
-        if (node.obj.$hasId() && (action === 'relate' || action === 'patch')) {
-          this._keptNodesByRowKey.set(node.rowKey, node);
-        }
-      }
-    }
-
-    return this._keptNodesByRowKey;
+  // The nodes that keep the row of `node` in other places of the graph, by
+  // relating or patching it there. A row may be kept in several places.
+  getKeptNodes(node) {
+    this._keptNodesByRowKey ??= groupBy(
+      this.activeNodes.filter(
+        (node) => node.obj.$hasId() && ['relate', 'patch'].includes(this.actionFor(node)),
+      ),
+      (node) => node.rowKey,
+    );
+    return this._keptNodesByRowKey.get(node.rowKey) || [];
   }
 }
 
-// Return true if both relations keep the keys of their related rows in the same
-// columns, also the same JSON paths of them.
-function hasSameKey(relation, otherRelation) {
-  const { relatedProp } = relation;
-  const otherProp = otherRelation?.keySide === 'related' ? otherRelation.relatedProp : null;
-  return (
-    !!otherProp &&
-    relation.relatedModelClass.getTableName() === otherRelation.relatedModelClass.getTableName() &&
-    relatedProp.size === otherProp.size &&
-    relatedProp.props.every(
-      (_, i) => relatedProp.propDescription(i) === otherProp.propDescription(i),
-    )
-  );
-}
-
 // For `HasMany` and `HasOne` relations, the relate prop is the id of the
 // related model. Use the id state of the input graph, since the parent's
 // insert copies the foreign key into the related model, which can complete