objection 4.0.0-rc.2 → 4.0.0-rc.4

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,48 @@ 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 graph relates the row of `node` by the key of its
+  // BelongsToOneRelation alone, without an id or a reference.
+  isRelatedByKey(node) {
+    return (
+      this.actions.get(node) === 'relate' &&
+      node.relation.keySide === 'owner' &&
+      !node.hasId &&
+      !node.isReference &&
+      !node.isDbReference &&
+      node.propertyReferences.length === 0
+    );
   }
 
   // Return true if the model of the `#ref` model `node` writes what `node`
@@ -182,13 +202,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 +228,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 +304,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 +325,6 @@ export class GraphPlan {
     }
 
     this.actions = actions;
-    return this;
   }
 
   _canRelate(node) {
@@ -336,14 +352,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 +373,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 +391,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,20 +1,27 @@
-import { hasOwnerKey, hasSameKey } from './graphKeys.js';
+import { hasOwnerKey, hasSameColumns, hasSameKey } from './graphKeys.js';
 import { groupBy } from '../../utils/objectUtils.js';
+import { ValidationErrorType } from '../../model/ValidationError.js';
+import { formatPath } from './GraphNode.js';
 
 // Order the writes of a planned graph in steps that keep keys and constraints
 // intact (#214), which `GraphWriter` writes:
 // 1. Move the rows that the graph relates to existing owners of HasMany and
 //    HasOne relations, as they may still sit below rows that the next step
-//    deletes. Rows that wait for inserts are related in step 3 or 4.
+//    deletes. Rows that wait for inserts or changed keys are related in step 3
+//    or 4.
 // 2. Remove rows that reference their owners, before the inserts that may need
 //    their unique keys.
 // 3. Insert the new rows in the order of their keys and references, then the
 //    keys deferred to break cycles and the join rows. Rows that move out of
 //    the slots of HasOneRelations that new rows go into are related in the
-//    same order, as the foreign key may be unique.
+//    same order, as the foreign key may be unique, and so are the patches and
+//    relates that change the keys that these rows read, as a foreign key may
+//    reference them (#428).
 // 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.
@@ -23,27 +30,20 @@ export class GraphSchedule {
     this.plan = plan;
     this.keys = keys;
     // 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:
+    // the rows that move out of the slots that it goes into. `isKeyChange`
+    // marks the patches and relates that change the keys it reads:
     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()
         ? []
         : plan.activeNodes.filter((node) => this._isMovedFirst(node)),
     );
-    // Relates that move the rows out of the slots of HasOneRelations that new
-    // rows go into, and that aren't moved first:
-    this.slotMovedNodes = this._getSlotMovedNodes();
+    // Relates and patches that aren't moved first but written in the inserts:
+    this.earlyNodes = this._getEarlyNodes();
     this.steps = this._planSteps();
   }
 
@@ -76,12 +76,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,
@@ -89,15 +96,19 @@ export class GraphSchedule {
           activeNodes.filter((node) => {
             const action = actions.get(node);
             return (
-              (action === 'patch' ||
-                (action === 'relate' &&
-                  !this.movedNodes.has(node) &&
-                  !this.slotMovedNodes.has(node))) &&
+              ['patch', 'relate'].includes(action) &&
+              !this.movedNodes.has(node) &&
+              !this.earlyNodes.has(node) &&
               // The row of a `#ref` model is written once, by its model:
               !this._isWrittenByModel(node)
             );
           }),
         ).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 +134,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) =>
@@ -205,7 +216,25 @@ export class GraphSchedule {
           }
         }
       } else if (!breakCycle()) {
-        throw new Error('the object graph contains cyclic references');
+        // A patch that changes a key that the rows it waits for read can be
+        // written neither before nor after them:
+        const { node: changingNode } =
+          nodes
+            .filter((node) => !handledNodes.has(node))
+            .flatMap(getPendingDependencies)
+            .find(
+              ({ node, dependent, isKeyChange }) => isKeyChange && isBlockedBy(node, dependent),
+            ) || {};
+
+        if (changingNode) {
+          const { modelClass, dataPathKey } = changingNode;
+          throw modelClass.createValidationError({
+            type: ValidationErrorType.InvalidGraph,
+            message: `the graph changes a key of the ${modelClass.name} at ${formatPath(dataPathKey)} that rows read which it also waits for; write the key in a separate query first`,
+          });
+        } else {
+          throw new Error('the object graph contains cyclic references');
+        }
       }
     }
 
@@ -238,9 +267,10 @@ export class GraphSchedule {
 
   // Return true if the HasMany or HasOne relate of `node` moves its row to an
   // existing owner before the removals, see the steps above. `#ref` models may
-  // get their ids from the inserts, rows that wait for the inserts are written
-  // once they're known, and a relate into the slot of a HasOne row waits for
-  // the removal of that row, or its move, as its key may be unique.
+  // get their ids from the inserts, rows that wait for the inserts or for
+  // changed keys are written after them, and a relate into the slot of a HasOne
+  // row waits for the removal of that row, or its move, as its key may be
+  // unique.
   _isMovedFirst(node, visitedNodes = new Set()) {
     const { actions } = this.plan;
     visitedNodes.add(node);
@@ -250,7 +280,7 @@ export class GraphSchedule {
       !node.isReference &&
       node.relation.keySide === 'related' &&
       node.parent.existing &&
-      !this._waitsForInserts(node)
+      !this._waitsForWrites(node)
     ) {
       const slotNode = getSlotNode(node);
       const moverNode = getSlotMover(this.plan, node);
@@ -264,24 +294,32 @@ export class GraphSchedule {
     }
   }
 
-  // Find the relates that move the rows out of the slots of HasOneRelations
-  // that new rows go into, and that aren't moved first. They're related in the
-  // inserts, along with the relates that move the rows out of their own slots,
-  // as the foreign key may be unique.
-  _getSlotMovedNodes() {
+  // Find the relates and patches that are written in the inserts, as the rows
+  // written there wait for them: The relates that move the rows out of the
+  // slots of HasOneRelations that new rows go into, along with the relates that
+  // move the rows out of their own slots, as the foreign key may be unique, and
+  // the patches and relates that change the keys that these rows or join rows
+  // read, as a foreign key may reference them (#428).
+  _getEarlyNodes() {
+    const { actions } = this.plan;
     const nodes = new Set();
-    const addMoverNodes = (node) => {
-      for (const { node: moverNode, isSlotMove } of this.dependencies.get(node) || []) {
-        if (isSlotMove && !this.movedNodes.has(moverNode) && !nodes.has(moverNode)) {
-          nodes.add(moverNode);
-          addMoverNodes(moverNode);
+    const addEarlyNodes = (node) => {
+      for (const dependency of this.dependencies.get(node) || []) {
+        const { node: earlyNode, isSlotMove, isKeyChange } = dependency;
+        if (
+          (isSlotMove || isKeyChange) &&
+          !this.movedNodes.has(earlyNode) &&
+          !nodes.has(earlyNode)
+        ) {
+          nodes.add(earlyNode);
+          addEarlyNodes(earlyNode);
         }
       }
     };
 
     for (const node of this.plan.activeNodes) {
-      if (this.plan.actions.get(node) === 'insert') {
-        addMoverNodes(node);
+      if (actions.get(node) === 'insert' || (node.relation?.keySide === 'join' && !node.current)) {
+        addEarlyNodes(node);
       }
     }
 
@@ -310,19 +348,21 @@ export class GraphSchedule {
   }
 
   // Return true if `node` waits for the keys or references of inserted models,
-  // also through the models that it references (#356), and through the models
-  // that it waits for to get its keys.
-  _waitsForInserts(node, visitedNodes = new Set()) {
+  // or for keys that patches change (#428), also through the models that it
+  // references (#356), and through the models that it waits for to get its
+  // keys.
+  _waitsForWrites(node, visitedNodes = new Set()) {
     const { actions } = this.plan;
     visitedNodes.add(node);
     return (this.dependencies.get(node) || []).some((dependency) => {
-      const { node: dependencyNode, relation } = dependency;
+      const { node: dependencyNode, relation, isKeyWait, isKeyChange } = dependency;
       const referencedNode = dependencyNode.referencedNode || dependencyNode;
       return (
         actions.get(referencedNode) === 'insert' ||
-        ((!relation || dependency.isKeyWait) &&
+        isKeyChange ||
+        ((!relation || isKeyWait) &&
           !visitedNodes.has(referencedNode) &&
-          this._waitsForInserts(referencedNode, visitedNodes))
+          this._waitsForWrites(referencedNode, visitedNodes))
       );
     });
   }
@@ -347,7 +387,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) || [])
@@ -452,20 +491,23 @@ 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)) {
+    // a wait, and stays deferrable to break cycles. The other waits aren't. A
+    // key change is waited for at the node that writes it, not at a `#ref`
+    // model of its row, which writes nothing:
+    for (const { node: waitedNode, prop, isKeyChange } of keys.waitsFor(node)) {
       const dependency = (dependencies.get(node) || []).find(
         (dependency) =>
-          getRow(dependency.node) === getRow(waitedNode) &&
+          (isKeyChange
+            ? dependency.node === waitedNode
+            : getRow(dependency.node) === getRow(waitedNode)) &&
           (!dependency.relation || getKeyProps(dependency, node).includes(prop)),
       );
 
       if (dependency) {
         dependency.isKeyWait = true;
+        dependency.isKeyChange ||= isKeyChange;
       } else {
-        addDependency(node, { node: waitedNode, isKeyWait: true });
+        addDependency(node, { node: waitedNode, isKeyWait: true, isKeyChange });
       }
     }
 
@@ -507,6 +549,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;