objection 3.7.0 → 3.9.0

package/lib/queryBuilder/join/TableNode.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { propKey, hasProps } = require('../../model/modelValues');
+
 class TableNode {
   constructor({ tableTree, modelClass, expression, parentNode = null, relation = null }) {
     this.tableTree = tableTree;
@@ -86,78 +88,14 @@ class TableNode {
   }
 
   _createIdGetter() {
-    const idColumns = this.modelClass.getIdColumnArray();
-    const columnAliases = idColumns.map((column) => this.getColumnAliasForColumn(column));
-
-    if (idColumns.length === 1) {
-      return createIdGetter(columnAliases);
-    } else {
-      return createCompositeIdGetter(columnAliases);
-    }
-  }
-}
-
-function createIdGetter(columnAliases) {
-  const columnAlias = columnAliases[0];
+    const columnAliases = this.modelClass
+      .getIdColumnArray()
+      .map((column) => this.getColumnAliasForColumn(column));
 
-  return (flatRow) => {
-    const id = flatRow[columnAlias];
-
-    if (id === null) {
-      return null;
-    }
-
-    return `${id}`;
-  };
-}
-
-function createCompositeIdGetter(columnAliases) {
-  if (columnAliases.length === 2) {
-    return createTwoIdGetter(columnAliases);
-  } else {
-    return createMultiIdGetter(columnAliases);
+    return (flatRow) => (hasProps(flatRow, columnAliases) ? propKey(flatRow, columnAliases) : null);
   }
 }
 
-function createTwoIdGetter(columnAliases) {
-  const columnAlias1 = columnAliases[0];
-  const columnAlias2 = columnAliases[1];
-
-  return (flatRow) => {
-    const id1 = flatRow[columnAlias1];
-    const id2 = flatRow[columnAlias2];
-
-    if (id1 === null || id2 === null) {
-      return null;
-    }
-
-    return `${id1},${id2}`;
-  };
-}
-
-function createMultiIdGetter(columnAliases) {
-  return (flatRow) => {
-    let idStr = '';
-
-    for (let i = 0, l = columnAliases.length; i < l; ++i) {
-      const columnAlias = columnAliases[i];
-      const id = flatRow[columnAlias];
-
-      if (id === null) {
-        return null;
-      }
-
-      idStr += id;
-
-      if (i !== l - 1) {
-        idStr += ',';
-      }
-    }
-
-    return idStr;
-  };
-}
-
 module.exports = {
   TableNode,
 };

package/lib/queryBuilder/join/utils.js

@@ -6,8 +6,8 @@ const { isPostgres, isMySql, isMsSql, isSqlite } = require('../../utils/knexUtil
 const RELATION_RECURSION_LIMIT = 64;
 
 // The maximum length of the column aliases of the joined relations, after
-// which the database would truncate them. Unknown databases use the strictest
-// of the known limits, the one of postgres.
+// which the database would truncate them. Other databases keep the limit of
+// postgres, which isn't the strictest one: Oracle before 12.2 only allows 30.
 function getIdentifierLengthLimit(knex) {
   if (isPostgres(knex)) {
     return 63;

package/lib/queryBuilder/operations/DelegateOperation.js

@@ -55,6 +55,17 @@ class DelegateOperation extends QueryBuilderOperation {
     return this.onBuild !== DelegateOperation.prototype.onBuild || this.delegate.hasOnBuild();
   }
 
+  onAfterBuild(builder) {
+    return this.delegate.onAfterBuild(builder);
+  }
+
+  hasOnAfterBuild() {
+    return (
+      this.onAfterBuild !== DelegateOperation.prototype.onAfterBuild ||
+      this.delegate.hasOnAfterBuild()
+    );
+  }
+
   onBuildKnex(knexBuilder, builder) {
     return this.delegate.onBuildKnex(knexBuilder, builder);
   }
@@ -110,6 +121,17 @@ class DelegateOperation extends QueryBuilderOperation {
     );
   }
 
+  queryBatches(builder) {
+    return this.delegate.queryBatches(builder);
+  }
+
+  hasQueryBatches() {
+    return (
+      this.queryBatches !== DelegateOperation.prototype.queryBatches ||
+      this.delegate.hasQueryBatches()
+    );
+  }
+
   onError(builder, error) {
     return this.delegate.onError(builder, error);
   }

package/lib/queryBuilder/operations/DeleteOperation.js

@@ -2,6 +2,8 @@
 
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 const { StaticHookArguments } = require('../StaticHookArguments');
+const { isMySql } = require('../../utils/knexUtils');
+const { warnOnce } = require('../../utils/warnings');
 
 class DeleteOperation extends QueryBuilderOperation {
   async onBefore2(builder, result) {
@@ -9,6 +11,17 @@ class DeleteOperation extends QueryBuilderOperation {
     return result;
   }
 
+  // knex leaves the order out of deletes on MySQL, but keeps their limit, so
+  // the order doesn't pick the deleted rows. Warn when the query is executed.
+  onAfterBuild(builder) {
+    if (isMySql(builder.knex()) && builder.has('limit') && builder.has(/^orderBy/)) {
+      warnOnce(
+        'orderBy() has no effect in delete queries with limit() on MySQL, so the limit ' +
+          'deletes rows in any order. This will throw an error in objection 4.0.',
+      );
+    }
+  }
+
   onBuildKnex(knexBuilder) {
     return knexBuilder.delete();
   }

package/lib/queryBuilder/operations/FirstOperation.js

@@ -3,10 +3,12 @@
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 
 class FirstOperation extends QueryBuilderOperation {
-  onBuildKnex(knexBuilder, builder) {
-    const modelClass = builder.modelClass();
+  shouldLimit(builder) {
+    return builder.isFind() && builder.modelClass().useLimitInFirst;
+  }
 
-    if (builder.isFind() && modelClass.useLimitInFirst) {
+  onBuildKnex(knexBuilder, builder) {
+    if (this.shouldLimit(builder)) {
       knexBuilder = knexBuilder.limit(1);
     }
 

package/lib/queryBuilder/operations/InsertGraphOperation.js

@@ -42,6 +42,7 @@ class InsertGraphOperation extends DelegateOperation {
         noUnrelate: true,
         insertMissing: true,
       }),
+      insertOnly: true,
     });
 
     // We resolve this query here and will not execute it. This is because the root

package/lib/queryBuilder/operations/InsertOperation.js

@@ -3,7 +3,7 @@
 const { QueryBuilderOperation } = require('./QueryBuilderOperation');
 const { StaticHookArguments } = require('../StaticHookArguments');
 const { after, mapAfterAllReturn } = require('../../utils/promiseUtils');
-const { isPostgres, isSqlite, isMySql, isMsSql } = require('../../utils/knexUtils');
+const { isSqlite, isMySql, hasBatchInsert } = require('../../utils/knexUtils');
 const { isObject, isString } = require('../../utils/objectUtils');
 
 // Base class for all insert operations.
@@ -27,7 +27,7 @@ class InsertOperation extends QueryBuilderOperation {
   }
 
   async onBefore2(builder, result) {
-    if (this.models.length > 1 && !isPostgres(builder.knex()) && !isMsSql(builder.knex())) {
+    if (this.models.length > 1 && !hasBatchInsert(builder.knex())) {
       throw new Error('batch insert only works with Postgresql and SQL Server');
     } else {
       await callBeforeInsert(builder, this.models);

package/lib/queryBuilder/operations/InstanceDeleteOperation.js

@@ -3,6 +3,7 @@
 const { DeleteOperation } = require('./DeleteOperation');
 const { InstanceFindOperation } = require('./InstanceFindOperation');
 const { assertHasId } = require('../../utils/assert');
+const { addWhereGroup } = require('../whereGroups');
 
 class InstanceDeleteOperation extends DeleteOperation {
   constructor(name, opt) {
@@ -20,7 +21,7 @@ class InstanceDeleteOperation extends DeleteOperation {
     super.onBuild(builder);
 
     assertHasId(this.instance);
-    builder.findById(this.instance.$id());
+    addWhereGroup(builder, () => builder.findById(this.instance.$id()));
   }
 
   async onAfter2(builder, result) {

package/lib/queryBuilder/operations/InstanceFindOperation.js

@@ -2,6 +2,7 @@
 
 const { FindOperation } = require('./FindOperation');
 const { assertHasId } = require('../../utils/assert');
+const { addWhereGroup } = require('../whereGroups');
 
 class InstanceFindOperation extends FindOperation {
   constructor(name, opt) {
@@ -11,7 +12,7 @@ class InstanceFindOperation extends FindOperation {
 
   onBuild(builder) {
     assertHasId(this.instance);
-    builder.findById(this.instance.$id());
+    addWhereGroup(builder, () => builder.findById(this.instance.$id()));
   }
 }
 

package/lib/queryBuilder/operations/InstanceUpdateOperation.js

@@ -4,6 +4,8 @@ const { UpdateOperation } = require('./UpdateOperation');
 const { InstanceFindOperation } = require('./InstanceFindOperation');
 const { assertHasId } = require('../../utils/assert');
 const { isObject } = require('../../utils/objectUtils');
+const { addWhereGroup } = require('../whereGroups');
+const { removeOverriddenQueryProps } = require('../../model/modelQueryProps');
 
 class InstanceUpdateOperation extends UpdateOperation {
   constructor(name, opt) {
@@ -18,6 +20,7 @@ class InstanceUpdateOperation extends UpdateOperation {
 
     if (!this.model) {
       this.model = this.instance;
+      removeOverriddenQueryProps(this.model);
     }
 
     return retVal;
@@ -27,7 +30,7 @@ class InstanceUpdateOperation extends UpdateOperation {
     super.onBuild(builder);
 
     assertHasId(this.instance);
-    builder.findById(this.instance.$id());
+    addWhereGroup(builder, () => builder.findById(this.instance.$id()));
   }
 
   async onAfter2(builder, result) {

package/lib/queryBuilder/operations/LimitPerParentOperation.js

@@ -0,0 +1,152 @@
+'use strict';
+
+const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+const { RangeOperation } = require('./RangeOperation');
+const { FirstOperation } = require('./FirstOperation');
+const { isString, isNumber } = require('../../utils/objectUtils');
+const { hasWindowFunctions, isKnexRaw } = require('../../utils/knexUtils');
+const { Selection, isSameTable, withoutSchema } = require('./select/Selection');
+
+// Without underscores, so that column name mappers don't change it.
+const rowNumberColumn = 'objectiontmprownum';
+
+// Applies the `limit()`, `offset()` and `first()` of a relation query that
+// fetches the related models of many parents to each parent separately.
+class LimitPerParentOperation extends QueryBuilderOperation {
+  constructor(name, opt) {
+    super(name, opt);
+    this.findOperation = opt.findOperation;
+  }
+
+  onBuild(builder) {
+    builder.addInternalSelection(rowNumberColumn);
+  }
+
+  // Return the limit and offset of the query, built into `knexBuilder` by any
+  // of its operations, or `null` if it has none:
+  getRange(knexBuilder, builder) {
+    // `page()` and `range()` keep limiting all parents, as their total does.
+    if (!builder.has(RangeOperation)) {
+      const { limit = null, offset = null } = knexBuilder._single;
+      // `first()` only limits the query with `useLimitInFirst`:
+      const isFirst = builder.has(FirstOperation);
+
+      if (limit !== null || offset !== null || isFirst) {
+        return { limit: isFirst ? 1 : limit, offset: offset ?? 0 };
+      }
+    }
+
+    return null;
+  }
+
+  // Called by `buildKnexQuery()` after the default table and select are set.
+  onAfterBuildKnex(knexBuilder, builder) {
+    const knex = builder.knex();
+    const range = this.getRange(knexBuilder, builder);
+
+    if (!range) {
+      return knexBuilder;
+    } else if (!hasWindowFunctions(knex)) {
+      // `WhereInEagerOperation` fetches the related models of each parent with
+      // a separate query then, so only `first()` still needs to be applied:
+      return range.limit === null ? knexBuilder : knexBuilder.limit(range.limit);
+    } else {
+      const { limit, offset } = range;
+      // Number the rows of each parent one level up, aliased as the related
+      // table, so that the order can refer to the selected columns and their
+      // aliases as in the query itself, e.g. to `id` when a joined table has
+      // an `id` too. The order moves into the window function, as SQL Server
+      // doesn't allow it in subqueries. An alias can't have a schema.
+      const table = withoutSchema(builder.tableRef());
+      // knex only accepts raw partitions wrapped in objects:
+      const partition = this.findOperation.ownerKeys(builder, table).map((column) => ({ column }));
+      const numberedQuery = knex
+        .queryBuilder()
+        .select('*')
+        .rowNumber(rowNumberColumn, (window) =>
+          window.orderBy(getWindowOrder(builder, knex, table)).partitionBy(partition),
+        )
+        .from(
+          knexBuilder.clone().clear('with').clear('limit').clear('offset').clear('order').as(table),
+        );
+
+      // Select the rows in range with the query itself, to keep its settings
+      // like `timeout()`, and its common table expressions.
+      knexBuilder
+        .clear('select')
+        .clear('where')
+        .clear('join')
+        .clear('union')
+        .clear('group')
+        .clear('having')
+        .clear('order')
+        .clear('limit')
+        .clear('offset')
+        .select('*')
+        .from(numberedQuery.as(rowNumberColumn))
+        .where(rowNumberColumn, '>', offset)
+        .orderBy(rowNumberColumn);
+
+      if (limit !== null) {
+        // knex also accepts raw offsets:
+        const end = isNumber(offset) ? offset + limit : knex.raw('? + ?', [offset, limit]);
+        knexBuilder.where(rowNumberColumn, '<=', end);
+      }
+
+      return knexBuilder;
+    }
+  }
+}
+
+// Convert the `orderBy()` and `orderByRaw()` calls of the query to the order
+// of knex's window functions, which can only refer to the related table by its
+// alias `table`.
+function getWindowOrder(builder, knex, table) {
+  const order = [];
+  const tableRef = builder.tableRef();
+
+  const getAliasedColumn = (column) => {
+    const selection = isString(column) && Selection.create(column);
+    return selection?.table && isSameTable(builder, selection.table, tableRef)
+      ? `${table}.${selection.column}`
+      : column;
+  };
+
+  builder.forEachOperation(builder.constructor.OrderBySelector, (op) => {
+    const args = op.getKnexArgs(builder);
+
+    if (op.name === 'orderByRaw') {
+      const [sql, bindings] = args;
+      order.push({ column: isKnexRaw(sql) ? sql : knex.raw(sql, bindings) });
+    } else {
+      const [column, direction, nulls] = args;
+      const items = Array.isArray(column)
+        ? column.map((item) => (isString(item) ? { column: item } : item))
+        : [{ column, order: direction, nulls }];
+
+      for (const item of items) {
+        const aliasedColumn = getAliasedColumn(item.column);
+
+        if (item.nulls) {
+          // Not all databases support `nulls first` and `nulls last`:
+          order.push({
+            column: knex.raw('(case when ? is null then 0 else 1 end)', [
+              isString(aliasedColumn) ? knex.ref(aliasedColumn) : aliasedColumn,
+            ]),
+            order: item.nulls === 'first' ? 'asc' : 'desc',
+          });
+        }
+
+        // Unlike in `orderBy()`, knex adds the direction to the window as it is:
+        order.push({ column: aliasedColumn, order: /^desc$/i.test(item.order) ? 'desc' : 'asc' });
+      }
+    }
+  });
+
+  // SQL Server requires an order in the window function:
+  return order.length ? order : [{ column: knex.raw('(select null)') }];
+}
+
+module.exports = {
+  LimitPerParentOperation,
+};

package/lib/queryBuilder/operations/QueryBuilderOperation.js

@@ -6,9 +6,11 @@ const hookNameToHasMethodName = {
   onBefore2: 'hasOnBefore2',
   onBefore3: 'hasOnBefore3',
   onBuild: 'hasOnBuild',
+  onAfterBuild: 'hasOnAfterBuild',
   onBuildKnex: 'hasOnBuildKnex',
   onRawResult: 'hasOnRawResult',
   queryExecutor: 'hasQueryExecutor',
+  queryBatches: 'hasQueryBatches',
   onAfter1: 'hasOnAfter1',
   onAfter2: 'hasOnAfter2',
   onAfter3: 'hasOnAfter3',
@@ -107,6 +109,20 @@ class QueryBuilderOperation {
     return this.onBuild !== QueryBuilderOperation.prototype.onBuild;
   }
 
+  // This is called after `onBuild` when the query is executed, right before the
+  // knex query is built and executed, but not when the query is only built,
+  // e.g. with `toKnexQuery()` or `resultSize()`. Use it for work that needs the
+  // built query, like queries that have to run before it. It's also called for
+  // queries that are resolved or rejected without executing, e.g. with `none()`
+  // or `resolve()`, so check `builder.isExplicitlyResolvedOrRejected()` first.
+  //
+  // This method can be asynchronous.
+  // This method should never call any methods that add operations to the builder.
+  onAfterBuild(builder) {}
+  hasOnAfterBuild() {
+    return this.onAfterBuild !== QueryBuilderOperation.prototype.onAfterBuild;
+  }
+
   // This is called when the knex query is built. Here you should only call knex
   // methods. You may call getters and other immutable methods of the `builder`
   // but you should never call methods that add QueryBuilderOperations.
@@ -177,6 +193,21 @@ class QueryBuilderOperation {
     return this.queryExecutor !== QueryBuilderOperation.prototype.queryExecutor;
   }
 
+  // This is called after `onAfterBuild` when the query is executed. It can
+  // return an array of batches to build and execute the knex query once per
+  // batch, e.g. when a filter has more values than the database accepts in one
+  // statement. The batch being built is in `builder._queryBatch`, and the
+  // results of all batches are merged before `onRawResult` is called. Return
+  // null to execute the query once.
+  //
+  // This method must be synchronous.
+  queryBatches(builder) {
+    return null;
+  }
+  hasQueryBatches() {
+    return this.queryBatches !== QueryBuilderOperation.prototype.queryBatches;
+  }
+
   // This is called if an error occurs in the query execution.
   //
   // This method must return a QueryBuilder instance.

package/lib/queryBuilder/operations/UpdateAndFetchOperation.js

@@ -3,6 +3,7 @@
 const { DelegateOperation } = require('./DelegateOperation');
 const { FindByIdOperation } = require('./FindByIdOperation');
 const { UpdateOperation } = require('./UpdateOperation');
+const { addWhereGroup, assignWhereGroup } = require('../whereGroups');
 
 class UpdateAndFetchOperation extends DelegateOperation {
   constructor(name, opt) {
@@ -41,7 +42,7 @@ class UpdateAndFetchOperation extends DelegateOperation {
 
   onBuild(builder) {
     if (!this.skipIdWhere) {
-      builder.findById(this.id);
+      addWhereGroup(builder, () => builder.findById(this.id));
     }
 
     super.onBuild(builder);
@@ -78,10 +79,17 @@ class UpdateAndFetchOperation extends DelegateOperation {
     return fetched ? this.model : undefined;
   }
 
-  toFindOperation() {
-    return new FindByIdOperation('findById', {
-      id: this.id,
-    });
+  toFindOperation(builder) {
+    // The find operation of the delegate keeps its filters, e.g. the ones that
+    // many-to-many updates move to a subquery when the query is built.
+    const delegate = this.delegate.toFindOperation(builder);
+
+    // Keep the id condition in its own where group, like `onBuild()` does. The
+    // delegate isn't named `findById`, as that would put all the wheres that it
+    // adds in the user's group.
+    return delegate
+      ? new FindByIdDelegateOperation('find', { delegate, id: this.id })
+      : assignWhereGroup(new FindByIdOperation('findById', { id: this.id }));
   }
 
   clone() {
@@ -94,6 +102,15 @@ class UpdateAndFetchOperation extends DelegateOperation {
   }
 }
 
+// Finds the rows of a delegate find operation by id, like `UpdateAndFetchOperation`
+// updates them.
+class FindByIdDelegateOperation extends DelegateOperation {
+  onBuild(builder) {
+    super.onBuild(builder);
+    addWhereGroup(builder, () => builder.findById(this.opt.id));
+  }
+}
+
 module.exports = {
   UpdateAndFetchOperation,
 };

package/lib/queryBuilder/operations/UpdateOperation.js

@@ -1,12 +1,16 @@
 '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');
 const { StaticHookArguments } = require('../StaticHookArguments');
+const { ValidationErrorType } = require('../../model/ValidationError');
 
 class UpdateOperation extends QueryBuilderOperation {
   constructor(name, opt) {
@@ -107,17 +111,39 @@ async function callStaticAfterUpdate(builder, result) {
 
 function convertFieldExpressionsToRaw(builder, model, json) {
   const knex = builder.knex();
+  const modelClass = builder.modelClass();
+  const declaredColumns = getDeclaredColumns(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)`)
+      // "col" : raw(`jsonb_set("table"."col", '{attr}', to_jsonb("other"#>'{lol}'), true)`)
+      // with the column qualified, as it is ambiguous with `excluded` in merge().
       warnIfNotPostgres(knex);
 
       let parsed = ref(key);
+
+      // The field expression would be lost or produce invalid SQL next to a
+      // value for the whole json column. Report it with the property names:
+      if (Object.prototype.hasOwnProperty.call(json, parsed.column)) {
+        const property = modelClass.columnNameToPropertyName(parsed.column);
+        throw modelClass.createValidationError({
+          type: ValidationErrorType.ModelValidation,
+          data: {
+            [modelClass.columnNameToPropertyName(key)]: [
+              {
+                message: `can't be combined with a value for the json column '${property}'`,
+                keyword: null,
+                params: { property },
+              },
+            ],
+          },
+        });
+      }
+
       let jsonPath = toPostgresJsonPathLiteral(parsed.parsedExpr.access);
       let valuePlaceholder = '?';
 
@@ -129,7 +155,7 @@ function convertFieldExpressionsToRaw(builder, model, json) {
 
       convertedJson[parsed.column] = knex.raw(
         `jsonb_set(??, ${jsonPath}, ${valuePlaceholder}, true)`,
-        [convertedJson[parsed.column] || parsed.column, val],
+        [convertedJson[parsed.column] || `${builder.tableRef()}.${parsed.column}`, val],
       );
 
       delete model[key];
@@ -141,7 +167,30 @@ 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,
+  getDeclaredColumns,
 };

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))