objection 3.1.5 → 3.2.0

package/README.md

@@ -1,6 +1,6 @@
 [![Stand With Ukraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner2-direct.svg)](https://stand-with-ukraine.pp.ua)
 
-[![Tests](https://github.com/Vincit/objection.js/actions/workflows/test.yml/badge.svg)](https://github.com/Vincit/objection.js)
+[![Tests](https://github.com/ditojs/objection/actions/workflows/test.yml/badge.svg)](https://github.com/ditojs/objection/actions)
 [![Join the chat at https://gitter.im/Vincit/objection.js](https://badges.gitter.im/Vincit/objection.js.svg)](https://gitter.im/Vincit/objection.js?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 # [Objection.js](https://vincit.github.io/objection.js)
@@ -9,7 +9,7 @@ Objection.js is an [ORM](https://en.wikipedia.org/wiki/Object-relational_mapping
 
 Even though ORM is the best commonly known acronym to describe objection, a more accurate description is to call it **a relational query builder**. You get all the benefits of an SQL query builder but also a powerful set of tools for working with relations.
 
-Objection.js is built on an SQL query builder called [knex](http://knexjs.org). All databases supported by knex are supported by objection.js. **SQLite3**, **Postgres** and **MySQL** are [thoroughly tested](https://github.com/Vincit/objection.js/actions).
+Objection.js is built on an SQL query builder called [knex](http://knexjs.org). All databases supported by knex are supported by objection.js. **SQLite3**, **Postgres** and **MySQL** are [thoroughly tested](https://github.com/ditojs/objection/actions).
 
 What objection.js gives you:
 
@@ -17,7 +17,7 @@ What objection.js gives you:
 - **Simple and fun way to [fetch, insert, update and delete](https://vincit.github.io/objection.js/guide/query-examples.html) objects using the full power of SQL**
 - **Powerful mechanisms for [eager loading](https://vincit.github.io/objection.js/guide/query-examples.html#eager-loading), [inserting](https://vincit.github.io/objection.js/guide/query-examples.html#graph-inserts) and [upserting](https://vincit.github.io/objection.js/guide/query-examples.html#graph-upserts) object graphs**
 - **Easy to use [transactions](https://vincit.github.io/objection.js/guide/transactions.html)**
-- **Official [TypeScript](https://github.com/Vincit/objection.js/blob/main/typings/objection/index.d.ts) support**
+- **Official [TypeScript](https://github.com/ditojs/objection/blob/main/typings/objection/index.d.ts) support**
 - **Optional [JSON schema](https://vincit.github.io/objection.js/guide/validation.html) validation**
 - **A way to [store complex documents](https://vincit.github.io/objection.js/guide/documents.html) as single rows**
 

package/lib/model/AjvValidator.js

@@ -35,6 +35,9 @@ class AjvValidator extends Validator {
     // A cache for the compiled validator functions.
     self.cache = new Map();
 
+    // The cache keys of the unmodified model class schemas.
+    self.modelCacheKeys = new WeakMap();
+
     const setupAjv = (ajv) => {
       if (conf.onCreateAjv) {
         conf.onCreateAjv(ajv);
@@ -92,12 +95,23 @@ class AjvValidator extends Validator {
     // Use the Ajv custom serializer if provided.
     const createCacheKey = this.ajvOptions.serialize || JSON.stringify;
 
-    // Optimization for the common case where jsonSchema is never modified.
-    // In that case we don't need to call the costly createCacheKey function.
-    const cacheKey =
-      jsonSchema === modelClass.getJsonSchema()
-        ? modelClass.uniqueTag()
-        : createCacheKey(jsonSchema);
+    let cacheKey;
+
+    if (jsonSchema === modelClass.getJsonSchema()) {
+      // Optimization for the common case where jsonSchema is never modified.
+      // The key is only computed once per model class. It includes the schema
+      // contents so that model classes with the same `uniqueTag()` but
+      // different schemas don't share validators, while bound model classes
+      // with equal schemas still do.
+      cacheKey = this.modelCacheKeys.get(modelClass);
+
+      if (cacheKey === undefined) {
+        cacheKey = `${modelClass.uniqueTag()}:${createCacheKey(jsonSchema)}`;
+        this.modelCacheKeys.set(modelClass, cacheKey);
+      }
+    } else {
+      cacheKey = createCacheKey(jsonSchema);
+    }
 
     let validators = this.cache.get(cacheKey);
     let validator = null;
@@ -263,24 +277,35 @@ function objectHasDefaults(obj) {
 
 function jsonSchemaWithoutRequired(jsonSchema) {
   const subSchemaProps = ['anyOf', 'oneOf', 'allOf', 'not', 'then', 'else', 'properties'];
+  // `definitions` was renamed to `$defs` in draft 2019-09. Support both.
+  const definitionProps = ['definitions', '$defs'];
   return Object.assign(
     omit(jsonSchema, ['required', ...subSchemaProps]),
     ...subSchemaProps.map((prop) => subSchemaWithoutRequired(jsonSchema, prop)),
-    jsonSchema && jsonSchema.definitions && Object.keys(jsonSchema.definitions).length > 0
-      ? {
-          definitions: Object.assign(
-            ...Object.keys(jsonSchema.definitions).map((prop) => ({
-              [prop]: jsonSchemaWithoutRequired(jsonSchema.definitions[prop]),
-            })),
-          ),
-        }
-      : {},
+    ...definitionProps.map((prop) => definitionsWithoutRequired(jsonSchema, prop)),
     jsonSchema.discriminator && jsonSchema.discriminator.propertyName
       ? { required: [jsonSchema.discriminator.propertyName] }
       : {},
   );
 }
 
+function definitionsWithoutRequired(jsonSchema, prop) {
+  const definitions = jsonSchema && jsonSchema[prop];
+
+  if (definitions && Object.keys(definitions).length > 0) {
+    return {
+      [prop]: Object.fromEntries(
+        Object.entries(definitions).map(([key, schema]) => [
+          key,
+          jsonSchemaWithoutRequired(schema),
+        ]),
+      ),
+    };
+  } else {
+    return {};
+  }
+}
+
 function subSchemaWithoutRequired(jsonSchema, prop) {
   if (jsonSchema[prop]) {
     if (Array.isArray(jsonSchema[prop])) {

package/lib/model/Model.js

@@ -120,7 +120,7 @@ class Model {
     return json;
   }
 
-  $formatJson(json) {
+  $formatJson(json, options) {
     return json;
   }
 
@@ -721,6 +721,8 @@ Model.uidProp = '#id';
 Model.uidRefProp = '#ref';
 Model.dbRefProp = '#dbRef';
 Model.propRefRegex = /#ref{([^\.]+)\.([^}]+)}/g;
+Model.graphUnrelateProp = '#unrelate';
+Model.graphDeleteProp = '#delete';
 Model.jsonAttributes = null;
 Model.cloneObjectAttributes = true;
 Model.virtualAttributes = null;

package/lib/model/graph/ModelGraphNode.js

@@ -46,6 +46,18 @@ class ModelGraphNode {
     return this.obj[this.modelClass.dbRefProp];
   }
 
+  get toBeUnrelated() {
+    return this.obj[this.modelClass.graphUnrelateProp] === true;
+  }
+
+  get toBeDeleted() {
+    return this.obj[this.modelClass.graphDeleteProp] === true;
+  }
+
+  get toBeUnrelatedOrDeleted() {
+    return this.toBeUnrelated || this.toBeDeleted;
+  }
+
   get parentNode() {
     if (this.parentEdge) {
       return this.parentEdge.ownerNode;

package/lib/model/modelToJson.js

@@ -15,10 +15,11 @@ function toJson(model, optIn) {
     pick: null,
     omitFromJson: model.$omitFromJson() || null,
     cloneObjects: modelClass.cloneObjectAttributes,
+    format: optIn && optIn.format,
   };
 
   let json = toExternalJsonImpl(model, opt);
-  json = model.$formatJson(json);
+  json = model.$formatJson(json, opt.format);
 
   return json;
 }

package/lib/queryBuilder/QueryBuilder.js

@@ -43,6 +43,7 @@ const { SelectOperation } = require('./operations/select/SelectOperation');
 const { EagerOperation } = require('./operations/eager/EagerOperation');
 const { RangeOperation } = require('./operations/RangeOperation');
 const { FirstOperation } = require('./operations/FirstOperation');
+const { NoneOperation } = require('./operations/NoneOperation');
 const { FromOperation } = require('./operations/FromOperation');
 const { KnexOperation } = require('./operations/KnexOperation');
 
@@ -56,6 +57,7 @@ class QueryBuilder extends QueryBuilderBase {
     self._modifiers = {};
 
     self._allowedGraphExpression = null;
+    self._graphModifiersAtPath = [];
     self._findOperationOptions = modelClass.defaultFindOptions;
     self._relatedQueryFor = null;
 
@@ -203,6 +205,7 @@ class QueryBuilder extends QueryBuilderBase {
     eagerOp.expression = eagerOp.expression.merge(parsedExp);
     eagerOp.graphOptions = { ...eagerOp.graphOptions, ...options };
 
+    checkMixedEager(this);
     checkEager(this);
     return this;
   }
@@ -223,28 +226,30 @@ class QueryBuilder extends QueryBuilderBase {
   }
 
   graphExpressionObject() {
-    const eagerOp = this.findOperation(EagerOperation);
+    const expression = getGraphExpression(this);
 
-    if (eagerOp && !eagerOp.expression.isEmpty) {
-      return eagerOp.expression.toPojo();
+    if (expression && !expression.isEmpty) {
+      return expression.toPojo();
     } else {
       return null;
     }
   }
 
   graphModifiersAtPath() {
-    const eagerOp = this.findOperation(EagerOperation);
+    const expression = getGraphExpression(this);
 
-    if (eagerOp && !eagerOp.expression.isEmpty) {
-      return eagerOp.modifiersAtPath.map((it) => Object.assign({}, it));
+    if (expression && !expression.isEmpty) {
+      return this._graphModifiersAtPath.map((it) => Object.assign({}, it));
     } else {
       return [];
     }
   }
 
   modifyGraph(path, modifier) {
-    const eagerOp = ensureEagerOperation(this);
-    eagerOp.modifiersAtPath.push({ path, modifier });
+    // The modifiers are shared by all eager operations. They only take effect
+    // for the paths that exist in each operation's expression.
+    ensureEagerOperation(this);
+    this._graphModifiersAtPath.push({ path, modifier });
     return this;
   }
 
@@ -301,8 +306,7 @@ class QueryBuilder extends QueryBuilderBase {
   }
 
   hasWithGraph() {
-    const eagerOp = this.findOperation(EagerOperation);
-    return !!eagerOp && !eagerOp.expression.isEmpty;
+    return findEagerOperations(this).some((eagerOp) => !eagerOp.expression.isEmpty);
   }
 
   isSelectAll() {
@@ -350,6 +354,7 @@ class QueryBuilder extends QueryBuilderBase {
     builder._modifiers = { ...this._modifiers };
 
     builder._allowedGraphExpression = this._allowedGraphExpression;
+    builder._graphModifiersAtPath = this._graphModifiersAtPath.slice();
     builder._findOperationOptions = this._findOperationOptions;
     builder._relatedQueryFor = this._relatedQueryFor;
 
@@ -421,7 +426,9 @@ class QueryBuilder extends QueryBuilderBase {
     const builder = this.clone().clear(/orderBy|offset|limit/);
 
     const countQuery = knex.count('* as count').from((knexBuilder) => {
-      builder.toKnexQuery(knexBuilder).as('temp');
+      // 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`.
+      builder.toKnexQuery(knexBuilder).clearOrder().as('temp');
     });
 
     if (this.internalOptions().debug) {
@@ -808,6 +815,10 @@ class QueryBuilder extends QueryBuilderBase {
     return this.addOperation(new FirstOperation('first'), args);
   }
 
+  none() {
+    return this.addOperation(new NoneOperation('none'), []);
+  }
+
   joinRelated(expression, options) {
     ensureJoinRelatedOperation(this, 'innerJoin').addCall({
       expression,
@@ -922,6 +933,10 @@ class QueryBuilder extends QueryBuilderBase {
     return this.addOperation(new FromOperation('from'), args);
   }
 
+  updateFrom(...args) {
+    return this.addOperation(new KnexOperation('updateFrom'), args);
+  }
+
   table(...args) {
     return this.addOperation(new FromOperation('table'), args);
   }
@@ -930,6 +945,15 @@ class QueryBuilder extends QueryBuilderBase {
     if (arguments.length === 0) {
       return this._relatedQueryFor;
     } else {
+      // The write operation factories installed by the static `relatedQuery()`
+      // read `for()` when the write method is called. Setting it afterwards
+      // would make the query silently target the wrong rows.
+      if (this._findOperationFactory !== findOperationFactory && !this.isFind()) {
+        throw new Error(
+          'for() must be called before insert, update, patch, delete, relate or unrelate on queries created using the static relatedQuery method',
+        );
+      }
+
       this._relatedQueryFor = relatedQueryFor;
       return this;
     }
@@ -952,48 +976,83 @@ function getTableName(modelClassOrTableName) {
   }
 }
 
+// A query builder can hold at most one eager operation of each kind: one
+// `JoinEagerOperation` for `withGraphJoined` and one `WhereInEagerOperation`
+// (or its subclass `NaiveEagerOperation`) for `withGraphFetched`.
 function ensureEagerOperation(builder, algorithm = null) {
   const modelClass = builder.modelClass();
   const defaultGraphOptions = modelClass.getDefaultGraphOptions();
-  const eagerOp = builder.findOperation(EagerOperation);
 
-  if (algorithm) {
-    const EagerOperationClass = getOperationClassForEagerAlgorithm(builder, algorithm);
+  if (!algorithm) {
+    const eagerOp = builder.findOperation(EagerOperation);
 
-    if (eagerOp instanceof EagerOperationClass) {
+    if (eagerOp) {
       return eagerOp;
-    } else {
-      const newEagerOp = new EagerOperationClass('eager', {
-        defaultGraphOptions,
-      });
+    }
 
-      if (eagerOp) {
-        newEagerOp.cloneFrom(eagerOp);
-      }
+    algorithm = getWhereInEagerAlgorithm(builder);
+  }
 
-      builder.clear(EagerOperation);
-      builder.addOperation(newEagerOp);
+  const EagerOperationClass = getOperationClassForEagerAlgorithm(builder, algorithm);
+  const EagerOperationKind = getEagerOperationKind(EagerOperationClass);
+  const eagerOp = builder.findOperation(EagerOperationKind);
 
-      return newEagerOp;
-    }
-  } else {
-    if (eagerOp) {
-      return eagerOp;
-    } else {
-      const EagerOperationClass = getOperationClassForEagerAlgorithm(
-        builder,
-        getWhereInEagerAlgorithm(builder),
-      );
+  if (eagerOp && eagerOp.constructor === EagerOperationClass) {
+    return eagerOp;
+  }
 
-      const newEagerOp = new EagerOperationClass('eager', {
-        defaultGraphOptions,
-      });
+  const newEagerOp = new EagerOperationClass('eager', {
+    defaultGraphOptions,
+  });
+
+  if (eagerOp) {
+    // Switching between algorithms of the same kind, e.g. from
+    // `WhereInEagerOperation` to `NaiveEagerOperation`.
+    newEagerOp.cloneFrom(eagerOp);
+    builder.clear(EagerOperationKind);
+  } else if (!builder.has(EagerOperation)) {
+    // The `modifyGraph` modifiers only live as long as an eager operation.
+    builder._graphModifiersAtPath = [];
+  }
 
-      builder.addOperation(newEagerOp);
+  builder.addOperation(newEagerOp);
 
-      return newEagerOp;
-    }
+  // Keep the joined operation before the fetched one (see `findEagerOperations`),
+  // even if it is added after `addImplicitOperations`, e.g. in `runBefore`.
+  const fetchOp =
+    EagerOperationKind === JoinEagerOperation && builder.findOperation(WhereInEagerOperation);
+
+  if (fetchOp) {
+    builder.removeOperation(fetchOp).addOperation(fetchOp);
   }
+
+  return newEagerOp;
+}
+
+function getEagerOperationKind(EagerOperationClass) {
+  return EagerOperationClass === JoinEagerOperation ? JoinEagerOperation : WhereInEagerOperation;
+}
+
+function findEagerOperations(builder) {
+  // Joined operations first, so that their `onBuild` runs before the fetched
+  // one's. See `WhereInEagerOperation.onBuild`.
+  return [
+    builder.findOperation(JoinEagerOperation),
+    builder.findOperation(WhereInEagerOperation),
+  ].filter(Boolean);
+}
+
+function getGraphExpression(builder) {
+  const eagerOps = findEagerOperations(builder);
+
+  if (eagerOps.length === 0) {
+    return null;
+  }
+
+  return eagerOps.reduce(
+    (expression, eagerOp) => expression.merge(eagerOp.expression),
+    RelationExpression.create(),
+  );
 }
 
 function getWhereInEagerAlgorithm(builder) {
@@ -1036,14 +1095,44 @@ function parseRelationExpression(modelClass, exp) {
   }
 }
 
+function checkMixedEager(builder) {
+  const joinOp = builder.findOperation(JoinEagerOperation);
+  const fetchOp = builder.findOperation(WhereInEagerOperation);
+
+  if (!joinOp || !fetchOp) {
+    return;
+  }
+
+  const joinNode = joinOp.expression.node;
+  const fetchNode = fetchOp.expression.node;
+  const isUsed = (node) => node.$allRecursive || node.$childNames.length > 0;
+
+  if (!isUsed(joinNode) || !isUsed(fetchNode)) {
+    return;
+  }
+
+  if (joinNode.$allRecursive || fetchNode.$allRecursive) {
+    throw new Error(
+      '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`,
+      );
+    }
+  }
+}
+
 function checkEager(builder) {
-  const eagerOp = builder.findOperation(EagerOperation);
+  const expr = getGraphExpression(builder);
 
-  if (!eagerOp) {
+  if (!expr) {
     return;
   }
 
-  const expr = eagerOp.expression;
   const allowedExpr = builder.allowedGraphExpression();
 
   if (expr.numChildren > 0 && allowedExpr && !allowedExpr.isSubExpression(expr)) {
@@ -1065,6 +1154,7 @@ function findQueryExecutorOperation(builder) {
 function beforeExecute(builder) {
   let promise = Promise.resolve();
 
+  checkRelatedQueryFor(builder);
   builder = addImplicitOperations(builder);
 
   // Resolve all before hooks before building and executing the query
@@ -1181,6 +1271,7 @@ function ensureJoinRelatedOperation(builder, joinOperation) {
 }
 
 function prebuildQuery(builder) {
+  checkRelatedQueryFor(builder);
   builder = addImplicitOperations(builder);
   builder = callOnBuildHooks(builder);
 
@@ -1193,6 +1284,17 @@ function prebuildQuery(builder) {
   }
 }
 
+function checkRelatedQueryFor(builder) {
+  // `for()` is only consumed by the operation factories installed by the static
+  // `relatedQuery()`. The default ones ignore it, which would silently make the
+  // query target all rows of the table.
+  if (builder.for() !== null && builder._findOperationFactory === findOperationFactory) {
+    throw new Error(
+      'for() can only be used with queries created using the static relatedQuery method',
+    );
+  }
+}
+
 function addImplicitOperations(builder) {
   if (builder.isFind()) {
     // If no write operations have been called at this point this query is a
@@ -1215,10 +1317,13 @@ function addFindOperation(builder) {
 }
 
 function moveEagerOperationToEnd(builder) {
-  const eagerOp = builder.findOperation(EagerOperation);
+  const eagerOps = findEagerOperations(builder);
 
   builder.clear(EagerOperation);
-  builder.addOperation(eagerOp);
+
+  for (const eagerOp of eagerOps) {
+    builder.addOperation(eagerOp);
+  }
 }
 
 function callOnBuildHooks(builder) {
@@ -1240,6 +1345,12 @@ function callOnBuildFuncs(builder, func) {
 function buildKnexQuery(builder, knexBuilder = builder.knex().queryBuilder()) {
   knexBuilder = builder.executeOnBuildKnex(knexBuilder);
 
+  const noneOperation = builder.findOperation(NoneOperation);
+
+  if (noneOperation) {
+    knexBuilder = noneOperation.onAfterBuildKnex(knexBuilder);
+  }
+
   const fromOperation = builder.findLastOperation(QueryBuilderBase.FromSelector);
 
   if (!builder.isPartial()) {

package/lib/queryBuilder/RelationExpression.js

@@ -229,6 +229,14 @@ function toString(node) {
   let childExpr = childNames.map((childName) => node[childName]).map(toString);
   let str = node.$relation;
 
+  if (node.$modify.length) {
+    str += `(${node.$modify.join(', ')})`;
+  }
+
+  if (node.$name !== node.$relation) {
+    str += ` as ${node.$name}`;
+  }
+
   if (node.$recursive) {
     if (isNumber(node.$recursive)) {
       str += '.^' + node.$recursive;
@@ -245,14 +253,6 @@ function toString(node) {
     childExpr = childExpr[0];
   }
 
-  if (node.$modify.length) {
-    str += `(${node.$modify.join(', ')})`;
-  }
-
-  if (node.$name !== node.$relation) {
-    str += ` as ${node.$name}`;
-  }
-
   if (childExpr) {
     if (str) {
       return `${str}.${childExpr}`;

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

@@ -91,6 +91,7 @@ function pruneGraphs() {
 
     if (!graphData.graphOptions.isInsertOnly()) {
       pruneDeletedBranches(graphData);
+      pruneUnrelatedOrDeletedBranches(graphData);
     }
 
     return graphData;
@@ -136,6 +137,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 +206,7 @@ function checkForErrors(builder) {
     checkForNotFoundErrors(graphData, builder);
     checkForUnallowedRelationErrors(graphData, builder);
     checkForUnallowedReferenceErrors(graphData, builder);
+    checkForRootUnrelateOrDeleteErrors(graphData, builder);
 
     if (graphData.graphOptions.isInsertOnly()) {
       checkForHasManyRelateErrors(graphData);
@@ -207,6 +222,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 +276,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;