objection 3.7.0 → 3.8.0

package/lib/model/AjvValidator.js

@@ -5,7 +5,7 @@ const addFormats = require('ajv-formats');
 const { Validator } = require('./Validator');
 const { ValidationErrorType } = require('../model/ValidationError');
 const { isObject, once, cloneDeep: lodashCloneDeep, omit } = require('../utils/objectUtils');
-const { parseFieldExpression } = require('../utils/parseFieldExpression');
+const { parseFieldExpression, isFieldExpressionKey } = require('../utils/parseFieldExpression');
 const { getQueryPropKeys } = require('./modelQueryProps');
 
 class AjvValidator extends Validator {
@@ -79,27 +79,60 @@ class AjvValidator extends Validator {
       return json;
     }
 
-    const modelClass = model.constructor;
-    const validator = this.getValidator(
-      modelClass,
-      ctx.jsonSchema,
-      !!options.patch,
-      options.patch ? null : getMissingQueryPropKeys(model, json, ctx.jsonSchema),
-    );
-
     // We need to clone the input json if we are about to set default values.
     if (!options.mutable && !options.patch && setsDefaultValues(ctx.jsonSchema)) {
       json = cloneDeep(json);
     }
 
-    // Patch objects can contain field expression keys like `'meta:b'` that update
-    // a single property inside a json column. Validate them against the nested
-    // schema by converting them into nested objects like `{ meta: { b: value } }`.
-    const fieldExpressions = options.patch ? nestFieldExpressions(json) : null;
-    const validationJson = fieldExpressions ? fieldExpressions.json : json;
+    // Patch and update objects can contain field expression keys like `'meta:b'`
+    // that update a single property inside a json column. Validate them against
+    // the nested schema by converting them into nested objects like
+    // `{ meta: { b: value } }`.
+    const queryPropKeys = getQueryPropKeys(model);
+    const fieldExpressions = nestFieldExpressions(json, queryPropKeys, ctx.jsonSchema);
+    let validationJson = fieldExpressions ? fieldExpressions.json : json;
+
+    const modelClass = model.constructor;
+    const validate = (json, isPatchObject, givenKeys = []) => {
+      const validator = this.getValidator(
+        modelClass,
+        ctx.jsonSchema,
+        isPatchObject,
+        isPatchObject ? null : getRequiredKeysGivenOutside(json, ctx.jsonSchema, givenKeys),
+      );
+      validator.call(model, json);
+      return validator.errors || [];
+    };
+
+    let errors;
+
+    if (options.patch) {
+      errors = validate(validationJson, true);
+    } else if (fieldExpressions && fieldExpressions.columns.length > 0) {
+      // Field expressions only write parts of their json columns. Validate these
+      // parts like patches, and the rest normally, with the columns counted as
+      // present like the query properties.
+      const { columns } = fieldExpressions;
+      const columnsJson = Object.fromEntries(
+        columns
+          .filter((column) => hasOwn(validationJson, column))
+          .map((column) => [column, validationJson[column]]),
+      );
+      const restJson = omit(validationJson, columns);
 
-    validator.call(model, validationJson);
-    const error = parseValidationError(validator.errors, modelClass, options, this.ajvOptions);
+      errors = [
+        ...validate(columnsJson, true),
+        ...validate(restJson, false, [...queryPropKeys, ...columns]),
+      ];
+
+      // Combine the parts again, without the defaults that Ajv set for the
+      // columns in `restJson`.
+      validationJson = Object.assign(restJson, columnsJson);
+    } else {
+      errors = validate(validationJson, false, queryPropKeys);
+    }
+
+    const error = parseValidationError(errors, modelClass, options, this.ajvOptions);
 
     if (error) {
       throw error;
@@ -107,7 +140,7 @@ class AjvValidator extends Validator {
 
     if (fieldExpressions) {
       // Copy back the changes made by Ajv options like `coerceTypes` and `removeAdditional`.
-      unnestFieldExpressions(json, fieldExpressions);
+      unnestFieldExpressions(json, validationJson, fieldExpressions);
     }
 
     return json;
@@ -148,7 +181,8 @@ class AjvValidator extends Validator {
         normalValidator: null,
 
         // Validators created for the schema object without the `required`
-        // properties that are given as query properties, keyed by their names.
+        // properties that are given outside the json, as query properties or
+        // json columns written by field expressions, keyed by their names.
         queryPropValidators: null,
       };
 
@@ -298,10 +332,11 @@ function parseValidationError(errors, modelClass, options, ajvOptions) {
   });
 }
 
-function nestFieldExpressions(json) {
+function nestFieldExpressions(json, queryPropKeys, jsonSchema) {
+  const isFieldExpression = (key) => isFieldExpressionKey(key, jsonSchema.properties);
   const keys = Object.keys(json);
 
-  if (!keys.some(isFieldExpression)) {
+  if (!keys.some(isFieldExpression) && !queryPropKeys.some(isFieldExpression)) {
     return null;
   }
 
@@ -310,6 +345,15 @@ function nestFieldExpressions(json) {
   // The objects created here for the nested paths. Other objects are values
   // of the input json and must not be modified.
   const createdObjects = new Set();
+  // The json columns that are only written partially, by field expressions in
+  // the json or the query properties.
+  const columns = new Set();
+
+  const addColumn = (expression) => {
+    if (expression && !hasOwn(json, expression.column)) {
+      columns.add(expression.column);
+    }
+  };
 
   for (const key of keys) {
     if (!isFieldExpression(key)) {
@@ -320,7 +364,10 @@ function nestFieldExpressions(json) {
 
   for (const key of keys) {
     if (isFieldExpression(key)) {
-      const path = fieldExpressionPath(key);
+      const expression = parseFieldExpressionKey(key);
+      // Not a valid field expression, validate it as a top-level property:
+      const path = expression ? expression.path : [key];
+      addColumn(expression);
 
       // Field expressions with array access, and those that conflict with other
       // keys of the patch, can't be validated without the current value of the
@@ -331,10 +378,16 @@ function nestFieldExpressions(json) {
     }
   }
 
-  return { json: nested, paths };
+  for (const key of queryPropKeys) {
+    if (isFieldExpression(key)) {
+      addColumn(parseFieldExpressionKey(key));
+    }
+  }
+
+  return { json: nested, paths, columns: [...columns] };
 }
 
-function unnestFieldExpressions(json, { json: nested, paths }) {
+function unnestFieldExpressions(json, nested, { paths, columns }) {
   for (const [key, path] of paths) {
     let value = nested;
     let found = true;
@@ -356,29 +409,35 @@ function unnestFieldExpressions(json, { json: nested, paths }) {
       json[key] = value;
     }
   }
-}
 
-function isFieldExpression(key) {
-  return key.indexOf(':') !== -1;
+  // Copy over the default values that Ajv set for missing properties, but not
+  // the json columns written by the field expressions.
+  for (const key of Object.keys(nested)) {
+    if (!paths.has(key) && !columns.includes(key)) {
+      json[key] = nested[key];
+    }
+  }
 }
 
-function fieldExpressionPath(key) {
+// Parse a field expression key into its json column and nested path, with the
+// path set to `null` if the key accesses array elements.
+function parseFieldExpressionKey(key) {
   let parsed;
 
   try {
     parsed = parseFieldExpression(key);
   } catch (err) {
-    // Not a valid field expression, validate it as a top-level property.
-    return [key];
+    return null;
   }
 
+  const { column, access } = parsed;
   // Numeric keys like the `0` in `tags:0` also access array elements when the
   // json value is an array, so treat them like `[0]`.
-  if (parsed.access.some((access) => access.type !== 'object' || /^-?\d+$/.test(access.ref))) {
-    return null;
-  }
-
-  return [parsed.column, ...parsed.access.map((access) => String(access.ref))];
+  const isArrayAccess = access.some(({ type, ref }) => type !== 'object' || /^-?\d+$/.test(ref));
+  return {
+    column,
+    path: isArrayAccess ? null : [column, ...access.map(({ ref }) => String(ref))],
+  };
 }
 
 function setPath(obj, path, value, createdObjects) {
@@ -462,22 +521,20 @@ function objectHasDefaults(obj) {
   return false;
 }
 
-// Returns the keys of the query properties of `model` (`raw()`, `val()`,
-// `ref()`, subqueries...) that are required by the schema but missing from
-// `json`, sorted, or `null` if there are none. Query properties are split from
-// the json before validation, but they do provide a value for the property.
-function getMissingQueryPropKeys(model, json, jsonSchema) {
+// Returns the `keys` that are required by the schema but given outside of
+// `json`, sorted, or `null` if there are none. Query properties (`raw()`,
+// `val()`, `ref()`, subqueries...) are split from the json before validation,
+// but they do provide a value for the property, and so do field expressions
+// for their json columns.
+function getRequiredKeysGivenOutside(json, jsonSchema, keys) {
   const required = jsonSchema.required;
 
   if (!Array.isArray(required) || required.length === 0) {
     return null;
   }
 
-  const keys = getQueryPropKeys(model).filter(
-    (key) => required.includes(key) && !Object.prototype.hasOwnProperty.call(json, key),
-  );
-
-  return keys.length > 0 ? keys.sort() : null;
+  const givenKeys = required.filter((key) => keys.includes(key) && !hasOwn(json, key));
+  return givenKeys.length > 0 ? givenKeys.sort() : null;
 }
 
 function jsonSchemaWithoutRequiredKeys(jsonSchema, keys) {

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,10 @@ 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');
 
 class QueryBuilder extends QueryBuilderBase {
   static init(self, modelClass) {
@@ -56,6 +58,7 @@ class QueryBuilder extends QueryBuilderBase {
     self._resultModelClass = null;
     self._explicitRejectValue = null;
     self._explicitResolveValue = null;
+    self._queryBatch = null;
     self._modifiers = {};
 
     self._allowedGraphExpression = null;
@@ -257,21 +260,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 +398,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) => {
@@ -506,34 +517,38 @@ class QueryBuilder extends QueryBuilderBase {
 
     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 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)) {
+        // `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 {
-        // 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 +600,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 +652,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);
       }
     }
   }
@@ -1325,14 +1340,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 +1397,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 +1416,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 +1425,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 +1602,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 +1643,12 @@ function buildKnexQuery(builder, knexBuilder = builder.knex().queryBuilder()) {
     }
   }
 
+  const limitPerParentOperation = builder.findOperation(LimitPerParentOperation);
+
+  if (limitPerParentOperation) {
+    knexBuilder = limitPerParentOperation.onAfterBuildKnex(knexBuilder, builder);
+  }
+
   return knexBuilder;
 }
 
@@ -1604,6 +1658,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/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;
     }