objection 3.8.0 → 3.9.1

package/lib/queryBuilder/graph/GraphOptions.js

@@ -161,8 +161,11 @@ class GraphOptions {
 
     return (
       !node &&
+      !hasIgnoredOtherModel(currentNode, graphData) &&
       !this._hasOption(currentNode, NO_UNRELATE) &&
-      this.shouldUnrelateIgnoreDisable(currentNode)
+      (this.shouldUnrelateIgnoreDisable(currentNode) ||
+        // The unrelate replaces a delete, so `noDelete` disables it too.
+        (!this._hasOption(currentNode, NO_DELETE) && shouldUnrelateKeptRow(currentNode, graphData)))
     );
   }
 
@@ -173,8 +176,11 @@ class GraphOptions {
 
     return (
       !node &&
+      !hasIgnoredOtherModel(currentNode, graphData) &&
       !this._hasOption(currentNode, NO_DELETE) &&
-      !this.shouldUnrelateIgnoreDisable(currentNode)
+      !this.shouldUnrelateIgnoreDisable(currentNode) &&
+      // Rows that the graph keeps in another place must not be deleted (#214).
+      !graphData.keptNodeForRow(currentNode)
     );
   }
 
@@ -182,6 +188,18 @@ class GraphOptions {
     return this.shouldInsert(node, graphData) || this.shouldRelate(node, graphData);
   }
 
+  // The graph ignores models that it neither inserts, relates nor patches, like
+  // models marked with `#unrelate` or `#delete` and models skipped by `noInsert`
+  // or `noRelate`. Inserted models have ids and can look like models to relate
+  // afterwards, so we check that they were inserted too.
+  shouldIgnore(node, graphData) {
+    return (
+      !node.userData.inserted &&
+      !this.shouldInsertOrRelate(node, graphData) &&
+      !this.shouldPatchOrUpdateIgnoreDisable(node, graphData)
+    );
+  }
+
   shouldDeleteOrUnrelate(currentNode, graphData) {
     return this.shouldDelete(currentNode, graphData) || this.shouldUnrelate(currentNode, graphData);
   }
@@ -264,27 +282,30 @@ function parseRelationExpression(optionName, expression) {
   }
 
   // Relation paths are matched by relation name, so aliases would never match.
-  const alias = findAlias(parsedExpression.node);
+  const alias = findNode(parsedExpression.node, (node) => node.$name !== node.$relation);
 
   if (alias) {
     throw createError(`aliases like "${alias.$relation} as ${alias.$name}" are not supported`);
   }
 
+  // `*` and `^` only have a meaning at the end of a relation path. Anywhere else
+  // they are parsed as relation names that would never match.
+  const token = findNode(parsedExpression.node, (node) => /^(\*|\^\d*)$/.test(node.$relation));
+
+  if (token) {
+    throw createError(`"${token.$relation}" is only supported at the end of a relation path`);
+  }
+
   return parsedExpression;
 }
 
-function findAlias(node) {
+function findNode(node, predicate) {
   for (const childName of node.$childNames) {
     const child = node[childName];
+    const found = predicate(child) ? child : findNode(child, predicate);
 
-    if (child.$name !== child.$relation) {
-      return child;
-    }
-
-    const alias = findAlias(child);
-
-    if (alias) {
-      return alias;
+    if (found) {
+      return found;
     }
   }
 
@@ -344,6 +365,39 @@ function hasRelateProp(node) {
   }
 }
 
+// An ignored model that isn't the current model of a BelongsToOneRelation
+// doesn't replace it, so we keep the current one instead of removing it as
+// missing.
+function hasIgnoredOtherModel(currentNode, graphData) {
+  const { relation } = currentNode.parentEdge;
+  const parentNode = getNode(currentNode.parentNode, graphData.graph);
+
+  return (
+    relation.isObjectionBelongsToOneRelation &&
+    !!parentNode &&
+    parentNode.edges.some(
+      (edge) =>
+        edge.relation === relation &&
+        edge.isOwnerNode(parentNode) &&
+        graphData.graphOptions.shouldIgnore(edge.relatedNode, graphData),
+    )
+  );
+}
+
+// A row that the graph keeps in another place is unrelated here instead of
+// being deleted, unless it's a has-many row that the graph relates through the
+// same relation: That relate moves it by overwriting the foreign key, which
+// may not be nullable.
+function shouldUnrelateKeptRow(currentNode, graphData) {
+  const keptNode = graphData.keptNodeForRow(currentNode);
+  const { relation } = currentNode.parentEdge;
+
+  return (
+    !!keptNode &&
+    !(relation.isObjectionHasManyRelation && keptNode.parentEdge?.relation === relation)
+  );
+}
+
 function getNode(currentNode, graph) {
   if (!graph || !currentNode) {
     return null;

package/lib/queryBuilder/graph/GraphUpsert.js

@@ -6,7 +6,7 @@ const { createNotModelError } = require('../../model/graph/ModelGraphBuilder');
 const { GraphFetcher } = require('../graph/GraphFetcher');
 const { GraphInsert } = require('./insert/GraphInsert');
 const { GraphPatch } = require('./patch/GraphPatch');
-const { GraphDelete } = require('./delete/GraphDelete');
+const { GraphDelete, GraphDereferencedBelongsToOneDelete } = require('./delete/GraphDelete');
 const { GraphRecursiveUpsert } = require('./recursiveUpsert/GraphRecursiveUpsert');
 const { GraphOptions, OPTION_NAMES } = require('./GraphOptions');
 const { ValidationErrorType } = require('../../model/ValidationError');
@@ -37,7 +37,7 @@ class GraphUpsert {
   // 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.
+  // TODO: Throw an error instead in objection 4.0 (#53).
   static warnOnConflict(builder, method) {
     if (builder.has(isOnConflictOperation)) {
       warnOnce(
@@ -60,13 +60,14 @@ class GraphUpsert {
       .then(pruneGraphs())
       .then(checkForJoinTableRelatedTableErrors(builder))
       .then(executeOperations(builder))
+      .then(removeReferenceProps(graph.nodes))
       .then(returnResult(this.objects, this.isArray));
   }
 }
 
 // Misspelled options are silently ignored, so the operation runs with the
 // default behaviour instead (#84). A warning is logged once per option.
-// TODO: Throw an error instead in objection 4.0.
+// TODO: Throw an error instead in objection 4.0 (#53).
 function warnOnUnknownOptions(upsertOptions) {
   // Recursive upserts pass on the already checked options of their parent.
   if (upsertOptions instanceof GraphOptions) {
@@ -128,6 +129,7 @@ function fetchCurrentGraph(builder, graphOptions, graph) {
 function pruneGraphs() {
   return (graphData) => {
     pruneRelatedBranches(graphData);
+    pruneSkippedBranches(graphData);
 
     if (!graphData.graphOptions.isInsertOnly()) {
       pruneDeletedBranches(graphData);
@@ -149,6 +151,31 @@ function pruneRelatedBranches(graphData) {
   removeBranchesFromGraph(findRoots(relateNodes), graphData.graph);
 }
 
+// Nothing is written below nodes that `noInsert` skips, as their descendants
+// would be orphans (#215). Branches that references from outside point into
+// are kept, since the references need their models.
+function pruneSkippedBranches(graphData) {
+  const { graph, graphOptions } = graphData;
+
+  const skippedNodes = graph.nodes.filter((node) => {
+    return (
+      graphOptions.shouldInsertIgnoreDisable(node, graphData) &&
+      !graphOptions.shouldInsert(node, graphData) &&
+      !isReferencedFromOutside(node.descendantRelationNodes)
+    );
+  });
+
+  removeBranchesFromGraph(findRoots(skippedNodes), graph);
+}
+
+function isReferencedFromOutside(nodes) {
+  const nodeSet = new Set(nodes);
+
+  return nodes.some((node) =>
+    node.refEdges.some((edge) => edge.isRelatedNode(node) && !nodeSet.has(edge.ownerNode)),
+  );
+}
+
 function pruneDeletedBranches(graphData) {
   const { graph, currentGraph } = graphData;
 
@@ -253,6 +280,7 @@ function checkForErrors(builder) {
 
     if (graphData.graphOptions.isInsertOnly()) {
       checkForHasManyRelateErrors(graphData);
+      warnOnInsertBelowRelate(graphData);
     }
 
     return graphData;
@@ -290,10 +318,18 @@ function checkForJoinTableRelatedTableErrors(builder) {
 
 function checkForNotFoundErrors(graphData, builder) {
   const { graphOptions, currentGraph, graph } = graphData;
+  // The branches below related nodes are upserted and checked by nested
+  // `upsertGraph` calls, against the current graphs of the related nodes:
+  const nestedNodes = new Set(
+    graph.nodes
+      .filter((node) => graphOptions.shouldRelate(node, graphData))
+      .flatMap((node) => node.descendantRelationNodes),
+  );
 
   for (const node of graph.nodes) {
     if (
       node.obj.$hasId() &&
+      !nestedNodes.has(node) &&
       !node.toBeUnrelatedOrDeleted &&
       !graphOptions.shouldInsertIgnoreDisable(node, graphData) &&
       !graphOptions.shouldRelateIgnoreDisable(node, graphData) &&
@@ -400,18 +436,52 @@ function checkForHasManyRelateErrors(graphData) {
   }
 }
 
+// `upsertGraph` upserts the branches below related models recursively, but
+// `insertGraph` prunes them, which drops the models that would be inserted
+// there (#217). A warning is logged once.
+// TODO: Throw an error instead in objection 4.0 (#53).
+function warnOnInsertBelowRelate(graphData) {
+  const { graph, graphOptions } = graphData;
+
+  const hasInsertBelowRelate = graph.nodes.some(
+    (node) =>
+      graphOptions.shouldRelate(node, graphData) &&
+      node.descendantRelationNodes.some((descendantNode) =>
+        graphOptions.shouldInsert(descendantNode, graphData),
+      ),
+  );
+
+  if (hasInsertBelowRelate) {
+    warnOnce(
+      'insertGraph() ignores new models below related models. ' +
+        'Insert them with a separate query or use upsertGraph() instead. ' +
+        'This will throw in objection 4.0.',
+    );
+  }
+}
+
 function executeOperations(builder) {
   return (graphData) => {
     const operations = graphData.graphOptions.isInsertOnly()
       ? [GraphInsert]
-      : [GraphDelete, GraphInsert, GraphPatch, GraphRecursiveUpsert];
-
-    return operations.reduce((promise, Operation) => {
-      const operation = new Operation(graphData);
-      const actions = operation.createActions();
+      : [
+          GraphDelete,
+          GraphInsert,
+          GraphPatch,
+          GraphDereferencedBelongsToOneDelete,
+          GraphRecursiveUpsert,
+        ];
+
+    // Create all actions before chaining the first ones, which would run even
+    // if creating the actions of a later operation throws, e.g. for a cycle.
+    const operationActions = operations.map((Operation) =>
+      new Operation(graphData).createActions(),
+    );
 
-      return promise.then(() => executeActions(builder, actions));
-    }, Promise.resolve());
+    return operationActions.reduce(
+      (promise, actions) => promise.then(() => executeActions(builder, actions)),
+      Promise.resolve(),
+    );
   };
 }
 
@@ -422,6 +492,18 @@ function executeActions(builder, actions) {
   );
 }
 
+// The reference markers only describe the input graph, don't return them.
+// `nodes` are the nodes before pruning, since the results of pruned branches
+// contain markers too.
+function removeReferenceProps(nodes) {
+  return () => {
+    for (const node of nodes) {
+      delete node.obj[node.modelClass.uidRefProp];
+      delete node.obj[node.modelClass.dbRefProp];
+    }
+  };
+}
+
 function isOnConflictOperation(op) {
   return op.name === 'onConflict' || op.name === 'ignore' || op.name === 'merge';
 }

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

@@ -2,19 +2,72 @@
 
 const { GraphOperation } = require('../GraphOperation');
 const { GraphDeleteAction } = require('./GraphDeleteAction');
+const { getPropertyTypes } = require('../../../model/modelJsonAttributes');
 
 class GraphDelete extends GraphOperation {
+  // The owner of a BelongsToOneRelation row references it until `GraphPatch`
+  // points the owner to a new row or to null. These rows are deleted
+  // afterwards by `GraphDereferencedBelongsToOneDelete`, all others before.
+  get deletesDereferencedRows() {
+    return false;
+  }
+
   createActions() {
     return [
       new GraphDeleteAction(this.graphData, {
-        nodes: this.currentGraph.nodes.filter((currentNode) =>
-          this.graphOptions.shouldDeleteOrUnrelate(currentNode, this.graphData),
+        nodes: this.currentGraph.nodes.filter(
+          (currentNode) =>
+            this.graphOptions.shouldDeleteOrUnrelate(currentNode, this.graphData) &&
+            isDereferencedBelongsToOneNode(currentNode, this.graphData) ===
+              this.deletesDereferencedRows,
         ),
+        areReferenced: !this.deletesDereferencedRows,
       }),
     ];
   }
 }
 
+class GraphDereferencedBelongsToOneDelete extends GraphDelete {
+  get deletesDereferencedRows() {
+    return true;
+  }
+}
+
+function isDereferencedBelongsToOneNode(currentNode, graphData) {
+  const { graph, graphOptions } = graphData;
+  const relation = currentNode.parentEdge?.relation;
+  const parentNode = graph.nodeForNode(currentNode.parentNode);
+
+  if (relation?.isObjectionBelongsToOneRelation && parentNode) {
+    const node = graph.nodeForNode(currentNode);
+    const isReplaced = parentNode.edges.some(
+      (edge) =>
+        edge.relation === relation &&
+        edge.isOwnerNode(parentNode) &&
+        !graphOptions.shouldIgnore(edge.relatedNode, graphData),
+    );
+    const isRemoved =
+      parentNode.obj[relation.name] === null || (!!node && node.toBeUnrelatedOrDeleted);
+
+    // Removing the row sets the owner's foreign key to null, but only where
+    // its schema allows it. Otherwise we delete the row first and leave the
+    // owner's reference to the database, as the column may be `NOT NULL`.
+    return (
+      isReplaced ||
+      (isRemoved &&
+        relation.ownerProp.props.every((prop) => isNullable(relation.ownerModelClass, prop)))
+    );
+  } else {
+    return false;
+  }
+}
+
+function isNullable(modelClass, prop) {
+  const schema = modelClass.getJsonSchema()?.properties?.[prop];
+  return !!schema && (schema.nullable === true || getPropertyTypes(schema).includes('null'));
+}
+
 module.exports = {
   GraphDelete,
+  GraphDereferencedBelongsToOneDelete,
 };

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

@@ -5,10 +5,14 @@ const { groupBy } = require('../../../utils/objectUtils');
 const promiseUtils = require('../../../utils/promiseUtils');
 
 class GraphDeleteAction extends GraphAction {
-  constructor(graphData, { nodes }) {
+  constructor(graphData, { nodes, areReferenced = true }) {
     super(graphData);
     // Nodes to delete.
     this.nodes = nodes;
+    // Whether the parents still reference the nodes. Rows of
+    // BelongsToOneRelations can be deleted after their owners were patched to
+    // reference new rows or null, so they can't be found through the relation.
+    this.areReferenced = areReferenced;
   }
 
   run(builder) {
@@ -47,10 +51,14 @@ class GraphDeleteAction extends GraphAction {
         );
 
         nodesByShouldUnrelate.forEach((nodes, shouldUnrelate) => {
-          const builder = parentNode.obj.$relatedQuery(relation.name).childQueryOf(parentBuilder);
-
-          if (!relation.isObjectionBelongsToOneRelation) {
-            // This is useless in case of BelongsToOneRelation.
+          const builder = (
+            this.areReferenced
+              ? parentNode.obj.$relatedQuery(relation.name)
+              : relation.relatedModelClass.query()
+          ).childQueryOf(parentBuilder);
+
+          if (!this.areReferenced || !relation.isObjectionBelongsToOneRelation) {
+            // This is useless in case of a referenced BelongsToOneRelation.
             builder.findByIds(nodes.map((node) => node.obj.$id()));
           }
 

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

@@ -7,9 +7,8 @@ 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.
+ * inserted without the foreign keys, which are copied from the related nodes
+ * and patched in with one query per owner.
  */
 class DeferredRelationGraphInsertAction extends GraphAction {
   constructor(graphData, { edges }) {
@@ -36,11 +35,13 @@ class DeferredRelationGraphInsertAction extends GraphAction {
     const ownerIdProp = modelClass.getIdRelationProperty();
     const patch = {};
 
-    for (const { relation } of edges) {
-      const { ownerProp } = relation;
+    for (const { relation, relatedNode } of edges) {
+      const { ownerProp, relatedProp } = relation;
 
       ownerProp.forEach((i) => {
-        ownerProp.patch(patch, i, ownerProp.getProp(ownerNode.obj, i));
+        const value = relatedProp.getProp(relatedNode.obj, i);
+        ownerProp.setProp(ownerNode.obj, i, value);
+        ownerProp.patch(patch, i, value);
       });
     }
 

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

@@ -46,7 +46,12 @@ class GraphInsert extends GraphOperation {
       // In case of HasManyRelation the related node depends on the owner node
       // because the related node has the foreign key.
       this._addDependency(edge.relatedNode, edge, dependencies);
-    } else if (edge.relation.isObjectionBelongsToOneRelation) {
+    } else if (
+      edge.relation.isObjectionBelongsToOneRelation &&
+      // Ignored models don't replace the current one, so their keys must not
+      // be copied to the owner either.
+      !this.graphOptions.shouldIgnore(edge.relatedNode, this.graphData)
+    ) {
       // In case of BelongsToOneRelation the owner node depends on the related
       // node because the owner node has the foreign key.
       this._addDependency(edge.ownerNode, edge, dependencies);
@@ -78,10 +83,23 @@ class GraphInsert extends GraphOperation {
       // new ones. We need to pass all nodes to `GraphInsertActions` so that we
       // can resolve all dependencies.
       const nodesToInsert = this.graph.nodes.filter((node) => {
-        return !this._isHandled(node, handledNodes) && !this._hasDependencies(node, handledNodes);
+        return (
+          !node.isReference && !handledNodes.has(node) && !this._hasDependencies(node, handledNodes)
+        );
+      });
+
+      // `#ref` nodes aren't inserted, so they can be resolved in the same
+      // action as the nodes they depend on, once these are inserted.
+      const insertedNodes = new Set([...handledNodes, ...nodesToInsert]);
+      const refNodes = this.graph.nodes.filter((node) => {
+        return (
+          node.isReference && !handledNodes.has(node) && !this._hasDependencies(node, insertedNodes)
+        );
       });
 
-      if (nodesToInsert.length === 0) {
+      const nodes = [...nodesToInsert, ...refNodes];
+
+      if (nodes.length === 0) {
         if (handledNodes.size !== this.graph.nodes.length && this._breakCycle(handledNodes)) {
           continue;
         }
@@ -92,13 +110,14 @@ class GraphInsert extends GraphOperation {
       actions.push(
         new GraphInsertAction(this.graphData, {
           nodes: nodesToInsert,
+          refNodes,
           dependencies: this.dependencies,
           deferredEdges: this.deferredEdges,
         }),
       );
 
-      for (const node of nodesToInsert) {
-        this._markHandled(node, handledNodes);
+      for (const node of nodes) {
+        handledNodes.add(node);
       }
     }
 
@@ -116,7 +135,7 @@ class GraphInsert extends GraphOperation {
   // `#ref` nodes, since the graph is a tree otherwise.
   _breakCycle(handledNodes) {
     for (const node of this.graph.nodes) {
-      if (this._isHandled(node, handledNodes)) {
+      if (handledNodes.has(node)) {
         continue;
       }
 
@@ -195,16 +214,12 @@ class GraphInsert extends GraphOperation {
     ];
   }
 
-  _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.
+  // handled first. Deferred edges are ignored.
   _pendingDependencyEdges(node, handledNodes) {
     const edges = this.dependencies.get(node) || [];
 
@@ -214,22 +229,51 @@ class GraphInsert extends GraphOperation {
       return (
         !this.deferredEdges.has(edge) &&
         !handledNodes.has(dependencyNode) &&
-        !this.currentGraph.nodeForNode(dependencyNode)
+        (!this.currentGraph.nodeForNode(dependencyNode) ||
+          this._readsFilledProps(edge, dependencyNode))
       );
     });
   }
 
-  _markHandled(node, handledNodes) {
-    handledNodes.add(node);
-
-    // The referencing nodes are all references that don't
-    // represent any real entity. They are simply intermediate nodes
-    // that depend on this node. Once this node is handled, we can
-    // also mark those nodes as handled as there is nothing to actually
-    // insert.
-    for (const refNode of node.referencingNodes) {
-      this._markHandled(refNode, handledNodes);
+  // Returns true if the reference `edge` reads props that the graph fills into
+  // `node`. The keys of existing models are known right away, but these props
+  // only once they're filled in (#356).
+  _readsFilledProps(edge, node) {
+    if (edge.type === ModelGraphEdge.Type.Relation) {
+      return false;
     }
+
+    const filledProps = this._getFilledProps(node);
+    // A `#ref` node stands in for `node` in its relations, which read only
+    // their keys from it:
+    const readProps =
+      edge.refType === ModelGraphEdge.ReferenceType.Property
+        ? [edge.refRelatedDataPath[0]]
+        : this._getRelationProps(edge.ownerNode.edges, edge.ownerNode);
+
+    return readProps.some((prop) => filledProps.includes(prop));
+  }
+
+  // Returns the props of `node` that the graph fills in from other models,
+  // through its relations and its property references.
+  _getFilledProps(node) {
+    const edges = this.dependencies.get(node) || [];
+
+    return [
+      ...this._getRelationProps(edges, node),
+      ...edges
+        .filter((edge) => edge.refType === ModelGraphEdge.ReferenceType.Property)
+        .map((edge) => edge.refOwnerDataPath[0]),
+    ];
+  }
+
+  // Returns the props of `node` that the relation edges among `edges` join on.
+  _getRelationProps(edges, node) {
+    return edges
+      .filter((edge) => edge.type === ModelGraphEdge.Type.Relation)
+      .flatMap((edge) => {
+        return (edge.isOwnerNode(node) ? edge.relation.ownerProp : edge.relation.relatedProp).props;
+      });
   }
 
   _createJoinRowActions() {

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

@@ -14,22 +14,24 @@ const promiseUtils = require('../../../utils/promiseUtils');
  * when needed.
  */
 class GraphInsertAction extends GraphAction {
-  constructor(graphData, { nodes, dependencies, deferredEdges }) {
+  constructor(graphData, { nodes, refNodes, dependencies, deferredEdges }) {
     super(graphData);
 
-    // Nodes to insert.
+    // Nodes to insert, and `#ref` nodes to resolve once they are inserted.
     this.nodes = nodes;
+    this.refNodes = refNodes;
     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) {
+  async run(builder) {
     const batches = this._createInsertBatches(builder);
     const concurrency = this._getConcurrency(builder, this.nodes);
 
-    return promiseUtils.map(batches, (batch) => this._insertBatch(builder, batch), { concurrency });
+    await promiseUtils.map(batches, (batch) => this._insertBatch(builder, batch), { concurrency });
+    this._resolveDependencies(this.refNodes);
   }
 
   _createInsertBatches(builder) {
@@ -49,7 +51,6 @@ class GraphInsertAction extends GraphAction {
   async _insertBatch(parentBuilder, nodes) {
     await this._beforeInsert(nodes);
     await this._insert(parentBuilder, nodes);
-    await this._afterInsert(nodes);
   }
 
   _beforeInsert(nodes) {
@@ -82,6 +83,8 @@ class GraphInsertAction extends GraphAction {
   _resolveDependency(dependencyNode, edge) {
     if (edge.type === ModelGraphEdge.Type.Relation && !edge.relation.joinTable) {
       this._resolveRelationDependency(dependencyNode, edge);
+    } else if (edge.refType === ModelGraphEdge.ReferenceType.Object) {
+      this._resolveReferences(edge.getOtherNode(dependencyNode));
     } else if (edge.refType === ModelGraphEdge.ReferenceType.Property) {
       this._resolvePropertyReferenceNode(dependencyNode, edge);
     }
@@ -219,14 +222,6 @@ class GraphInsertAction extends GraphAction {
       }),
     );
   }
-
-  _afterInsert(nodes) {
-    for (const node of nodes) {
-      for (const refNode of node.referencingNodes) {
-        this._resolveDependency(refNode, refNode.parentEdge);
-      }
-    }
-  }
 }
 
 function getModelClass(node) {