objection 3.7.0 → 3.8.0

package/lib/queryBuilder/operations/UpdateOperation.js

@@ -1,8 +1,11 @@
 'use strict';
 
 const { ref } = require('../../queryBuilder/ReferenceBuilder');
-const { isEmpty } = require('../../utils/objectUtils');
-const { toPostgresJsonPathLiteral } = require('../../utils/parseFieldExpression');
+const { isEmpty, isObject } = require('../../utils/objectUtils');
+const {
+  isFieldExpressionKey,
+  toPostgresJsonPathLiteral,
+} = require('../../utils/parseFieldExpression');
 const { isKnexRaw, isKnexQueryBuilder } = require('../../utils/knexUtils');
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 const { warnIfNotPostgres } = require('./jsonApi/postgresJsonApi');
@@ -107,12 +110,13 @@ async function callStaticAfterUpdate(builder, result) {
 
 function convertFieldExpressionsToRaw(builder, model, json) {
   const knex = builder.knex();
+  const declaredColumns = getDeclaredColumns(builder.modelClass());
   const convertedJson = {};
 
   for (const key of Object.keys(json)) {
     let val = json[key];
 
-    if (key.indexOf(':') > -1) {
+    if (isFieldExpressionKey(key, declaredColumns)) {
       // 'col:attr' : ref('other:lol') is transformed to
       // "col" : raw(`jsonb_set("col", '{attr}', to_jsonb("other"#>'{lol}'), true)`)
       warnIfNotPostgres(knex);
@@ -141,6 +145,28 @@ function convertFieldExpressionsToRaw(builder, model, json) {
   return convertedJson;
 }
 
+const declaredColumnsByModelClass = new WeakMap();
+
+// The keys of `json` are column names, so map the properties with a ':' that the
+// schema declares to their columns, once per model class. Properties that only
+// the schema returned by `$beforeValidate()` declares aren't known here.
+function getDeclaredColumns(modelClass) {
+  let declaredColumns = declaredColumnsByModelClass.get(modelClass);
+
+  if (!declaredColumns) {
+    const jsonSchema = modelClass.getJsonSchema();
+    const properties = jsonSchema && jsonSchema.properties;
+    declaredColumns = Object.fromEntries(
+      (isObject(properties) ? Object.keys(properties) : [])
+        .filter((key) => key.includes(':'))
+        .map((key) => [modelClass.propertyNameToColumnName(key), true]),
+    );
+    declaredColumnsByModelClass.set(modelClass, declaredColumns);
+  }
+
+  return declaredColumns;
+}
+
 module.exports = {
   UpdateOperation,
   convertFieldExpressionsToRaw,

package/lib/queryBuilder/operations/WhereGroupOperation.js

@@ -3,11 +3,11 @@
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 
 // Builds a set of where operations inside a single knex `where(callback)`
-// group, i.e. wraps them in parentheses. See `wrapWhereGroups`.
+// group, i.e. wraps them in parentheses. See `getWhereGroupOperations()`.
 class WhereGroupOperation extends QueryBuilderOperation {
   constructor(name, opt) {
     super(name, opt);
-    this.operations = [];
+    this.operations = opt.operations;
   }
 
   onBuildKnex(knexBuilder, builder) {
@@ -28,12 +28,6 @@ class WhereGroupOperation extends QueryBuilderOperation {
       }
     });
   }
-
-  clone() {
-    const clone = super.clone();
-    clone.operations = this.operations.map((op) => op.clone());
-    return clone;
-  }
 }
 
 module.exports = {

package/lib/queryBuilder/operations/eager/JoinEagerOperation.js

@@ -20,6 +20,11 @@ class JoinEagerOperation extends EagerOperation {
   }
 
   onBefore3(builder) {
+    return this.fetchTableMetadata(builder);
+  }
+
+  // Also called by `resultSize()`, which builds the query without executing it.
+  fetchTableMetadata(builder) {
     return this.joiner
       .setExpression(this.buildFinalExpression(builder))
       .setModifiers(this.buildFinalModifiers(builder))

package/lib/queryBuilder/operations/eager/WhereInEagerOperation.js

@@ -3,7 +3,8 @@
 const promiseUtils = require('../../../utils/promiseUtils');
 
 const { EagerOperation } = require('./EagerOperation');
-const { isMsSql, isOracle, isSqlite } = require('../../../utils/knexUtils');
+const { LimitPerParentOperation } = require('../LimitPerParentOperation');
+const { isMsSql, isOracle, isSqlite, hasWindowFunctions } = require('../../../utils/knexUtils');
 const { isObject, asArray, flatten, chunk } = require('../../../utils/objectUtils');
 const { ValidationErrorType } = require('../../../model/ValidationError');
 const { createModifier } = require('../../../utils/createModifier');
@@ -85,7 +86,9 @@ class WhereInEagerOperation extends EagerOperation {
 
   async fetchRelation(builder, models, relation, expr) {
     const modelClass = builder.resultModelClass();
-    const batchSize = this.batchSize(builder.knex());
+    const batchSize = this.shouldFetchPerParent(builder, models, relation, expr)
+      ? 1
+      : this.batchSize(builder.knex());
     const modelBatches = chunk(models, batchSize);
 
     const result = await promiseUtils.map(
@@ -136,9 +139,32 @@ class WhereInEagerOperation extends EagerOperation {
       }
     }
 
+    if (this.graphOptions.limitPerParent) {
+      queryBuilder.addOperation(
+        new LimitPerParentOperation('limitPerParent', { findOperation }),
+        [],
+      );
+    }
+
     return queryBuilder;
   }
 
+  // Without window functions, the related models can only be limited per
+  // parent with one query per parent.
+  shouldFetchPerParent(builder, models, relation, expr) {
+    if (this.graphOptions.limitPerParent && !hasWindowFunctions(builder.knex())) {
+      // Build the query to find its limits, also those of the relation's
+      // `modify` and of `onBuildKnex()` hooks. This runs its modifiers and
+      // build hooks once more than for fetching the relation.
+      const query = this.fetchRelationBatch(builder, models, relation, expr);
+      query.executeOnBuild();
+      const knexQuery = query.executeOnBuildKnex(query.knex().queryBuilder());
+      return !!query.findOperation(LimitPerParentOperation)?.getRange(knexQuery, query);
+    } else {
+      return false;
+    }
+  }
+
   shouldSkipFetched(models, relation, expr) {
     if (!this.graphOptions.skipFetched) {
       return false;

package/lib/queryBuilder/operations/jsonApi/postgresJsonApi.js

@@ -3,7 +3,7 @@
 const parser = require('../../../utils/parseFieldExpression');
 const { asArray, isObject, isString } = require('../../../utils/objectUtils');
 const { isKnexRaw, isKnexQueryBuilder, isPostgres } = require('../../../utils/knexUtils');
-const { deprecate } = require('../../../utils/deprecate');
+const { warnOnce } = require('../../../utils/warnings');
 
 /**
  * @typedef {String} FieldExpression
@@ -50,7 +50,7 @@ const { deprecate } = require('../../../utils/deprecate');
 // TODO: Consider throwing an error instead in objection 4.0.
 function warnIfNotPostgres(knex) {
   if (!isPostgres(knex)) {
-    deprecate(
+    warnOnce(
       'JSON field expressions and the whereJson*() methods of objection are only supported ' +
         'on PostgreSQL. Use the JSON methods of knex like whereJsonPath() or jsonExtract() ' +
         'with other databases.',

package/lib/queryBuilder/operations/select/SelectOperation.js

@@ -25,6 +25,8 @@ class SelectOperation extends ObjectionToKnexConvertingOperation {
     // The selections that aggregates select, by their aliases. `null` for
     // non-aggregate operations.
     this.aggregateSelections = AGGREGATE_METHODS.has(name) ? [] : null;
+    // `distinctOn()` makes the rows distinct on its columns, it doesn't select them.
+    this.isDistinctOn = name === 'distinctOn';
   }
 
   onAdd(builder, args) {
@@ -38,11 +40,13 @@ class SelectOperation extends ObjectionToKnexConvertingOperation {
 
     const ret = super.onAdd(builder, selections);
 
-    for (const selection of selections) {
-      const selectionInstance = Selection.create(selection);
+    if (!this.isDistinctOn) {
+      for (const selection of selections) {
+        const selectionInstance = Selection.create(selection);
 
-      if (selectionInstance) {
-        this.selections.push(selectionInstance);
+        if (selectionInstance) {
+          this.selections.push(selectionInstance);
+        }
       }
     }
 

package/lib/queryBuilder/operations/select/Selection.js

@@ -63,11 +63,11 @@ class Selection {
     if (selectionInBuilder.column === '*') {
       if (selectionInBuilder.table) {
         if (selectionToTest.column === '*') {
-          return isSameTable(builder, selectionToTest.table, selectionInBuilder.table);
+          return isSameIdentifier(builder, selectionToTest.table, selectionInBuilder.table);
         } else {
           return (
             selectionToTest.table === null ||
-            isSameTable(builder, selectionToTest.table, selectionInBuilder.table)
+            isSameIdentifier(builder, selectionToTest.table, selectionInBuilder.table)
           );
         }
       } else {
@@ -80,9 +80,9 @@ class Selection {
         return false;
       } else {
         return (
-          selectionToTest.column === selectionInBuilder.column &&
+          isSameIdentifier(builder, selectionToTest.column, selectionInBuilder.column) &&
           (selectionToTest.table === null ||
-            isSameTable(builder, selectionToTest.table, selectionInBuilderTable))
+            isSameIdentifier(builder, selectionToTest.table, selectionInBuilderTable))
         );
       }
     }
@@ -97,30 +97,29 @@ Object.defineProperties(Selection.prototype, {
   },
 });
 
-// Table names that only differ in a way that knex's `wrapIdentifier` mapping
-// (for example `knexSnakeCaseMappers()`) cancels out refer to the same table:
+// Identifiers that only differ in a way that knex's `wrapIdentifier` mapping
+// (for example `knexSnakeCaseMappers()`) cancels out are the same identifier:
 // `dataExtension` and `data_extension` both end up as `data_extension`.
-function isSameTable(builder, table1, table2) {
-  if (table1 === table2) {
+function isSameIdentifier(builder, identifier1, identifier2) {
+  if (identifier1 === identifier2) {
     return true;
-  } else if (!table1 || !table2) {
+  } else if (!identifier1 || !identifier2) {
     return false;
+  } else {
+    return mapIdentifier(builder, identifier1) === mapIdentifier(builder, identifier2);
   }
+}
 
+function mapIdentifier(builder, identifier) {
   const knex = builder.unsafeKnex();
   const wrapIdentifier = knex && knex.client && knex.client.config.wrapIdentifier;
 
-  if (!wrapIdentifier) {
-    return false;
-  }
-
-  const mapTable = (table) =>
-    table
-      .split('.')
-      .map((part) => wrapIdentifier(part, identity))
-      .join('.');
-
-  return mapTable(table1) === mapTable(table2);
+  return wrapIdentifier
+    ? identifier
+        .split('.')
+        .map((part) => wrapIdentifier(part, identity))
+        .join('.')
+    : identifier;
 }
 
 function identity(value) {
@@ -211,4 +210,6 @@ function createSelectionFromString(selection) {
 
 module.exports = {
   Selection,
+  isSameIdentifier,
+  mapIdentifier,
 };

package/lib/queryBuilder/parsers/relationExpressionParser.js

@@ -4,6 +4,8 @@
 
 'use strict';
 
+const { warnOnce } = require('../../utils/warnings');
+
 class peg$SyntaxError extends SyntaxError {
   constructor(message, expected, found, location) {
     super(message);
@@ -944,11 +946,11 @@ function peg$parse(input, options) {
 
   function assertDuplicateRelation(node, expr) {
     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`,
+      warnOnce(
+        `Duplicate relation "${expr.$name}" in a relation expression, only the last one is used. Use "a.[b, c]" instead of "[a.b, a.c]". This will throw an error in objection 4.0.`,
       );
 
-      // TODO: enable for v2.0.
+      // Throws in objection 4.0, see ditojs/objection#53.
       // const err = new Error();
       // err.duplicateRelationName = expr.$name;
       // throw err;

package/lib/queryBuilder/parsers/relationExpressionParser.pegjs

@@ -1,9 +1,13 @@
+{{
+  const { warnOnce } = require('../../utils/warnings');
+}}
+
 {
   function assertDuplicateRelation(node, expr) {
     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`);
+      warnOnce(`Duplicate relation "${expr.$name}" in a relation expression, only the last one is used. Use "a.[b, c]" instead of "[a.b, a.c]". This will throw an error in objection 4.0.`);
 
-      // TODO: enable for v2.0.
+      // Throws in objection 4.0, see ditojs/objection#53.
       // const err = new Error();
       // err.duplicateRelationName = expr.$name;
       // throw err;

package/lib/queryBuilder/whereGroups.js

@@ -5,21 +5,23 @@ const { isObject, isFunction } = require('../utils/objectUtils');
 const { isKnexRaw } = require('../utils/knexUtils');
 
 // Where operations of a query can come from different sources: the user, a
-// relation's owner condition, the relation's `modify`/`filter` and so on. Each
-// source forms its own "where group". All operations the user adds belong to
-// the default group, and `addWhereGroup` assigns the operations added inside
-// its callback to a new, separate group.
+// relation's owner condition, the relation's `modify`/`filter`, the id
+// condition of `patchAndFetchById()` and `$query()` and so on. Each source
+// forms its own "where group". All operations the user adds belong to the
+// default group, and `addWhereGroup` assigns the operations added inside its
+// callback to a new, separate group.
 //
 // Knex simply joins all where clauses with their `and` or `or` boolean. Since
 // `and` binds tighter than `or`, a user's `orWhere` would escape the relation's
 // owner condition: `where "ownerId" in (1) and a or b`. This would find, update
 // and delete rows of other owners too. See issues #2191 and #1909.
 //
-// To prevent this, `wrapWhereGroups` is called after all `onBuild` hooks have
-// run. If a query contains more than one where group, every group that may
-// contain an `or` at its top level is wrapped in parentheses, so that the
-// groups are always ANDed together: `where "ownerId" in (1) and (a or b)`.
-// Groups without an `or` are left alone so that their SQL doesn't change.
+// To prevent this, the where groups are computed when the knex query is built.
+// If a query contains more than one where group, every group that may contain
+// an `or` at its top level is wrapped in parentheses, so that the groups are
+// always ANDed together: `where "ownerId" in (1) and (a or b)`. Groups without
+// an `or` are left alone so that their SQL doesn't change. The operations
+// aren't moved, so that a built query can be cloned and built again.
 function addWhereGroup(builder, callback) {
   const parentWhereGroup = builder._whereGroup;
   builder._whereGroup = {};
@@ -31,7 +33,17 @@ function addWhereGroup(builder, callback) {
   }
 }
 
-function wrapWhereGroups(builder) {
+// Assign an operation that isn't added through a builder, like the result of
+// `toFindOperation()`, to a new, separate group.
+function assignWhereGroup(operation) {
+  operation.whereGroup = {};
+  return operation;
+}
+
+// Return a map from each where operation that needs to be wrapped in
+// parentheses to the `WhereGroupOperation` that builds its group in place of
+// the group's first operation, or to null for the group's other operations.
+function getWhereGroupOperations(builder) {
   const WhereSelector = builder.constructor.WhereSelector;
   const whereOps = new Set();
   const groups = new Map();
@@ -56,17 +68,21 @@ function wrapWhereGroups(builder) {
     ops.push(op);
   });
 
-  if (groups.size < 2) {
-    return builder;
-  }
+  const whereGroupOps = new Map();
+
+  if (groups.size > 1) {
+    for (const ops of groups.values()) {
+      if (ops.some(mayContainTopLevelOr)) {
+        for (const op of ops) {
+          whereGroupOps.set(op, null);
+        }
 
-  for (const [group, ops] of groups) {
-    if (ops.some(mayContainTopLevelOr)) {
-      wrapOperations(builder, group, ops);
+        whereGroupOps.set(ops[0], new WhereGroupOperation('where', { operations: ops }));
+      }
     }
   }
 
-  return builder;
+  return whereGroupOps;
 }
 
 function getWhereGroup(op) {
@@ -80,10 +96,6 @@ function getWhereGroup(op) {
 }
 
 function mayContainTopLevelOr(op) {
-  if (op instanceof WhereGroupOperation) {
-    return false;
-  }
-
   // orWhere, orWhereIn, orWhereRaw, orWhereExists, orWhereJsonSupersetOf etc.
   if (/^or[A-Z]/.test(op.name)) {
     return true;
@@ -101,25 +113,8 @@ function isRaw(arg) {
   return isKnexRaw(arg) || (isObject(arg) && isFunction(arg.toKnexRaw));
 }
 
-function wrapOperations(builder, group, ops) {
-  const groupOp = new WhereGroupOperation('where');
-  groupOp.whereGroup = group;
-
-  builder.replaceOperation(ops[0], groupOp);
-
-  for (let i = 1; i < ops.length; ++i) {
-    builder.removeOperation(ops[i]);
-  }
-
-  for (const op of ops) {
-    op.parentOperation = null;
-    op.adderHookName = null;
-  }
-
-  groupOp.operations = ops;
-}
-
 module.exports = {
   addWhereGroup,
-  wrapWhereGroups,
+  assignWhereGroup,
+  getWhereGroupOperations,
 };

package/lib/queryBuilder/withoutOrder.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const { FirstOperation } = require('./operations/FirstOperation');
+const { isMsSql } = require('../utils/knexUtils');
+
+// Removes the order of a subquery that only selects or joins rows. The order
+// can come from a relation's `modify` or an `onBuild` hook of the context, so
+// it's removed when the subquery is built.
+function withoutOrder(subquery) {
+  return subquery.onBuild(clearUnsupportedOrder);
+}
+
+// Without a limit, an order doesn't matter in subqueries and updates, and SQL
+// Server rejects it there. With a limit it decides the rows, so we keep it, and
+// SQL Server rejects an update rather than updating arbitrary rows.
+function clearUnsupportedOrder(builder) {
+  if (isMsSql(builder.knex()) && !hasLimit(builder)) {
+    builder.clearOrder();
+  }
+}
+
+function hasLimit(builder) {
+  return (
+    builder.has(/limit|offset/) ||
+    // `first()` only adds its limit when the knex query is built.
+    builder.findOperation(FirstOperation)?.shouldLimit(builder)
+  );
+}
+
+module.exports = {
+  withoutOrder,
+  clearUnsupportedOrder,
+};

package/lib/relations/Relation.js

@@ -11,6 +11,7 @@ const { get, isFunction } = require('../utils/objectUtils');
 const { mapAfterAllReturn } = require('../utils/promiseUtils');
 const { createModifier } = require('../utils/createModifier');
 const { addWhereGroup } = require('../queryBuilder/whereGroups');
+const { withoutOrder } = require('../queryBuilder/withoutOrder');
 
 class Relation {
   constructor(relationName, OwnerClass) {
@@ -157,6 +158,8 @@ class Relation {
     if (relatedJoinSelect.isSelectAll()) {
       // No need to join a subquery if the query is `select * from "RelatedTable"`.
       relatedJoinSelect = aliasedTableName(relatedTable, relatedTableAlias);
+    } else {
+      withoutOrder(relatedJoinSelect);
     }
 
     return builder[joinOperation](relatedJoinSelect, (join) => {

package/lib/relations/RelationFindOperation.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { FindOperation } = require('../queryBuilder/operations/FindOperation');
-const { deprecate } = require('../utils/deprecate');
+const { warnOnce } = require('../utils/warnings');
 
 class RelationFindOperation extends FindOperation {
   constructor(name, opt) {
@@ -76,6 +76,11 @@ class RelationFindOperation extends FindOperation {
     return super.onAfter3(builder, related);
   }
 
+  // The columns of the result rows that hold the keys of their owners:
+  ownerKeyColumns() {
+    return this.relation.relatedProp.cols;
+  }
+
   warnOnInvalidOwnerProps() {
     this.warnOnMissingOwnerProps();
 
@@ -98,7 +103,7 @@ class RelationFindOperation extends FindOperation {
       }
 
       if (this.owner.modelArray.some((owner) => ownerProp.getProp(owner, c) === undefined)) {
-        deprecate(
+        warnOnce(
           `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
             `some owner models are missing the join property "${ownerProp.propDescription(c)}", ` +
             'so no related models are found for them. Select the column in the owner query.',
@@ -120,7 +125,7 @@ class RelationFindOperation extends FindOperation {
 
     for (let c = 0, lc = ownerProp.size; c < lc; ++c) {
       if (this.owner.modelArray.some((owner) => Array.isArray(ownerProp.getProp(owner, c)))) {
-        deprecate(
+        warnOnce(
           `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. ' +
@@ -139,7 +144,7 @@ class RelationFindOperation extends FindOperation {
 
     for (let c = 0, lc = relatedProp.size; c < lc; ++c) {
       if (related.some((rel) => relatedProp.getProp(rel, c) === undefined)) {
-        deprecate(
+        warnOnce(
           `Fetching relation "${this.relation.name}" of ${this.relation.ownerModelClass.name}: ` +
             `some related models are missing the join property "${relatedProp.propDescription(c)}", ` +
             'so they are not assigned to any owner. Check that the relation mapping uses the ' +

package/lib/relations/manyToMany/ManyToManyModifyMixin.js

@@ -2,6 +2,7 @@
 
 const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
 const { addWhereGroup } = require('../../queryBuilder/whereGroups');
+const { withoutOrder } = require('../../queryBuilder/withoutOrder');
 
 // This mixin contains the shared code for all modify operations (update, delete, relate, unrelate)
 // for ManyToManyRelation operations.
@@ -40,8 +41,18 @@ const ManyToManyModifyMixin = (Operation) => {
         // We can now remove the where and join statements from the main query.
         this.removeFiltersFromMainQuery(builder);
 
-        // Add a single where clause that uses the created subquery.
-        addWhereGroup(builder, () => this.applyModifyFilterForRelatedTable(builder));
+        // Add a single where clause that uses the created subquery. Updates
+        // that modify the join rows too are executed in batches of the ids
+        // that `onAfterBuild` fetches, see `queryBatches()` (#161).
+        addWhereGroup(builder, () =>
+          this.modifiesJoinTable
+            ? builder.where((whereBuilder) =>
+                builder._queryBatch
+                  ? this.applyIdFilterForRelatedTable(whereBuilder, builder._queryBatch)
+                  : this.applyModifyFilterForRelatedTable(whereBuilder),
+              )
+            : this.applyModifyFilterForRelatedTable(builder),
+        );
       }
 
       return super.onBuild(builder);
@@ -63,7 +74,7 @@ const ManyToManyModifyMixin = (Operation) => {
         .copyFrom(builder, builderClass.WhereSelector)
         .copyFrom(builder, builderClass.JoinSelector);
 
-      return modifyFilterSubquery.clearSelect();
+      return withoutOrder(modifyFilterSubquery.clearSelect());
     }
 
     removeFiltersFromMainQuery(builder) {
@@ -80,6 +91,11 @@ const ManyToManyModifyMixin = (Operation) => {
       return builder.whereInComposite(idRefs, subquery);
     }
 
+    applyIdFilterForRelatedTable(builder, ids) {
+      const idRefs = this.relation.relatedModelClass.getIdRelationProperty().refs(builder);
+      return builder.whereInComposite(idRefs, ids);
+    }
+
     // Only modifies the join rows that match the filters (#1853).
     applyModifyFilterForJoinTable(builder) {
       const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
@@ -108,11 +124,13 @@ const ManyToManyModifyMixin = (Operation) => {
         });
       });
 
-      return relation
-        .applyModify(subquery)
-        .copyFrom(builder, builderClass.WhereSelector)
-        .copyFrom(builder, builderClass.JoinSelector)
-        .select(1);
+      return withoutOrder(
+        relation
+          .applyModify(subquery)
+          .copyFrom(builder, builderClass.WhereSelector)
+          .copyFrom(builder, builderClass.JoinSelector)
+          .select(1),
+      );
     }
 
     toFindOperation() {
@@ -143,9 +161,13 @@ const ManyToManyModifyMixin = (Operation) => {
 
 class ManyToManyModifyFindOperation extends ManyToManyFindOperation {
   onBuild(builder) {
+    const { modifyOperation } = this.opt;
     super.onBuild(builder);
+
     addWhereGroup(builder, () =>
-      this.opt.modifyOperation.applyModifyFilterForRelatedTable(builder),
+      modifyOperation.relatedIds
+        ? modifyOperation.applyIdFilterForRelatedTable(builder, modifyOperation.relatedIds)
+        : modifyOperation.applyModifyFilterForRelatedTable(builder),
     );
   }
 }

package/lib/relations/manyToMany/ManyToManyRelation.js

@@ -11,6 +11,7 @@ const { mapAfterAllReturn } = require('../../utils/promiseUtils');
 const { isFunction, isObject, isString } = require('../../utils/objectUtils');
 const { createModifier } = require('../../utils/createModifier');
 const { addWhereGroup } = require('../../queryBuilder/whereGroups');
+const { withoutOrder } = require('../../queryBuilder/withoutOrder');
 
 const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
 const { ManyToManyInsertOperation } = require('./insert/ManyToManyInsertOperation');
@@ -113,6 +114,8 @@ class ManyToManyRelation extends Relation {
       .as(joinTableAlias);
     if (joinTableSelect.isSelectAll()) {
       joinTableSelect = aliasedTableName(joinTable, joinTableAlias);
+    } else {
+      withoutOrder(joinTableSelect);
     }
 
     builder.join(joinTableSelect, (join) => {
@@ -144,6 +147,8 @@ class ManyToManyRelation extends Relation {
     if (relatedJoinSelect.isSelectAll()) {
       // No need to join a subquery if the query is `select * from "RelatedTable"`.
       relatedJoinSelect = aliasedTableName(relatedTable, relatedTableAlias);
+    } else {
+      withoutOrder(relatedJoinSelect);
     }
 
     let joinTableSelect = this.joinTableModelClass
@@ -153,6 +158,8 @@ class ManyToManyRelation extends Relation {
       .as(joinTableAlias);
     if (joinTableSelect.isSelectAll()) {
       joinTableSelect = aliasedTableName(this.joinTable, joinTableAlias);
+    } else {
+      withoutOrder(joinTableSelect);
     }
 
     return builder[joinOperation](joinTableSelect, (join) => {