objection 3.1.5 → 3.3.0

package/lib/queryBuilder/StaticHookArguments.js

@@ -24,7 +24,13 @@ class StaticHookArguments {
 
   get asFindQuery() {
     return () => {
-      return this[BUILDER_SYMBOL].toFindQuery().clearWithGraphFetched().runAfter(asArray);
+      // The `runAfter()` callbacks of the query being executed (including the
+      // ones installed by `throwIfNotFound()` and `traverse()`) are meant for
+      // its result, not for the result of this find query.
+      return this[BUILDER_SYMBOL].toFindQuery()
+        .clear('runAfter')
+        .clearWithGraphFetched()
+        .runAfter(toArray);
     };
   }
 
@@ -97,6 +103,11 @@ class StaticHookArguments {
   }
 }
 
+// Like `asArray()`, but an empty `first()` result becomes an empty array.
+function toArray(result) {
+  return result === undefined ? [] : asArray(result);
+}
+
 function getRelation(op) {
   return op.relation;
 }

package/lib/queryBuilder/graph/GraphFetcher.js

@@ -141,7 +141,9 @@ function shouldSelectColumn(column, selects, node) {
     !selects.has(column) &&
     column !== modelClass.propertyNameToColumnName(modelClass.dbRefProp) &&
     column !== modelClass.propertyNameToColumnName(modelClass.uidRefProp) &&
-    column !== modelClass.propertyNameToColumnName(modelClass.uidProp)
+    column !== modelClass.propertyNameToColumnName(modelClass.uidProp) &&
+    column !== modelClass.propertyNameToColumnName(modelClass.graphUnrelateProp) &&
+    column !== modelClass.propertyNameToColumnName(modelClass.graphDeleteProp)
   );
 }
 

package/lib/queryBuilder/graph/GraphOptions.js

@@ -51,6 +51,10 @@ class GraphOptions {
 
   // Like `shouldRelate` but ignores settings that explicitly disable relate operations.
   shouldRelateIgnoreDisable(node, graphData) {
+    if (node.toBeUnrelated || node.toBeDeleted) {
+      return false;
+    }
+
     if (node.isReference || node.isDbReference) {
       return true;
     }
@@ -71,6 +75,10 @@ class GraphOptions {
 
   // Like `shouldInsert` but ignores settings that explicitly disable insert operations.
   shouldInsertIgnoreDisable(node, graphData) {
+    if (node.toBeUnrelated || node.toBeDeleted) {
+      return false;
+    }
+
     return (
       !getCurrentNode(node, graphData) &&
       !this.shouldRelateIgnoreDisable(node, graphData) &&
@@ -89,6 +97,10 @@ class GraphOptions {
   // Like `shouldPatch() || shouldUpdate()` but ignores settings that explicitly disable
   // update or patch operations.
   shouldPatchOrUpdateIgnoreDisable(node, graphData) {
+    if (node.toBeUnrelated || node.toBeDeleted) {
+      return false;
+    }
+
     if (this.shouldRelate(node, graphData)) {
       // We should update all nodes that are going to be related. Note that
       // we don't actually update anything unless there is something to update
@@ -121,16 +133,23 @@ class GraphOptions {
   }
 
   shouldUnrelate(currentNode, graphData) {
+    const node = getNode(currentNode, graphData.graph);
+    if (node && node.toBeUnrelated) return true;
+
     return (
-      !getNode(currentNode, graphData.graph) &&
+      !node &&
       !this._hasOption(currentNode, NO_UNRELATE) &&
       this.shouldUnrelateIgnoreDisable(currentNode)
     );
   }
 
   shouldDelete(currentNode, graphData) {
+    const node = getNode(currentNode, graphData.graph);
+    // `#unrelate` takes precedence over `#delete` if both are set.
+    if (node && node.toBeDeleted && !node.toBeUnrelated) return true;
+
     return (
-      !getNode(currentNode, graphData.graph) &&
+      !node &&
       !this._hasOption(currentNode, NO_DELETE) &&
       !this.shouldUnrelateIgnoreDisable(currentNode)
     );

package/lib/queryBuilder/graph/GraphUpsert.js

@@ -14,6 +14,7 @@ const { RelationExpression } = require('../RelationExpression');
 const { GraphNodeDbExistence } = require('./GraphNodeDbExistence');
 const { GraphData } = require('./GraphData');
 const { uniqBy, asArray, isObject } = require('../../utils/objectUtils');
+const { deprecate } = require('../../utils/deprecate');
 
 class GraphUpsert {
   constructor({ rootModelClass, objects, upsertOptions }) {
@@ -28,6 +29,23 @@ class GraphUpsert {
     return { skipValidation: true };
   }
 
+  // A graph is written using many insert queries (one per batch and table),
+  // so there's no single insert query an `onConflict` clause could be applied
+  // to. Even applying it to the root table only would be unsound: rows skipped
+  // 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.
+  static warnOnConflict(builder, method) {
+    if (builder.has(isOnConflictOperation)) {
+      deprecate(
+        `onConflict(), ignore() and merge() are not supported by ${method}(). ` +
+          'Insert the conflicting rows with a separate insert() query instead. ' +
+          'This will throw in objection 4.0.',
+      );
+    }
+  }
+
   run(builder) {
     const modelClass = builder.modelClass();
     const graphOptions = new GraphOptions(this.upsertOpt);
@@ -91,6 +109,7 @@ function pruneGraphs() {
 
     if (!graphData.graphOptions.isInsertOnly()) {
       pruneDeletedBranches(graphData);
+      pruneUnrelatedOrDeletedBranches(graphData);
     }
 
     return graphData;
@@ -136,6 +155,19 @@ function pruneDeletedBranches(graphData) {
   removeNodesFromGraph(new Set(rootsNotInRelation), currentGraph);
 }
 
+// Models marked with `#unrelate` or `#delete` are unrelated or deleted
+// as a whole. Their relations are ignored, both in the upserted graph
+// and in the current graph.
+function pruneUnrelatedOrDeletedBranches(graphData) {
+  const { graph, currentGraph } = graphData;
+
+  const roots = findRoots(graph.nodes.filter((node) => node.toBeUnrelatedOrDeleted));
+  const currentRoots = roots.map((node) => currentGraph.nodeForNode(node)).filter(Boolean);
+
+  removeBranchesFromGraph(roots, graph);
+  removeBranchesFromGraph(currentRoots, currentGraph);
+}
+
 function findRoots(nodes) {
   const nodeSet = new Set(nodes);
 
@@ -192,6 +224,7 @@ function checkForErrors(builder) {
     checkForNotFoundErrors(graphData, builder);
     checkForUnallowedRelationErrors(graphData, builder);
     checkForUnallowedReferenceErrors(graphData, builder);
+    checkForRootUnrelateOrDeleteErrors(graphData, builder);
 
     if (graphData.graphOptions.isInsertOnly()) {
       checkForHasManyRelateErrors(graphData);
@@ -207,6 +240,8 @@ function checkForNotFoundErrors(graphData, builder) {
   for (const node of graph.nodes) {
     if (
       node.obj.$hasId() &&
+      !node.toBeUnrelated &&
+      !node.toBeDeleted &&
       !graphOptions.shouldInsertIgnoreDisable(node, graphData) &&
       !graphOptions.shouldRelateIgnoreDisable(node, graphData) &&
       !currentGraph.nodeForNode(node)
@@ -259,6 +294,19 @@ function checkForUnallowedReferenceErrors(graphData, builder) {
   }
 }
 
+function checkForRootUnrelateOrDeleteErrors(graphData, builder) {
+  for (const node of graphData.graph.nodes) {
+    if (!node.parentEdge && node.toBeUnrelatedOrDeleted) {
+      const { graphUnrelateProp, graphDeleteProp } = node.modelClass;
+
+      throw builder.modelClass().createValidationError({
+        type: ValidationErrorType.InvalidGraph,
+        message: `${graphUnrelateProp} and ${graphDeleteProp} can only be used for related models, not for root models`,
+      });
+    }
+  }
+}
+
 function checkForHasManyRelateErrors(graphData) {
   const { graph, graphOptions } = graphData;
 
@@ -296,6 +344,10 @@ function executeActions(builder, actions) {
   );
 }
 
+function isOnConflictOperation(op) {
+  return op.name === 'onConflict' || op.name === 'ignore' || op.name === 'merge';
+}
+
 function returnResult(objects, isArray) {
   return () => (isArray ? objects : objects[0]);
 }

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

@@ -40,20 +40,26 @@ class GraphDeleteAction extends GraphAction {
       const nodesByParent = groupBy(nodes, getParent);
 
       nodesByParent.forEach((nodes, parentNode) => {
-        const shouldUnrelate = this.graphOptions.shouldUnrelate(nodes[0], this.graphData);
-
-        const builder = parentNode.obj.$relatedQuery(relation.name).childQueryOf(parentBuilder);
-
-        if (!relation.isObjectionBelongsToOneRelation) {
-          // This is useless in case of BelongsToOneRelation.
-          builder.findByIds(nodes.map((node) => node.obj.$id()));
-        }
-
-        for (const node of nodes) {
-          node.userData.deleted = true;
-        }
-
-        builders.push(shouldUnrelate ? builder.unrelate() : builder.delete());
+        // Nodes of the same relation and parent can still require different
+        // operations when they are marked with `#unrelate` or `#delete`.
+        const nodesByShouldUnrelate = groupBy(nodes, (node) =>
+          this.graphOptions.shouldUnrelate(node, this.graphData),
+        );
+
+        nodesByShouldUnrelate.forEach((nodes, shouldUnrelate) => {
+          const builder = parentNode.obj.$relatedQuery(relation.name).childQueryOf(parentBuilder);
+
+          if (!relation.isObjectionBelongsToOneRelation) {
+            // This is useless in case of BelongsToOneRelation.
+            builder.findByIds(nodes.map((node) => node.obj.$id()));
+          }
+
+          for (const node of nodes) {
+            node.userData.deleted = true;
+          }
+
+          builders.push(shouldUnrelate ? builder.unrelate() : builder.delete());
+        });
       });
     });
 

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

@@ -0,0 +1,57 @@
+'use strict';
+
+const { GraphAction } = require('../GraphAction');
+const { groupBy } = require('../../../utils/objectUtils');
+const promiseUtils = require('../../../utils/promiseUtils');
+
+/**
+ * Patches in the foreign keys of `BelongsToOneRelation` edges that `GraphInsert`
+ * had to defer to break a dependency cycle. The owner nodes of these edges were
+ * inserted without the foreign keys. `GraphInsertAction` already copied them to
+ * the owner objects once the related nodes were inserted, so all that's left to
+ * do is one patch query per owner.
+ */
+class DeferredRelationGraphInsertAction extends GraphAction {
+  constructor(graphData, { edges }) {
+    super(graphData);
+
+    // `BelongsToOneRelation` edges whose owner node needs to be patched.
+    this.edges = edges;
+  }
+
+  run(builder) {
+    const edgesByOwner = groupBy(this.edges, (edge) => edge.ownerNode);
+    const owners = [...edgesByOwner.keys()];
+    const concurrency = this._getConcurrency(builder, owners);
+
+    return promiseUtils.map(
+      owners,
+      (owner) => this._patchOwner(builder, owner, edgesByOwner.get(owner)),
+      { concurrency },
+    );
+  }
+
+  _patchOwner(builder, ownerNode, edges) {
+    const { modelClass } = ownerNode;
+    const ownerIdProp = modelClass.getIdRelationProperty();
+    const patch = {};
+
+    for (const { relation } of edges) {
+      const { ownerProp } = relation;
+
+      ownerProp.forEach((i) => {
+        ownerProp.patch(patch, i, ownerProp.getProp(ownerNode.obj, i));
+      });
+    }
+
+    return modelClass
+      .query()
+      .childQueryOf(builder)
+      .patch(patch)
+      .whereInComposite(ownerIdProp.refs(builder), [ownerIdProp.getProps(ownerNode.obj)]);
+  }
+}
+
+module.exports = {
+  DeferredRelationGraphInsertAction,
+};

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

@@ -1,6 +1,7 @@
 'use strict';
 
 const { JoinRowGraphInsertAction } = require('./JoinRowGraphInsertAction');
+const { DeferredRelationGraphInsertAction } = require('./DeferredRelationGraphInsertAction');
 const { GraphInsertAction } = require('./GraphInsertAction');
 const { GraphOperation } = require('../GraphOperation');
 const { ModelGraphEdge } = require('../../../model/graph/ModelGraphEdge');
@@ -9,10 +10,15 @@ class GraphInsert extends GraphOperation {
   constructor(...args) {
     super(...args);
     this.dependencies = this._createDependencyMap();
+    this.deferredEdges = new Set();
   }
 
   createActions() {
-    return [...this._createNormalActions(), ...this._createJoinRowActions()];
+    return [
+      ...this._createNormalActions(),
+      ...this._createDeferredRelationActions(),
+      ...this._createJoinRowActions(),
+    ];
   }
 
   _createDependencyMap() {
@@ -30,6 +36,12 @@ class GraphInsert extends GraphOperation {
   }
 
   _createRelationDependency(edge, dependencies) {
+    if (edge.relatedNode.toBeUnrelatedOrDeleted) {
+      // Models marked with `#unrelate` or `#delete` are never inserted or
+      // related, so their keys must not be copied to the owner (or vice versa).
+      return;
+    }
+
     if (edge.relation.isObjectionHasManyRelation) {
       // In case of HasManyRelation the related node depends on the owner node
       // because the related node has the foreign key.
@@ -70,6 +82,10 @@ class GraphInsert extends GraphOperation {
       });
 
       if (nodesToInsert.length === 0) {
+        if (handledNodes.size !== this.graph.nodes.length && this._breakCycle(handledNodes)) {
+          continue;
+        }
+
         break;
       }
 
@@ -77,6 +93,7 @@ class GraphInsert extends GraphOperation {
         new GraphInsertAction(this.graphData, {
           nodes: nodesToInsert,
           dependencies: this.dependencies,
+          deferredEdges: this.deferredEdges,
         }),
       );
 
@@ -92,19 +109,71 @@ class GraphInsert extends GraphOperation {
     return actions;
   }
 
-  _isHandled(node, handledNodes) {
-    return handledNodes.has(node);
+  // Tries to break a dependency cycle by deferring one `BelongsToOneRelation`
+  // edge that points to a `#ref` node. The owner node is then inserted without
+  // the foreign key, which is patched in by `DeferredRelationGraphInsertAction`
+  // once the referenced node has been inserted. Cycles can only exist through
+  // `#ref` nodes, since the graph is a tree otherwise.
+  _breakCycle(handledNodes) {
+    for (const node of this.graph.nodes) {
+      if (this._isHandled(node, handledNodes)) {
+        continue;
+      }
+
+      for (const edge of this._pendingDependencyEdges(node, handledNodes)) {
+        if (
+          this._canDeferEdge(edge, node) &&
+          this._isBlockedBy(edge.relatedNode, node, handledNodes, new Set())
+        ) {
+          this.deferredEdges.add(edge);
+          return true;
+        }
+      }
+    }
+
+    return false;
   }
 
-  _hasDependencies(node, handledNodes) {
-    if (!this.dependencies.has(node)) {
+  _canDeferEdge(edge, node) {
+    return (
+      edge.type === ModelGraphEdge.Type.Relation &&
+      edge.relation.isObjectionBelongsToOneRelation &&
+      edge.isOwnerNode(node) &&
+      edge.relatedNode.isReference &&
+      // Both ends need to be inserted for the foreign key to be patched in later.
+      this.graphOptions.shouldInsert(node, this.graphData) &&
+      this.graphOptions.shouldInsert(edge.relatedNode.referencedNode, this.graphData) &&
+      !this._isReadByPropertyReference(node, edge.relation.ownerProp)
+    );
+  }
+
+  // Returns true if a `#ref{}` property reference reads one of the `props` of
+  // `node`. Such references may be resolved before a deferred prop is set,
+  // which would resolve them to `undefined`.
+  _isReadByPropertyReference(node, props) {
+    return node.refEdges.some((edge) => {
+      return (
+        edge.refType === ModelGraphEdge.ReferenceType.Property &&
+        edge.isRelatedNode(node) &&
+        props.props.includes(edge.refRelatedDataPath[0])
+      );
+    });
+  }
+
+  // Returns true if `node` (transitively) waits for `blockingNode` to be handled.
+  _isBlockedBy(node, blockingNode, handledNodes, visitedNodes) {
+    if (node === blockingNode) {
+      return true;
+    }
+
+    if (visitedNodes.has(node)) {
       return false;
     }
 
-    for (const edge of this.dependencies.get(node)) {
-      const dependencyNode = edge.getOtherNode(node);
+    visitedNodes.add(node);
 
-      if (!handledNodes.has(dependencyNode) && !this.currentGraph.nodeForNode(dependencyNode)) {
+    for (const edge of this._pendingDependencyEdges(node, handledNodes)) {
+      if (this._isBlockedBy(edge.getOtherNode(node), blockingNode, handledNodes, visitedNodes)) {
         return true;
       }
     }
@@ -112,6 +181,42 @@ class GraphInsert extends GraphOperation {
     return false;
   }
 
+  _createDeferredRelationActions() {
+    if (this.deferredEdges.size === 0) {
+      return [];
+    }
+
+    return [
+      new DeferredRelationGraphInsertAction(this.graphData, {
+        edges: [...this.deferredEdges],
+      }),
+    ];
+  }
+
+  _isHandled(node, handledNodes) {
+    return handledNodes.has(node);
+  }
+
+  _hasDependencies(node, handledNodes) {
+    return this._pendingDependencyEdges(node, handledNodes).length > 0;
+  }
+
+  // Returns the dependency edges of `node` whose other node still needs to be
+  // inserted first. Deferred edges are ignored.
+  _pendingDependencyEdges(node, handledNodes) {
+    const edges = this.dependencies.get(node) || [];
+
+    return edges.filter((edge) => {
+      const dependencyNode = edge.getOtherNode(node);
+
+      return (
+        !this.deferredEdges.has(edge) &&
+        !handledNodes.has(dependencyNode) &&
+        !this.currentGraph.nodeForNode(dependencyNode)
+      );
+    });
+  }
+
   _markHandled(node, handledNodes) {
     handledNodes.add(node);
 

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

@@ -14,12 +14,15 @@ const promiseUtils = require('../../../utils/promiseUtils');
  * when needed.
  */
 class GraphInsertAction extends GraphAction {
-  constructor(graphData, { nodes, dependencies }) {
+  constructor(graphData, { nodes, dependencies, deferredEdges }) {
     super(graphData);
 
     // Nodes to insert.
     this.nodes = nodes;
     this.dependencies = dependencies;
+    // Dependency edges that are resolved once the dependency node has been
+    // inserted, and are patched in by `DeferredRelationGraphInsertAction`.
+    this.deferredEdges = deferredEdges;
   }
 
   run(builder) {
@@ -63,6 +66,10 @@ class GraphInsertAction extends GraphAction {
 
       if (edges) {
         for (const edge of edges) {
+          if (this.deferredEdges.has(edge)) {
+            continue;
+          }
+
           // `node` needs `dependencyNode` to have been inserted (and it has been).
           const dependencyNode = edge.getOtherNode(node);
 
@@ -174,6 +181,8 @@ class GraphInsertAction extends GraphAction {
 
     for (const node of nodes) {
       delete node.obj[modelClass.uidProp];
+      delete node.obj[modelClass.graphUnrelateProp];
+      delete node.obj[modelClass.graphDeleteProp];
       node.obj.$validate(null, { dataPath: node.dataPathKey });
     }
 

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

@@ -75,6 +75,8 @@ class GraphPatchAction extends GraphAction {
     delete node.obj[node.modelClass.uidProp];
     delete node.obj[node.modelClass.uidRefProp];
     delete node.obj[node.modelClass.dbRefProp];
+    delete node.obj[node.modelClass.graphUnrelateProp];
+    delete node.obj[node.modelClass.graphDeleteProp];
 
     node.obj.$validate(null, {
       dataPath: node.dataPathKey,
@@ -122,7 +124,9 @@ class GraphPatchAction extends GraphAction {
         edge.isOwnerNode(node) &&
         edge.relation &&
         edge.relation.isObjectionBelongsToOneRelation &&
-        edge.relation.relatedProp.hasProps(edge.relatedNode.obj)
+        edge.relation.relatedProp.hasProps(edge.relatedNode.obj) &&
+        // Models marked with `#unrelate` or `#delete` are handled below.
+        !edge.relatedNode.toBeUnrelatedOrDeleted
       ) {
         const { relation } = edge;
 
@@ -153,7 +157,8 @@ class GraphPatchAction extends GraphAction {
       if (
         edge.isOwnerNode(currentNode) &&
         edge.relation.isObjectionBelongsToOneRelation &&
-        node.obj[edge.relation.name] === null &&
+        (node.obj[edge.relation.name] === null ||
+          isToBeUnrelatedOrDeleted(this.graph.nodeForNode(edge.relatedNode))) &&
         this.graphOptions.shouldDeleteOrUnrelate(edge.relatedNode, this.graphData)
       ) {
         const { relation } = edge;
@@ -231,7 +236,10 @@ class GraphPatchAction extends GraphAction {
   }
 
   _createRootBuilder(node) {
-    return node.obj.$query();
+    const currentNode = this.currentGraph.nodeForNode(node);
+    const currentObj = currentNode && currentNode.obj;
+
+    return currentObj ? currentObj.$query() : node.obj.$query();
   }
 }
 
@@ -250,6 +258,10 @@ function nonStrictEquals(val1, val2) {
   return jsonEquals(val1, val2);
 }
 
+function isToBeUnrelatedOrDeleted(node) {
+  return !!node && node.toBeUnrelatedOrDeleted;
+}
+
 module.exports = {
   GraphPatchAction,
 };

package/lib/queryBuilder/join/JoinResultParser.js

@@ -22,6 +22,8 @@ class JoinResultParser {
       return flatRows;
     }
 
+    this._checkIdColumns(flatRows[0]);
+
     this.columnsByTableNode = this._createColumns(flatRows[0]);
     this.parentMap = new Map();
     this.rootModels = [];
@@ -93,6 +95,26 @@ class JoinResultParser {
     }
   }
 
+  _checkIdColumns(row) {
+    for (const tableNode of this.tableTree.nodes) {
+      const idColumns = tableNode.modelClass.getIdColumnArray();
+      const hasIdColumns =
+        idColumns.length > 0 &&
+        idColumns.every((column) =>
+          Object.prototype.hasOwnProperty.call(row, tableNode.getColumnAliasForColumn(column)),
+        );
+
+      if (!hasIdColumns) {
+        throw new Error(
+          `withGraphJoined: the id column(s) [${idColumns.join(', ')}] of model ${tableNode.modelClass.name} ` +
+            `are missing from the result, so the joined rows can't be grouped into models. ` +
+            `withGraphJoined requires all models in the relation expression to have a primary key ` +
+            `(idColumn) that exists in the table. Use withGraphFetched for models without one.`,
+        );
+      }
+    }
+  }
+
   _createColumns(row) {
     const columns = Object.keys(row).map((columnAlias) =>
       JoinResultColumn.create({ tableTree: this.tableTree, columnAlias }),