objection 4.0.0-rc.1 → 4.0.0-rc.2

package/lib/queryBuilder/graph/GraphLoader.js

@@ -1,4 +1,4 @@
-import { asArray, chunk, groupBy, uniqBy } from '../../utils/objectUtils.js';
+import { asArray, chunk, groupBy } from '../../utils/objectUtils.js';
 import { getMaxRows } from '../../utils/knexUtils.js';
 import { FetchStrategy } from './GraphOptions.js';
 import { GraphNode } from './GraphNode.js';
@@ -25,7 +25,10 @@ export async function loadCurrentGraph(builder, plan) {
       fetchedNodes.add(node);
     }
 
-    for (const [isMovedRow, groupNodes] of groupBy(nodes, (node) => areRelated && isMoved(node))) {
+    // The roots of a later pass were moved by an earlier one:
+    const isMovedNode = (node) => areRelated && isMoved(node) && passNodes.has(node.parent);
+
+    for (const [isMovedRow, groupNodes] of groupBy(nodes, isMovedNode)) {
       for (const nodesOfClass of groupBy(groupNodes, (node) => node.modelClass).values()) {
         const models = await fetchModels(builder, plan.graphOptions, nodesOfClass, {
           withRelations: !isMovedRow,
@@ -84,8 +87,13 @@ export async function loadCurrentGraph(builder, plan) {
     });
   };
 
+  // The roots of the pass are at their places, except for the relates that an
+  // earlier pass left to this one:
   await fetch(
-    plan.nodes.filter((node) => !passNodes.has(node.parent) && node.hasId),
+    plan.nodes.filter(
+      (node) =>
+        !passNodes.has(node.parent) && node.hasId && !(plan.laterNodes.has(node) && !node.current),
+    ),
     { areRelated: false },
   );
 
@@ -159,11 +167,12 @@ function hasRelations(obj) {
 // their ids, in as many queries as the number of their ids requires.
 async function fetchModels(builder, graphOptions, nodes, options) {
   const [{ modelClass }] = nodes;
-  const uniqueNodes = uniqBy(nodes, (node) => node.obj.$idKey());
+  const nodesByRow = [...groupBy(nodes, (node) => node.obj.$idKey()).values()];
   const maxIds = getMaxRows(builder.unsafeKnex(), modelClass.getIdColumnArray().length);
   const models = [];
 
-  for (const chunkNodes of chunk(uniqueNodes, maxIds)) {
+  // Fetch each row once, with the relations of all its places:
+  for (const chunkNodes of chunk(nodesByRow, maxIds)) {
     models.push(...(await fetchModelsOfNodes(builder, graphOptions, chunkNodes, options)));
   }
 
@@ -173,11 +182,12 @@ async function fetchModels(builder, graphOptions, nodes, options) {
 function fetchModelsOfNodes(
   builder,
   graphOptions,
-  nodes,
+  nodesByRow,
   { withRelations = false, onlyIds = false },
 ) {
-  const [{ modelClass }] = nodes;
-  const ids = nodes.map((node) => node.obj.$id());
+  const [[{ modelClass }]] = nodesByRow;
+  const ids = nodesByRow.map(([node]) => node.obj.$id());
+  const nodes = nodesByRow.flat();
   const expression = RelationExpression.fromModelGraph(
     withRelations ? nodes.map((node) => node.obj) : [],
   );

package/lib/queryBuilder/graph/GraphNode.js

@@ -233,3 +233,9 @@ export function createNotModelError(modelClass, value) {
     message: `expected value "${value}" to be an instance of ${modelClass.name}`,
   });
 }
+
+// Name the place of a model in error messages, by its data path.
+export function formatPath(dataPathKey) {
+  const path = dataPathKey.replace(/^\./, '');
+  return path ? `'${path}'` : 'the root';
+}

package/lib/queryBuilder/graph/GraphPlan.js

@@ -1,12 +1,17 @@
+import { hasSameColumns, hasSameKey } from './graphKeys.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, keptNodes = new Map(), laterNodes = new Set() }) {
     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, by row:
+    // The nodes that earlier passes of the graph decided to keep or inserted,
+    // by row:
     this.earlierKeptNodes = keptNodes;
     this.graphOptions = graphOptions;
     this.actions = null;
@@ -79,6 +84,20 @@ export class GraphPlan {
                 : 'missing';
   }
 
+  // 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
   // their place, inserted models, related models with fetched rows and `#ref`
   // models, but not below removed or ignored ones.
@@ -146,11 +165,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.
@@ -317,17 +336,29 @@ 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, 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).
   _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.deferredNodes.has(keptNode)) && this._hasNewRowInSlot(currentNode))
     );
   }
 
@@ -345,14 +376,30 @@ 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 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 nodes that keep their rows, by row, also the ones that earlier passes
-  // decided to keep.
+  // 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);
@@ -361,7 +408,7 @@ export class GraphPlan {
         const action = this.actionFor(node);
 
         if (node.obj.$hasId() && (action === 'relate' || action === 'patch')) {
-          this._keptNodesByRowKey.set(node.rowKey, node);
+          addKeptNode(this._keptNodesByRowKey, node);
         }
       }
     }
@@ -370,19 +417,8 @@ export class GraphPlan {
   }
 }
 
-// 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),
-    )
-  );
+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