objection 4.0.0-rc.2 → 4.0.0-rc.3

package/lib/queryBuilder/graph/GraphPlan.js

@@ -1,27 +1,14 @@
-import { hasSameColumns, hasSameKey } from './graphKeys.js';
+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(), laterNodes = new Set() }) {
+  constructor({ nodes, graphOptions }) {
     this.nodes = nodes;
-    // The nodes that an earlier pass left to this one before writing them:
-    this.laterNodes = laterNodes;
-    this.currentNodes = [];
-    this.deferredNodes = new Set();
-    // The nodes that earlier passes of the graph decided to keep or inserted,
-    // 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() {
@@ -34,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:
@@ -65,23 +60,35 @@ 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`
@@ -182,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] : []) {
@@ -210,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))),
       ),
     );
 
@@ -289,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) {
@@ -308,7 +312,6 @@ export class GraphPlan {
     }
 
     this.actions = actions;
-    return this;
   }
 
   _canRelate(node) {
@@ -336,14 +339,13 @@ export class GraphPlan {
     );
   }
 
-  // A row that the graph keeps in another place, or that an earlier pass
-  // inserted, 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 or a later pass keeps is still unrelated if
-  // this pass fills its slot with another row, 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);
@@ -358,11 +360,11 @@ export class GraphPlan {
     return (
       relation.keySide !== 'related' ||
       !(isKeptInRelation || isKeptByOwner) ||
-      ((isKeptByOwner || this.deferredNodes.has(keptNode)) && this._hasNewRowInSlot(currentNode))
+      (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 (
@@ -376,51 +378,33 @@ export class GraphPlan {
     );
   }
 
-  // The nodes that keep the row of `node` in other places of the graph, by
-  // relating or patching it there, or that an earlier pass inserted.
-  getKeptNodes(node) {
-    return this.keptNodes.get(node.rowKey) || [];
-  }
-
-  // The nodes that keep their rows in the next passes, once this one is
-  // written: the ones that it decided to keep before its writes, and the ones
-  // that it inserts.
-  getNextKeptNodes() {
-    const keptNodes = new Map(this.keptNodes);
-
-    for (const node of this.activeNodes) {
-      if (this.actions.get(node) === 'insert') {
-        addKeptNode(keptNodes, node);
-      }
-    }
-
-    return keptNodes;
+  // 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 relating or patching them, by row, also
-  // the ones that earlier passes decided to keep or inserted. A row may be kept
-  // in several places.
-  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')) {
-          addKeptNode(this._keptNodesByRowKey, 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) || [];
   }
 }
 
-function addKeptNode(keptNodes, node) {
-  keptNodes.set(node.rowKey, [...(keptNodes.get(node.rowKey) || []), node]);
-}
-
 // 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

package/lib/queryBuilder/graph/GraphSchedule.js

@@ -1,4 +1,4 @@
-import { hasOwnerKey, hasSameKey } from './graphKeys.js';
+import { hasOwnerKey, hasSameColumns, hasSameKey } from './graphKeys.js';
 import { groupBy } from '../../utils/objectUtils.js';
 
 // Order the writes of a planned graph in steps that keep keys and constraints
@@ -14,7 +14,9 @@ import { groupBy } from '../../utils/objectUtils.js';
 //    same order, as the foreign key may be unique.
 // 4. Patch the changed rows, the other relates, and the keys of owners whose
 //    BelongsToOne rows were inserted, related or removed.
-// 5. Remove the BelongsToOne rows that the owners no longer reference.
+// 5. Unrelate the rows that their own to-many relation on their own key leaves
+//    out, e.g. a pet in its own `siblings`, after their own writes.
+// 6. Remove the BelongsToOne rows that the owners no longer reference.
 // Each step writes a row that goes into the slot of a HasOneRelation after the
 // row that moves out of it, unless that closes a cycle.
 // `insertGraph()` only inserts.
@@ -25,16 +27,9 @@ export class GraphSchedule {
     // The nodes that each node waits for, through its keys, its references and
     // the rows that move out of the slots that it goes into:
     this.dependencies = createDependencies(plan, this.keys);
-    // Dependencies that aren't waited for, to break cycles, and the ones of
-    // owners that earlier passes wrote, whose keys are patched in once their
-    // BelongsToOne rows of this pass are written. Deferred keys are written
-    // after the inserts:
-    const activeNodes = new Set(plan.activeNodes);
-    this.deferredDependencies = new Set(
-      [...this.dependencies].flatMap(([node, dependencies]) =>
-        activeNodes.has(node) ? [] : dependencies.filter((dependency) => dependency.relation),
-      ),
-    );
+    // Dependencies that aren't waited for, to break cycles. Deferred keys are
+    // written after the inserts:
+    this.deferredDependencies = new Set();
     // Relates whose rows are moved to their new owners before the removals:
     this.movedNodes = new Set(
       plan.graphOptions.isInsertOnly()
@@ -76,12 +71,19 @@ export class GraphSchedule {
     } else {
       const removedNodes = activeCurrentNodes.filter((node) => actions.get(node) !== 'keep');
       const isReferencedByOwner = (currentNode) => currentNode.relation.keySide === 'owner';
+      // A row that its own to-many relation on its own key leaves out, e.g. a
+      // pet in its own `siblings`, is unrelated after its own writes, which keep
+      // its key. A row in its own slot leaves it before another one goes in:
+      const isOwnRow = ({ relation, parent, rowKey }) =>
+        rowKey === parent.rowKey &&
+        !relation.isOneToOne() &&
+        hasSameColumns(relation.relatedProp, relation.ownerProp);
 
       return [
         ...this._planLevels([...this.movedNodes]).map(({ nodes }) => ({ kind: 'move', nodes })),
         {
           kind: 'remove',
-          nodes: removedNodes.filter((node) => !isReferencedByOwner(node)),
+          nodes: removedNodes.filter((node) => !isReferencedByOwner(node) && !isOwnRow(node)),
           areReferenced: true,
         },
         ...insertSteps,
@@ -98,6 +100,11 @@ export class GraphSchedule {
             );
           }),
         ).map(({ nodes }) => ({ kind: 'patch', nodes })),
+        {
+          kind: 'remove',
+          nodes: removedNodes.filter(isOwnRow),
+          areReferenced: true,
+        },
         {
           kind: 'remove',
           // Owners unrelate their BelongsToOne rows by patching their keys:
@@ -123,8 +130,8 @@ export class GraphSchedule {
     // The keys of models with rows are known, also of related models that were
     // fetched, except for the props that the graph fills in:
     const hasRow = (node) => !!(node.referencedNode || node).existing;
-    // Nodes outside this pass were written by an earlier one, or are never
-    // written, see `checkReferences()`:
+    // Nodes outside of `nodes` are written in other steps, or never, see
+    // `checkReferences()`:
     const getPendingDependencies = (node) =>
       (this.dependencies.get(node) || []).filter(
         (dependency) =>
@@ -347,7 +354,6 @@ export class GraphSchedule {
   // their cycle: the strongly connected components of these references, found
   // with Tarjan's algorithm.
   findReferenceCycles(nodes) {
-    const getRow = (node) => node.referencedNode || node;
     const nodesByRow = groupBy(nodes, getRow);
     const getReferencedNodes = (node) =>
       (this.dependencies.get(node) || [])
@@ -453,8 +459,6 @@ function createDependencies(plan, keys) {
     // A place waits for the inserts and `#ref{}` values that bind the slots of
     // its keys. A dependency on the same row through the same key becomes such
     // a wait, and stays deferrable to break cycles. The other waits aren't:
-    const getRow = (node) => node.referencedNode || node;
-
     for (const { node: waitedNode, prop } of keys.waitsFor(node)) {
       const dependency = (dependencies.get(node) || []).find(
         (dependency) =>
@@ -507,6 +511,11 @@ function getSlotNode(node) {
     : null;
 }
 
+// The row of `node`: a `#ref` model is the model it refers to.
+function getRow(node) {
+  return node.referencedNode || node;
+}
+
 // Return the key props of `node` on its side of the relation of `dependency`.
 function getKeyProps({ relation, related }, node) {
   return (related === node ? relation.relatedProp : relation.ownerProp).props;