objection 3.7.0 → 3.9.0

package/lib/queryBuilder/QueryBuilder.js

@@ -8,9 +8,10 @@ const { ValidationErrorType } = require('../model/ValidationError');
 const { isObject, isString, isFunction, last, flatten } = require('../utils/objectUtils');
 const { RelationExpression, DuplicateRelationError } = require('./RelationExpression');
 const { assertIdNotUndefined, assertHasIdColumn } = require('../utils/assert');
-const { deprecate } = require('../utils/deprecate');
+const { warnOnce } = require('../utils/warnings');
+const { isMsSql } = require('../utils/knexUtils');
 
-const { Selection } = require('./operations/select/Selection');
+const { Selection, isSameIdentifier } = require('./operations/select/Selection');
 
 const { QueryBuilderContext } = require('./QueryBuilderContext');
 const { QueryBuilderBase } = require('./QueryBuilderBase');
@@ -45,9 +46,11 @@ const { EagerOperation } = require('./operations/eager/EagerOperation');
 const { RangeOperation } = require('./operations/RangeOperation');
 const { FirstOperation } = require('./operations/FirstOperation');
 const { NoneOperation } = require('./operations/NoneOperation');
+const { LimitPerParentOperation } = require('./operations/LimitPerParentOperation');
 const { FromOperation } = require('./operations/FromOperation');
 const { KnexOperation } = require('./operations/KnexOperation');
-const { wrapWhereGroups } = require('./whereGroups');
+const { clearUnsupportedOrder } = require('./withoutOrder');
+const { addWhereGroup } = require('./whereGroups');
 
 class QueryBuilder extends QueryBuilderBase {
   static init(self, modelClass) {
@@ -56,6 +59,7 @@ class QueryBuilder extends QueryBuilderBase {
     self._resultModelClass = null;
     self._explicitRejectValue = null;
     self._explicitResolveValue = null;
+    self._queryBatch = null;
     self._modifiers = {};
 
     self._allowedGraphExpression = null;
@@ -257,21 +261,29 @@ class QueryBuilder extends QueryBuilderBase {
     // The `joinOperation` option only applies to the relations of this call,
     // see `RelationJoiner`. All other options are shared by all calls.
     const { joinOperation, ...graphOptions } = options;
+    const isJoined = eagerOp instanceof JoinEagerOperation;
 
     eagerOp.expression = eagerOp.expression.merge(parsedExp);
     eagerOp.graphOptions = { ...eagerOp.graphOptions, ...graphOptions };
 
     if (joinOperation) {
-      if (eagerOp instanceof JoinEagerOperation) {
+      if (isJoined) {
         eagerOp.joinOperations.push({ expression: parsedExp, joinOperation });
       } else {
-        deprecate(
+        warnOnce(
           'The joinOperation option only applies to withGraphJoined() and is ignored for the ' +
             `fetched relations "${parsedExp.toString()}".`,
         );
       }
     }
 
+    if (graphOptions.limitPerParent && isJoined) {
+      warnOnce(
+        'The limitPerParent option only applies to withGraphFetched() and is ignored for the ' +
+          `joined relations "${parsedExp.toString()}".`,
+      );
+    }
+
     checkMixedEager(this);
     checkEager(this);
     return this;
@@ -387,7 +399,7 @@ class QueryBuilder extends QueryBuilderBase {
     return this.everyOperation((op) => {
       if (op.constructor === SelectOperation) {
         // SelectOperations with zero selections are the ones that only have
-        // raw items or other non-trivial selections.
+        // raw items or other non-trivial selections, or `distinctOn()`.
         return (
           op.selections.length > 0 &&
           op.selections.every((select) => {
@@ -501,39 +513,50 @@ class QueryBuilder extends QueryBuilderBase {
 
   async resultSize() {
     const knex = this.knex();
-    const builder = this.clone().clear(/orderBy|offset|limit/);
+    // `distinctOn` picks the first row of each group in the order of the query,
+    // which decides which root models are counted with to-many joins.
+    const shouldKeepOrder = this.has('distinctOn');
+    const builder = this.clone().clear(shouldKeepOrder ? /offset|limit/ : /orderBy|offset|limit/);
     const joinEagerOp = builder.findOperation(JoinEagerOperation);
 
     if (joinEagerOp) {
       // `withGraphJoined` needs the table metadata to build its selects.
-      await joinEagerOp.onBefore3(builder);
+      await joinEagerOp.fetchTableMetadata(builder);
+
+      // To-many joins return one row per joined child, so the root models are
+      // counted by their distinct ids, see below.
+      if (joinEagerOp.joiner.hasToManyJoins(builder)) {
+        assertHasIdColumn(builder.modelClass());
+      }
     }
 
+    const idColumns = builder.modelClass().getIdColumnArray();
+
     // Also clear the order on the built knex query, since `orderBy` calls
     // can be added at build time, e.g. by a relation's `modify`.
-    const buildQuery = (knexBuilder) => builder.toKnexQuery(knexBuilder).clearOrder();
+    const buildQuery = (knexBuilder) => {
+      const query = builder.toKnexQuery(knexBuilder);
+      return shouldKeepOrder ? query : query.clearOrder();
+    };
 
     const countQuery = knex.count('* as count').from((knexBuilder) => {
-      if (!joinEagerOp) {
+      if (!joinEagerOp || idColumns.length === 0) {
+        // Without ids, the joins are all to-one and return one row per root
+        // model.
         buildQuery(knexBuilder);
+      } else if (refersToSelections(builder) || builder.has('distinctOn')) {
+        // `having`, and `groupBy` with an alias, may refer to aliased
+        // selections, and clearing the selections would also clear
+        // `distinctOn`, so keep them and select the distinct ids from the
+        // result instead.
+        knexBuilder.distinct(idColumns).from((knexBuilder) => {
+          buildQuery(knexBuilder).as('inner');
+        });
       } else {
-        // The joins of `withGraphJoined` return one row per joined child.
-        // Count the distinct root models instead.
-        const idColumns = builder.modelClass().getIdColumnArray();
-
-        if (refersToSelections(builder)) {
-          // `having`, and `groupBy` with an alias, may refer to aliased
-          // selections, so keep them and select the distinct ids from the
-          // result instead.
-          knexBuilder.distinct(idColumns).from((knexBuilder) => {
-            buildQuery(knexBuilder).as('inner');
-          });
-        } else {
-          const tableRef = builder.tableRef();
-          buildQuery(knexBuilder)
-            .clearSelect()
-            .distinct(idColumns.map((col) => `${tableRef}.${col}`));
-        }
+        const tableRef = builder.tableRef();
+        buildQuery(knexBuilder)
+          .clearSelect()
+          .distinct(idColumns.map((col) => `${tableRef}.${col}`));
       }
 
       knexBuilder.as('temp');
@@ -585,7 +608,7 @@ class QueryBuilder extends QueryBuilderBase {
     let selectionInstance = null;
 
     this.forEachOperation(true, (op) => {
-      if (op.constructor === SelectOperation) {
+      if (op.constructor === SelectOperation && !op.isDistinctOn) {
         selectionInstance = op.findSelection(this, selection);
         noSelectStatements = false;
 
@@ -637,9 +660,9 @@ class QueryBuilder extends QueryBuilderBase {
     } else {
       if (foundSelection.column === '*') {
         // * selects the columns with their column names as aliases.
-        return selection.column === alias;
+        return isSameIdentifier(this, selection.column, alias);
       } else {
-        return foundSelection.name === alias;
+        return isSameIdentifier(this, foundSelection.name, alias);
       }
     }
   }
@@ -1000,7 +1023,9 @@ class QueryBuilder extends QueryBuilderBase {
   }
 
   updateById(id, modelOrObject) {
-    return this.findById(id)
+    // Keep the id condition in its own where group, so that a user's `orWhere()`
+    // can't get around it. See `whereGroups.js`.
+    return addWhereGroup(this, () => this.findById(id))
       .update(modelOrObject)
       .runBefore((_, builder) => {
         if (!builder.internalOptions().skipUndefined) {
@@ -1010,7 +1035,7 @@ class QueryBuilder extends QueryBuilderBase {
   }
 
   patchById(id, modelOrObject) {
-    return this.findById(id)
+    return addWhereGroup(this, () => this.findById(id))
       .patch(modelOrObject)
       .runBefore((_, builder) => {
         if (!builder.internalOptions().skipUndefined) {
@@ -1020,7 +1045,7 @@ class QueryBuilder extends QueryBuilderBase {
   }
 
   deleteById(id) {
-    return this.findById(id)
+    return addWhereGroup(this, () => this.findById(id))
       .delete()
       .runBefore((_, builder) => {
         if (!builder.internalOptions().skipUndefined) {
@@ -1325,14 +1350,14 @@ function checkMixedEager(builder) {
 
   if (joinNode.$allRecursive || fetchNode.$allRecursive) {
     throw new Error(
-      'relation expression `*` cannot be used when mixing withGraphJoined and withGraphFetched',
+      'relation expression "*" cannot be used when mixing withGraphJoined and withGraphFetched',
     );
   }
 
   for (const childName of joinNode.$childNames) {
     if (fetchNode.$childNames.includes(childName)) {
       throw new Error(
-        `relation \`${childName}\` cannot be loaded with both withGraphJoined and withGraphFetched`,
+        `relation "${childName}" cannot be loaded with both withGraphJoined and withGraphFetched`,
       );
     }
   }
@@ -1382,10 +1407,13 @@ function beforeExecute(builder) {
   return promise;
 }
 
-function doExecute(builder) {
+async function doExecute(builder) {
   let promise = Promise.resolve();
 
   builder = callOnBuildHooks(builder);
+  // Unlike `onBuild`, `onAfterBuild` can be async, as it only runs when the
+  // query is executed, not when it's only built, e.g. with `toKnexQuery()`:
+  await chainOperationHooks(promise, builder, 'onAfterBuild');
   const queryExecutorOperation = findQueryExecutorOperation(builder);
 
   const explicitRejectValue = builder._explicitRejectValue;
@@ -1398,7 +1426,7 @@ function doExecute(builder) {
   } else if (queryExecutorOperation !== null) {
     promise = Promise.resolve(queryExecutorOperation.queryExecutor(builder));
   } else {
-    promise = Promise.resolve(buildKnexQuery(builder));
+    promise = executeKnexQuery(builder);
 
     promise = chainOperationHooks(promise, builder, 'onRawResult');
     promise = promise.then((result) => createModels(result, builder));
@@ -1407,6 +1435,30 @@ function doExecute(builder) {
   return promise;
 }
 
+// An operation can split the query into batches, e.g. to stay below the number
+// of values a database accepts in one statement. Build and execute the knex
+// query once per batch then, with the operation reading the current batch from
+// `builder._queryBatch`, and merge the counts or rows of all batches.
+async function executeKnexQuery(builder) {
+  const operation = builder.findOperation((op) => op.hasQueryBatches());
+  const batches = operation?.queryBatches(builder);
+
+  if (batches) {
+    const results = [];
+
+    for (const batch of batches) {
+      builder._queryBatch = batch;
+      results.push(await buildKnexQuery(builder));
+    }
+
+    return results.reduce((merged, result) =>
+      Array.isArray(merged) ? merged.concat(result) : merged + result,
+    );
+  } else {
+    return buildKnexQuery(builder);
+  }
+}
+
 function afterExecute(builder, result) {
   let promise = Promise.resolve(result);
 
@@ -1560,7 +1612,13 @@ function callOnBuildHooks(builder) {
   callOnBuildFuncs(builder, builder.internalContext().onBuild);
 
   builder.executeOnBuild();
-  return wrapWhereGroups(builder);
+
+  // Clear the order after all hooks, as any of them may add one.
+  if (builder.isUpdate()) {
+    clearUnsupportedOrder(builder);
+  }
+
+  return builder;
 }
 
 function callOnBuildFuncs(builder, func) {
@@ -1595,6 +1653,12 @@ function buildKnexQuery(builder, knexBuilder = builder.knex().queryBuilder()) {
     }
   }
 
+  const limitPerParentOperation = builder.findOperation(LimitPerParentOperation);
+
+  if (limitPerParentOperation) {
+    knexBuilder = limitPerParentOperation.onAfterBuildKnex(knexBuilder, builder);
+  }
+
   return knexBuilder;
 }
 
@@ -1604,6 +1668,10 @@ function setDefaultTable(builder, knexBuilder) {
 
   if (table === tableRef) {
     return knexBuilder.table(table);
+  } else if (isMsSql(builder.knex()) && (builder.isUpdate() || builder.isDelete())) {
+    // SQL Server can't alias the table of updates and deletes, but it can modify
+    // it through a common table expression named like the alias.
+    return knexBuilder.with(tableRef, (query) => query.select('*').from(table)).table(tableRef);
   } else {
     return knexBuilder.table(`${table} as ${tableRef}`);
   }

package/lib/queryBuilder/QueryBuilderOperationSupport.js

@@ -3,7 +3,8 @@
 const { isString, isFunction, isRegExp, mergeMaps, last } = require('../utils/objectUtils');
 const { QueryBuilderContextBase } = require('./QueryBuilderContextBase');
 const { QueryBuilderUserContext } = require('./QueryBuilderUserContext');
-const { deprecate } = require('../utils/deprecate');
+const { deprecate } = require('../utils/warnings');
+const { getWhereGroupOperations } = require('./whereGroups');
 
 const AllSelector = () => true;
 const SelectSelector =
@@ -489,8 +490,19 @@ class QueryBuilderOperationSupport {
   }
 
   executeOnBuildKnex(knexBuilder) {
-    this.forEachOperation(true, (op) => {
-      if (op.hasOnBuildKnex()) {
+    const whereGroupOps = getWhereGroupOperations(this);
+
+    // Visit the operations while building, so that operations added by
+    // `onBuildKnex` hooks are built too. Build each where group in place of its
+    // first operation, and skip the operations that the groups build.
+    this.forEachOperation(true, (it) => {
+      const op = whereGroupOps.has(it)
+        ? whereGroupOps.get(it)
+        : it.isAncestorInSet(whereGroupOps)
+          ? null
+          : it;
+
+      if (op?.hasOnBuildKnex()) {
         const newKnexBuilder = this.callOperationMethod(op, 'onBuildKnex', [knexBuilder, this]);
         // Default to the input knex builder for backwards compatibility
         // with QueryBuilder.onBuildKnex hooks.

package/lib/queryBuilder/StaticHookArguments.js

@@ -26,9 +26,12 @@ class StaticHookArguments {
     return () => {
       // 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.
+      // its result, not for the result of this find query. The same goes for
+      // the value it was resolved with, e.g. the 0 of an update that only
+      // changes the join rows of a many-to-many relation.
       return this[BUILDER_SYMBOL].toFindQuery()
         .clear('runAfter')
+        .clearResolve()
         .clearWithGraphFetched()
         .runAfter(toArray);
     };

package/lib/queryBuilder/graph/GraphData.js

@@ -6,7 +6,46 @@ class GraphData {
     this.currentGraph = currentGraph;
     this.graphOptions = graphOptions;
     this.nodeDbExistence = nodeDbExistence;
+    // Pruning replaces `graph.nodes`, but `keptNodeForRow()` also needs the
+    // branches below related nodes.
+    this._unprunedNodes = graph.nodes;
+    this._keptNodesByRowKey = null;
   }
+
+  // Find the node that keeps the row of `currentNode` in another place of the
+  // graph, by relating or patching it there, or by upserting it below a related
+  // node. Only call this after pruning.
+  keptNodeForRow(currentNode) {
+    if (!this._keptNodesByRowKey) {
+      this._keptNodesByRowKey = new Map();
+      const nodes = new Set(this.graph.nodes);
+
+      // Nested upserts write the pruned branches below related nodes, except
+      // for models marked with `#unrelate` or `#delete` and their descendants:
+      const isUpsertedBelowRelatedNode = (node) =>
+        !node.toBeUnrelatedOrDeleted &&
+        (nodes.has(node.parentNode)
+          ? this.graphOptions.shouldRelate(node.parentNode, this)
+          : isUpsertedBelowRelatedNode(node.parentNode));
+
+      for (const node of this._unprunedNodes) {
+        if (
+          node.obj.$hasId() &&
+          (nodes.has(node)
+            ? this.graphOptions.shouldPatchOrUpdateIgnoreDisable(node, this)
+            : isUpsertedBelowRelatedNode(node))
+        ) {
+          this._keptNodesByRowKey.set(getRowKey(node), node);
+        }
+      }
+    }
+
+    return this._keptNodesByRowKey.get(getRowKey(currentNode)) || null;
+  }
+}
+
+function getRowKey(node) {
+  return `${node.modelClass.getTableName()}:${node.obj.$idKey()}`;
 }
 
 module.exports = {

package/lib/queryBuilder/graph/GraphFetcher.js

@@ -4,6 +4,8 @@ const { asArray, groupBy } = require('../../utils/objectUtils');
 const { ModelGraph } = require('../../model/graph/ModelGraph');
 const { FetchStrategy } = require('./GraphOptions');
 const { RelationExpression } = require('../RelationExpression');
+const { getDeclaredColumns } = require('../operations/UpdateOperation');
+const { parseFieldExpression, isFieldExpressionKey } = require('../../utils/parseFieldExpression');
 
 class GraphFetcher {
   /**
@@ -106,8 +108,14 @@ function createInputColumnSelector(nodes) {
 
     for (const node of nodes) {
       const databaseJson = node.obj.$toDatabaseJson(builder);
+      const declaredColumns = getDeclaredColumns(node.modelClass);
+
+      for (const key of Object.keys(databaseJson)) {
+        // Select the json column of field expressions like `'meta:a'`:
+        const column = isFieldExpressionKey(key, declaredColumns)
+          ? parseFieldExpression(key).column
+          : key;
 
-      for (const column of Object.keys(databaseJson)) {
         if (!shouldSelectColumn(column, selects, node)) {
           continue;
         }

package/lib/queryBuilder/graph/GraphOptions.js

@@ -17,21 +17,6 @@ const FETCH_STRATEGY = 'fetchStrategy';
 const ALLOW_REFS = 'allowRefs';
 const ALLOW_MARKERS = 'allowMarkers';
 
-const OPTION_NAMES = [
-  NO_RELATE,
-  NO_UNRELATE,
-  NO_INSERT,
-  NO_UPDATE,
-  NO_DELETE,
-  UPDATE,
-  RELATE,
-  UNRELATE,
-  INSERT_MISSING,
-  FETCH_STRATEGY,
-  ALLOW_REFS,
-  ALLOW_MARKERS,
-];
-
 // The options that are matched against the relation path of each node, see
 // `_hasOption()`.
 const NODE_OPTION_NAMES = [
@@ -46,6 +31,8 @@ const NODE_OPTION_NAMES = [
   INSERT_MISSING,
 ];
 
+const OPTION_NAMES = [...NODE_OPTION_NAMES, FETCH_STRATEGY, ALLOW_REFS, ALLOW_MARKERS];
+
 const FetchStrategy = {
   OnlyIdentifiers: 'OnlyIdentifiers',
   Everything: 'Everything',
@@ -55,14 +42,17 @@ const FetchStrategy = {
 class GraphOptions {
   // `rootRelationPath` is the relation path of the root node of a recursive
   // upsert in the original graph, against which the relation paths and
-  // expressions of the options match.
-  constructor(options, rootRelationPath = []) {
+  // expressions of the options match. `insertOnly` is only set by
+  // `insertGraph`, which never fetches, updates or removes existing rows.
+  constructor(options, rootRelationPath = [], insertOnly = false) {
     if (options instanceof GraphOptions) {
       this.options = options.options;
       this.rootRelationPath = options.rootRelationPath;
+      this.insertOnly = options.insertOnly;
     } else {
       this.options = parseRelationExpressions(options);
       this.rootRelationPath = rootRelationPath;
+      this.insertOnly = insertOnly;
     }
   }
 
@@ -79,17 +69,12 @@ class GraphOptions {
   }
 
   isInsertOnly() {
-    // NO_RELATE is not in the list, since the `insert only` mode does
-    // relate things that can be related using inserts.
-    // TODO: Use a special key for this.
-    return [NO_DELETE, NO_UPDATE, NO_UNRELATE, INSERT_MISSING].every((opt) => {
-      return this.options[opt] === true;
-    });
+    return this.insertOnly;
   }
 
   // Like `shouldRelate` but ignores settings that explicitly disable relate operations.
   shouldRelateIgnoreDisable(node, graphData) {
-    if (node.toBeUnrelated || node.toBeDeleted) {
+    if (node.toBeUnrelatedOrDeleted) {
       return false;
     }
 
@@ -113,7 +98,7 @@ class GraphOptions {
 
   // Like `shouldInsert` but ignores settings that explicitly disable insert operations.
   shouldInsertIgnoreDisable(node, graphData) {
-    if (node.toBeUnrelated || node.toBeDeleted) {
+    if (node.toBeUnrelatedOrDeleted) {
       return false;
     }
 
@@ -135,7 +120,7 @@ class GraphOptions {
   // Like `shouldPatch() || shouldUpdate()` but ignores settings that explicitly disable
   // update or patch operations.
   shouldPatchOrUpdateIgnoreDisable(node, graphData) {
-    if (node.toBeUnrelated || node.toBeDeleted) {
+    if (node.toBeUnrelatedOrDeleted) {
       return false;
     }
 
@@ -176,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)))
     );
   }
 
@@ -188,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)
     );
   }
 
@@ -197,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);
   }
@@ -279,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;
     }
   }
 
@@ -359,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;