objection 3.5.0 → 3.7.0

package/lib/queryBuilder/parsers/relationExpressionParser.pegjs

@@ -1,6 +1,6 @@
 {
   function assertDuplicateRelation(node, expr) {
-    if (expr.$name in node) {
+    if (Object.prototype.hasOwnProperty.call(node, expr.$name)) {
       console.warn(`Duplicate relation "${expr.$name}" in a relation expression. You should use "a.[b, c]" instead of "[a.b, a.c]". This will cause an error in objection 2.0`);
 
       // TODO: enable for v2.0.

package/lib/queryBuilder/transformations/WrapMysqlModifySubqueryTransformation.js

@@ -2,8 +2,6 @@
 
 const { QueryTransformation } = require('./QueryTransformation');
 const { isMySql } = require('../../utils/knexUtils');
-const { once } = require('../../utils/objectUtils');
-const getJoinBuilder = once(() => require('../JoinBuilder').JoinBuilder);
 
 /**
  * Mysql doesn't allow queries like this:
@@ -32,11 +30,10 @@ class WrapMysqlModifySubqueryTransformation extends QueryTransformation {
       return query;
     }
 
-    // This transformation should not apply to join builder, otherwise it causes:
-    // "TypeError: parentQuery.isUpdate is not a function"
-    const JoinBuilder = getJoinBuilder();
-    if (parentQuery instanceof JoinBuilder) {
-      return query;
+    // Subqueries in where groups and join clauses are converted with a
+    // partial builder as their parent. Use the query that they belong to.
+    while (parentQuery.isPartial() && parentQuery.parentQuery()) {
+      parentQuery = parentQuery.parentQuery();
     }
 
     // This transformation only applies to update and delete queries.

package/lib/relations/Relation.js

@@ -83,6 +83,12 @@ class Relation {
     return false;
   }
 
+  // Whether owner models may legitimately lack the owner join property at
+  // `index`, so that it isn't reported as missing (#132).
+  isOptionalOwnerProp(_index) {
+    return false;
+  }
+
   clone() {
     const relation = new this.constructor(this.name, this.ownerModelClass);
 
@@ -97,6 +103,7 @@ class Relation {
     relation.joinTableRelatedProp = this.joinTableRelatedProp;
     relation.joinTableBeforeInsert = this.joinTableBeforeInsert;
     relation.joinTableExtras = this.joinTableExtras;
+    relation.joinTableModify = this.joinTableModify;
 
     return relation;
   }

package/lib/relations/RelationFindOperation.js

@@ -12,7 +12,6 @@ class RelationFindOperation extends FindOperation {
     this.alwaysReturnArray = false;
     this.assignResultToOwner = true;
     this.relationProperty = opt.relationProperty || this.relation.name;
-    this.omitProps = [];
     this.alias = null;
   }
 
@@ -21,10 +20,9 @@ class RelationFindOperation extends FindOperation {
     this.relation.findQuery(builder, this.owner);
 
     if (this.owner.isModels) {
-      this.warnOnMissingOwnerProps();
+      this.warnOnInvalidOwnerProps();
 
       if (this.assignResultToOwner) {
-        this.warnOnArrayOwnerProps();
         this.selectMissingJoinColumns(builder);
       }
     }
@@ -70,11 +68,6 @@ class RelationFindOperation extends FindOperation {
 
   onAfter3(builder, related) {
     const isOneToOne = this.relation.isOneToOne();
-    const intOpt = builder.internalOptions();
-
-    if (!intOpt.keepImplicitJoinProps) {
-      this.omitImplicitJoinProps(related);
-    }
 
     if (!this.alwaysReturnArray && isOneToOne && related.length <= 1) {
       related = related[0] || undefined;
@@ -83,14 +76,27 @@ class RelationFindOperation extends FindOperation {
     return super.onAfter3(builder, related);
   }
 
+  warnOnInvalidOwnerProps() {
+    this.warnOnMissingOwnerProps();
+
+    if (this.assignResultToOwner) {
+      this.warnOnArrayOwnerProps();
+    }
+  }
+
   // Owner models without the join columns, e.g. loaded with a partial
   // `select()`, silently get no related models (#1832). Only `undefined`
-  // is reported, as `null` is a legit value for a missing relation.
+  // is reported, as `null` is a legit value for a missing relation, and
+  // owner props that may legitimately be unset are skipped (#132).
   // TODO: Consider throwing an error instead in objection 4.0.
   warnOnMissingOwnerProps() {
     const { ownerProp } = this.relation;
 
     for (let c = 0, lc = ownerProp.size; c < lc; ++c) {
+      if (this.relation.isOptionalOwnerProp(c)) {
+        continue;
+      }
+
       if (this.owner.modelArray.some((owner) => ownerProp.getProp(owner, c) === undefined)) {
         deprecate(
           `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
@@ -106,7 +112,11 @@ class RelationFindOperation extends FindOperation {
   // assigned to their owners, so all owners silently get no related models
   // (#2667). `$relatedQuery()` without assigning the results isn't affected.
   warnOnArrayOwnerProps() {
-    const { ownerProp } = this.relation;
+    const { ownerProp, joinTable } = this.relation;
+    // Relations through a join table already are the alternative to arrays.
+    const advice = joinTable
+      ? 'Map the relation from a column that holds a single key instead.'
+      : 'Use a ManyToManyRelation through a join table instead.';
 
     for (let c = 0, lc = ownerProp.size; c < lc; ++c) {
       if (this.owner.modelArray.some((owner) => Array.isArray(ownerProp.getProp(owner, c)))) {
@@ -114,7 +124,7 @@ class RelationFindOperation extends FindOperation {
           `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
             `the join property "${ownerProp.propDescription(c)}" of some owner models holds ` +
             'an array, which is not supported, so no related models are found for them. ' +
-            'Use a ManyToManyRelation through a join table instead.',
+            advice,
         );
       }
     }
@@ -149,7 +159,7 @@ class RelationFindOperation extends FindOperation {
       const col = relatedProp.cols[c];
 
       if (!builder.hasSelectionAs(fullCol, col) && addedSelects.indexOf(fullCol) === -1) {
-        this.omitProps.push(prop);
+        this.omitFromResult(builder, prop);
         addedSelects.push(fullCol);
       }
     }
@@ -165,34 +175,12 @@ class RelationFindOperation extends FindOperation {
     }
   }
 
-  omitImplicitJoinProps(related) {
-    const relatedModelClass = this.relation.relatedModelClass;
-
-    if (!this.omitProps.length || !related) {
-      return related;
-    }
-
-    if (!Array.isArray(related)) {
-      return this.omitImplicitJoinPropsFromOne(relatedModelClass, related);
-    }
-
-    if (!related.length) {
-      return related;
-    }
-
-    for (let i = 0, l = related.length; i < l; ++i) {
-      this.omitImplicitJoinPropsFromOne(relatedModelClass, related[i]);
-    }
-
-    return related;
-  }
-
-  omitImplicitJoinPropsFromOne(relatedModelClass, model) {
-    for (let c = 0, lc = this.omitProps.length; c < lc; ++c) {
-      relatedModelClass.omitImpl(model, this.omitProps[c]);
+  // Omits a property that was selected only to assign the related models to
+  // their owners from the result, before any `runAfter()` hooks are called.
+  omitFromResult(builder, prop) {
+    if (!builder.internalOptions().keepImplicitJoinProps) {
+      builder.addInternalSelection(prop);
     }
-
-    return model;
   }
 
   clone() {
@@ -201,7 +189,6 @@ class RelationFindOperation extends FindOperation {
     clone.alwaysReturnArray = this.alwaysReturnArray;
     clone.assignResultToOwner = this.assignResultToOwner;
     clone.relationProperty = this.relationProperty;
-    clone.omitProps = this.omitProps.slice();
     clone.alias = this.alias;
 
     return clone;

package/lib/relations/belongsToOne/BelongsToOneDeleteOperation.js

@@ -3,8 +3,10 @@
 const { RelationDeleteOperation } = require('../RelationDeleteOperation');
 
 class BelongsToOneDeleteOperation extends RelationDeleteOperation {
-  onAfter1(_, result) {
-    if (this.owner.isModels) {
+  onAfter1(builder, result) {
+    // A query resolved without executing it, e.g. with `none()`, deleted
+    // nothing, so the owners are left untouched.
+    if (this.owner.isModels && !builder.isExplicitlyResolvedOrRejected()) {
       const ownerProp = this.relation.ownerProp;
 
       for (const owner of this.owner.modelArray) {

package/lib/relations/belongsToOne/BelongsToOneRelation.js

@@ -11,6 +11,15 @@ class BelongsToOneRelation extends Relation {
     return true;
   }
 
+  // The foreign key is unset when no related model was ever assigned, e.g. on
+  // models returned by `insert()` or created with `fromJson()`, where no
+  // related model is the right result. This can't be told apart from a
+  // foreign key left out of a partial `select()`. Foreign keys that are part
+  // of the id are always expected to be set (#132).
+  isOptionalOwnerProp(index) {
+    return !this.ownerModelClass.getIdPropertyArray().includes(this.ownerProp.props[index]);
+  }
+
   insert(_, owner) {
     return new BelongsToOneInsertOperation('insert', {
       relation: this,

package/lib/relations/manyToMany/ManyToManyModifyMixin.js

@@ -16,18 +16,27 @@ const ManyToManyModifyMixin = (Operation) => {
     constructor(...args) {
       super(...args);
       this.modifyFilterSubquery = null;
+      this.joinRowFilterSubquery = null;
+      this.skipRelationFilter = false;
     }
 
+    // Unrelate doesn't execute the main query, and updates of rows that are
+    // known to be related, like the patches of `upsertGraph()`, keep their own
+    // filters (#135).
     get modifyMainQuery() {
-      return true;
+      return !this.modifiesJoinTableOnly && !this.skipRelationFilter;
     }
 
     // At this point `builder` should only have the user's own wheres and joins. There can
     // be other operations (like orderBy) too, but those are meaningless with modify operations.
     onBuild(builder) {
-      this.modifyFilterSubquery = this.createModifyFilterSubquery(builder);
+      if (this.modifiesJoinTable && !this.skipRelationFilter) {
+        this.joinRowFilterSubquery = this.createJoinRowFilterSubquery(builder);
+      }
 
       if (this.modifyMainQuery) {
+        this.modifyFilterSubquery = this.createModifyFilterSubquery(builder);
+
         // We can now remove the where and join statements from the main query.
         this.removeFiltersFromMainQuery(builder);
 
@@ -71,22 +80,39 @@ const ManyToManyModifyMixin = (Operation) => {
       return builder.whereInComposite(idRefs, subquery);
     }
 
-    // Modifies the join rows of all related rows that match the filters. If the filters
-    // reference join table columns, this also modifies join rows that don't match them
-    // but share a related row with one that does (#1853). The dialect specific mixins
-    // override this to only modify the join rows that match the filters themselves.
+    // Only modifies the join rows that match the filters (#1853).
     applyModifyFilterForJoinTable(builder) {
       const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
-      const joinTableRelatedRefs = this.relation.joinTableRelatedProp.refs(builder);
-
-      const relatedRefs = this.relation.relatedProp.refs(builder);
       const ownerValues = this.owner.getProps(this.relation);
 
-      const subquery = this.modifyFilterSubquery.clone().select(relatedRefs);
-
       return builder
-        .whereInComposite(joinTableRelatedRefs, subquery)
-        .whereInComposite(joinTableOwnerRefs, ownerValues);
+        .whereInComposite(joinTableOwnerRefs, ownerValues)
+        .whereExists(this.joinRowFilterSubquery);
+    }
+
+    // Selects the related rows of a join row that match the filters. The join
+    // table isn't joined, so that the filters on its columns apply to the join
+    // row of the outer query.
+    createJoinRowFilterSubquery(builder) {
+      const { relation } = this;
+      const builderClass = builder.constructor;
+      const subquery = relation.relatedModelClass.query().childQueryOf(builder);
+      const joinTableRef = builder.tableRefFor(relation.joinTable);
+
+      addWhereGroup(subquery, () => {
+        relation.relatedProp.forEach((i) => {
+          const relatedRef = relation.relatedProp.ref(subquery, i);
+          const joinTableRelatedRef = relation.joinTableRelatedProp.ref(subquery, i);
+
+          subquery.where(relatedRef, joinTableRelatedRef.table(joinTableRef));
+        });
+      });
+
+      return relation
+        .applyModify(subquery)
+        .copyFrom(builder, builderClass.WhereSelector)
+        .copyFrom(builder, builderClass.JoinSelector)
+        .select(1);
     }
 
     toFindOperation() {
@@ -108,6 +134,8 @@ const ManyToManyModifyMixin = (Operation) => {
     clone() {
       const clone = super.clone();
       clone.modifyFilterSubquery = this.modifyFilterSubquery;
+      clone.joinRowFilterSubquery = this.joinRowFilterSubquery;
+      clone.skipRelationFilter = this.skipRelationFilter;
       return clone;
     }
   };

package/lib/relations/manyToMany/ManyToManyMySqlModifyMixin.js

@@ -1,66 +1,55 @@
 'use strict';
 
 const { ManyToManyModifyMixin } = require('./ManyToManyModifyMixin');
-const { isObject } = require('../../utils/objectUtils');
 
 // We need to override this mixin for mysql because mysql doesn't allow a
-// statement that modifies the join table to read the related table in a
-// subquery, if a trigger on the join table modifies the related table:
+// statement that modifies the join table to read the join table in a
+// subquery (ER_UPDATE_TABLE_USED), e.g. through the user's filters, or the
+// related table if a trigger on the join table modifies it
+// (ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG).
 //
-//   ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG
-//
-// So the join rows that match the filters are fetched in a separate query
-// before the main query, which then only modifies these rows (#1853). Mysql
-// has no row ids and the join table's primary key isn't known, so the rows are
-// identified by the values of all their columns.
+// So the owner and related ids of the join rows that match the filters are
+// fetched in a separate query before the statement, which then only modifies
+// the join rows with these ids. Unlike the subquery, these can't tell apart
+// join rows that only differ in their other columns (#1853).
 //
 // https://stackoverflow.com/a/2314264/3729316
 const ManyToManyMySqlModifyMixin = (Operation) => {
   return class extends ManyToManyModifyMixin(Operation) {
     applyModifyFilterForJoinTable(builder) {
-      const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
-      const tableRef = builder.tableRefFor(this.relation.getJoinModelClass(builder));
-
+      const { joinTableOwnerProp, joinTableRelatedProp } = this.relation;
       const ownerValues = this.owner.getProps(this.relation);
-      const subquery = this.modifyFilterSubquery.clone().select(`${tableRef}.*`);
+      const subquery = this.joinRowFilterSubquery;
 
       return builder
+        .whereInComposite(joinTableOwnerProp.refs(builder), ownerValues)
         .runBefore(async (_, builder) => {
+          const idRefs = [
+            ...joinTableOwnerProp.refs(builder),
+            ...joinTableRelatedProp.refs(builder),
+          ];
+
           // Fetch the raw rows: no models, so that no hooks run for them.
-          const rows = await subquery.toKnexQuery();
+          const rows = await builder
+            .modelClass()
+            .query()
+            .childQueryOf(builder)
+            .copyFrom(builder, builder.constructor.WhereSelector)
+            .whereExists(subquery)
+            .select(idRefs)
+            .toKnexQuery();
 
-          if (rows.length) {
-            builder.where((builder) => {
-              for (const row of rows) {
-                builder.orWhere((builder) => {
-                  for (const [column, value] of Object.entries(row)) {
-                    builder.whereRaw('?? <=> ?', [
-                      `${tableRef}.${column}`,
-                      toComparableValue(value),
-                    ]);
-                  }
-                });
-              }
-            });
-          } else {
-            // Still execute the query so that it returns the expected
-            // result for the dialect, e.g. a count of 0 for deletes.
-            builder.where(false);
-          }
-        })
-        .whereInComposite(joinTableOwnerRefs, ownerValues);
+          // An empty list still executes the query, so that it returns the
+          // expected result for the dialect, e.g. a count of 0 for deletes.
+          builder.whereInComposite(
+            idRefs,
+            rows.map((row) => Object.values(row)),
+          );
+        });
     }
   };
 };
 
-// Some drivers return JSON columns parsed. Mysql parses strings that are
-// compared to JSON columns, so the stringified value matches them again.
-function toComparableValue(value) {
-  return isObject(value) && !(value instanceof Date) && !Buffer.isBuffer(value)
-    ? JSON.stringify(value)
-    : value;
-}
-
 module.exports = {
   ManyToManyMySqlModifyMixin,
 };

package/lib/relations/manyToMany/ManyToManyRelation.js

@@ -4,7 +4,7 @@ const { getModel } = require('../../model/getModel');
 const { Relation } = require('../Relation');
 const { RelationProperty } = require('../RelationProperty');
 
-const { isSqlite, isMySql, isPostgres } = require('../../utils/knexUtils');
+const { isSqlite, isMySql } = require('../../utils/knexUtils');
 const { inheritModel } = require('../../model/inheritModel');
 const { resolveModel } = require('../../utils/resolveModel');
 const { mapAfterAllReturn } = require('../../utils/promiseUtils');
@@ -21,14 +21,10 @@ const {
   ManyToManyUnrelateSqliteOperation,
 } = require('./unrelate/ManyToManyUnrelateSqliteOperation');
 const { ManyToManyUnrelateMySqlOperation } = require('./unrelate/ManyToManyUnrelateMySqlOperation');
-const {
-  ManyToManyUnrelatePostgresOperation,
-} = require('./unrelate/ManyToManyUnrelatePostgresOperation');
 
 const { ManyToManyUpdateOperation } = require('./update/ManyToManyUpdateOperation');
 const { ManyToManyUpdateSqliteOperation } = require('./update/ManyToManyUpdateSqliteOperation');
 const { ManyToManyUpdateMySqlOperation } = require('./update/ManyToManyUpdateMySqlOperation');
-const { ManyToManyUpdatePostgresOperation } = require('./update/ManyToManyUpdatePostgresOperation');
 
 const { ManyToManyDeleteOperation } = require('./delete/ManyToManyDeleteOperation');
 const { ManyToManyDeleteSqliteOperation } = require('./delete/ManyToManyDeleteSqliteOperation');
@@ -93,7 +89,8 @@ class ManyToManyRelation extends Relation {
 
   // The modify operations can't tell the join rows apart from the related rows
   // if the join table is also the related table, so they would modify the
-  // wrong rows (#1803).
+  // wrong rows (#1803). Inserting and relating would insert the join rows as
+  // new related rows (#133).
   assertCanModifyJoinTable(builder, operationName) {
     if (this.isJoinTableRelatedTable(builder)) {
       throw this.createError(
@@ -188,7 +185,9 @@ class ManyToManyRelation extends Relation {
     });
   }
 
-  insert(_, owner) {
+  insert(builder, owner) {
+    this.assertCanModifyJoinTable(builder, 'insert');
+
     return new ManyToManyInsertOperation('insert', {
       relation: this,
       owner,
@@ -218,6 +217,8 @@ class ManyToManyRelation extends Relation {
   }
 
   relate(builder, owner) {
+    this.assertCanModifyJoinTable(builder, 'relate');
+
     return new ManyToManyRelateOperation('relate', {
       relation: this,
       owner,
@@ -498,26 +499,25 @@ function parseBeforeInsert(ctx) {
 }
 
 function finalizeJoinModelClass(ctx) {
-  if (ctx.joinTableModelClass.getIdColumn() === null) {
-    // We cannot know if the join table has a primary key. Therefore we set some
-    // known column as the idColumn so that inserts will work.
+  // We cannot know if the join table has a primary key. Therefore we set some
+  // known column as the idColumn of the join model class that we created. A
+  // `through.modelClass` is left untouched, even if it has no `idColumn` (#2305).
+  if (!ctx.mapping.join.through.modelClass) {
     ctx.joinTableModelClass.idColumn = ctx.joinTableRelatedProp.cols;
   }
 
   return ctx;
 }
 
-// The modify operations need dialect specific code to only modify the join
-// rows that match the filters, see the `ManyToMany*ModifyMixin` classes.
-function getOperationClass(builder, { sqlite, mysql, postgres, other }) {
+// The modify operations need dialect specific code on sqlite and mysql, see
+// the `ManyToMany*ModifyMixin` classes.
+function getOperationClass(builder, { sqlite, mysql, other }) {
   const knex = builder.knex();
 
   if (isSqlite(knex)) {
     return sqlite;
   } else if (isMySql(knex)) {
     return mysql;
-  } else if (isPostgres(knex)) {
-    return postgres;
   } else {
     return other;
   }
@@ -527,7 +527,6 @@ function getUpdateOperationClass(builder) {
   return getOperationClass(builder, {
     sqlite: ManyToManyUpdateSqliteOperation,
     mysql: ManyToManyUpdateMySqlOperation,
-    postgres: ManyToManyUpdatePostgresOperation,
     other: ManyToManyUpdateOperation,
   });
 }
@@ -536,7 +535,6 @@ function getUnrelateOperationClass(builder) {
   return getOperationClass(builder, {
     sqlite: ManyToManyUnrelateSqliteOperation,
     mysql: ManyToManyUnrelateMySqlOperation,
-    postgres: ManyToManyUnrelatePostgresOperation,
     other: ManyToManyUnrelateOperation,
   });
 }
@@ -546,7 +544,6 @@ function getDeleteOperationClass(builder) {
   return getOperationClass(builder, {
     sqlite: ManyToManyDeleteSqliteOperation,
     mysql: ManyToManyDeleteOperation,
-    postgres: ManyToManyDeleteOperation,
     other: ManyToManyDeleteOperation,
   });
 }

package/lib/relations/manyToMany/ManyToManySqliteModifyMixin.js

@@ -15,19 +15,6 @@ const ManyToManySqliteModifyMixin = (Operation) => {
 
       return builder.whereInComposite(rowIdRef, subquery);
     }
-
-    applyModifyFilterForJoinTable(builder) {
-      const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
-      const tableRef = builder.tableRefFor(this.relation.getJoinModelClass(builder));
-      const rowIdRef = `${tableRef}.${SQLITE_BUILTIN_ROW_ID}`;
-
-      const ownerValues = this.owner.getProps(this.relation);
-      const subquery = this.modifyFilterSubquery.clone().select(rowIdRef);
-
-      return builder
-        .whereInComposite(rowIdRef, subquery)
-        .whereInComposite(joinTableOwnerRefs, ownerValues);
-    }
   };
 };
 

package/lib/relations/manyToMany/find/ManyToManyFindOperation.js

@@ -36,7 +36,7 @@ class ManyToManyFindOperation extends RelationFindOperation {
     }
 
     if (this.owner.isModels) {
-      this.warnOnMissingOwnerProps();
+      this.warnOnInvalidOwnerProps();
 
       if (this.assignResultToOwner) {
         this.selectMissingJoinColumns(builder);
@@ -122,8 +122,7 @@ class ManyToManyFindOperation extends RelationFindOperation {
       const propName = relatedModelClass.columnNameToPropertyName(this.ownerJoinColumnAlias[i]);
 
       builder.select(joinTableOwnerRef.as(this.ownerJoinColumnAlias[i]));
-      // Mark them to be omitted later.
-      this.omitProps.push(propName);
+      this.omitFromResult(builder, propName);
     });
 
     super.selectMissingJoinColumns(builder);

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateMySqlOperation.js

@@ -5,11 +5,7 @@ const { ManyToManyMySqlModifyMixin } = require('../ManyToManyMySqlModifyMixin');
 
 class ManyToManyUnrelateMySqlOperation extends ManyToManyMySqlModifyMixin(
   ManyToManyUnrelateOperationBase,
-) {
-  get modifyMainQuery() {
-    return false;
-  }
-}
+) {}
 
 module.exports = {
   ManyToManyUnrelateMySqlOperation,

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateOperation.js

@@ -3,11 +3,7 @@
 const { ManyToManyUnrelateOperationBase } = require('./ManyToManyUnrelateOperationBase');
 const { ManyToManyModifyMixin } = require('../ManyToManyModifyMixin');
 
-class ManyToManyUnrelateOperation extends ManyToManyModifyMixin(ManyToManyUnrelateOperationBase) {
-  get modifyMainQuery() {
-    return false;
-  }
-}
+class ManyToManyUnrelateOperation extends ManyToManyModifyMixin(ManyToManyUnrelateOperationBase) {}
 
 module.exports = {
   ManyToManyUnrelateOperation,

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateOperationBase.js

@@ -4,6 +4,15 @@ const { UnrelateOperation } = require('../../../queryBuilder/operations/Unrelate
 const { addWhereGroup } = require('../../../queryBuilder/whereGroups');
 
 class ManyToManyUnrelateOperationBase extends UnrelateOperation {
+  get modifiesJoinTable() {
+    return true;
+  }
+
+  // The main query is replaced by the query that `queryExecutor()` returns.
+  get modifiesJoinTableOnly() {
+    return true;
+  }
+
   queryExecutor(builder) {
     const unrelateQuery = this.relation
       .getJoinModelClass(builder.knex())

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateSqliteOperation.js

@@ -5,11 +5,7 @@ const { ManyToManySqliteModifyMixin } = require('../ManyToManySqliteModifyMixin'
 
 class ManyToManyUnrelateSqliteOperation extends ManyToManySqliteModifyMixin(
   ManyToManyUnrelateOperationBase,
-) {
-  get modifyMainQuery() {
-    return false;
-  }
-}
+) {}
 
 module.exports = {
   ManyToManyUnrelateSqliteOperation,