objection 3.6.0 → 3.8.0

package/lib/model/AjvValidator.js

@@ -5,7 +5,7 @@ const addFormats = require('ajv-formats');
 const { Validator } = require('./Validator');
 const { ValidationErrorType } = require('../model/ValidationError');
 const { isObject, once, cloneDeep: lodashCloneDeep, omit } = require('../utils/objectUtils');
-const { parseFieldExpression } = require('../utils/parseFieldExpression');
+const { parseFieldExpression, isFieldExpressionKey } = require('../utils/parseFieldExpression');
 const { getQueryPropKeys } = require('./modelQueryProps');
 
 class AjvValidator extends Validator {
@@ -79,27 +79,60 @@ class AjvValidator extends Validator {
       return json;
     }
 
-    const modelClass = model.constructor;
-    const validator = this.getValidator(
-      modelClass,
-      ctx.jsonSchema,
-      !!options.patch,
-      options.patch ? null : getMissingQueryPropKeys(model, json, ctx.jsonSchema),
-    );
-
     // We need to clone the input json if we are about to set default values.
     if (!options.mutable && !options.patch && setsDefaultValues(ctx.jsonSchema)) {
       json = cloneDeep(json);
     }
 
-    // Patch objects can contain field expression keys like `'meta:b'` that update
-    // a single property inside a json column. Validate them against the nested
-    // schema by converting them into nested objects like `{ meta: { b: value } }`.
-    const fieldExpressions = options.patch ? nestFieldExpressions(json) : null;
-    const validationJson = fieldExpressions ? fieldExpressions.json : json;
+    // Patch and update objects can contain field expression keys like `'meta:b'`
+    // that update a single property inside a json column. Validate them against
+    // the nested schema by converting them into nested objects like
+    // `{ meta: { b: value } }`.
+    const queryPropKeys = getQueryPropKeys(model);
+    const fieldExpressions = nestFieldExpressions(json, queryPropKeys, ctx.jsonSchema);
+    let validationJson = fieldExpressions ? fieldExpressions.json : json;
+
+    const modelClass = model.constructor;
+    const validate = (json, isPatchObject, givenKeys = []) => {
+      const validator = this.getValidator(
+        modelClass,
+        ctx.jsonSchema,
+        isPatchObject,
+        isPatchObject ? null : getRequiredKeysGivenOutside(json, ctx.jsonSchema, givenKeys),
+      );
+      validator.call(model, json);
+      return validator.errors || [];
+    };
+
+    let errors;
+
+    if (options.patch) {
+      errors = validate(validationJson, true);
+    } else if (fieldExpressions && fieldExpressions.columns.length > 0) {
+      // Field expressions only write parts of their json columns. Validate these
+      // parts like patches, and the rest normally, with the columns counted as
+      // present like the query properties.
+      const { columns } = fieldExpressions;
+      const columnsJson = Object.fromEntries(
+        columns
+          .filter((column) => hasOwn(validationJson, column))
+          .map((column) => [column, validationJson[column]]),
+      );
+      const restJson = omit(validationJson, columns);
+
+      errors = [
+        ...validate(columnsJson, true),
+        ...validate(restJson, false, [...queryPropKeys, ...columns]),
+      ];
+
+      // Combine the parts again, without the defaults that Ajv set for the
+      // columns in `restJson`.
+      validationJson = Object.assign(restJson, columnsJson);
+    } else {
+      errors = validate(validationJson, false, queryPropKeys);
+    }
 
-    validator.call(model, validationJson);
-    const error = parseValidationError(validator.errors, modelClass, options, this.ajvOptions);
+    const error = parseValidationError(errors, modelClass, options, this.ajvOptions);
 
     if (error) {
       throw error;
@@ -107,7 +140,7 @@ class AjvValidator extends Validator {
 
     if (fieldExpressions) {
       // Copy back the changes made by Ajv options like `coerceTypes` and `removeAdditional`.
-      unnestFieldExpressions(json, fieldExpressions);
+      unnestFieldExpressions(json, validationJson, fieldExpressions);
     }
 
     return json;
@@ -148,7 +181,8 @@ class AjvValidator extends Validator {
         normalValidator: null,
 
         // Validators created for the schema object without the `required`
-        // properties that are given as query properties, keyed by their names.
+        // properties that are given outside the json, as query properties or
+        // json columns written by field expressions, keyed by their names.
         queryPropValidators: null,
       };
 
@@ -215,7 +249,22 @@ class AjvValidator extends Validator {
       this.setupAjv(this.ajvQueryProps);
     }
 
-    return this.ajvQueryProps.compile(jsonSchema);
+    for (;;) {
+      try {
+        return this.ajvQueryProps.compile(jsonSchema);
+      } catch (err) {
+        // The schemas of other model classes that `$ref`s point to aren't added
+        // to this instance. Copy them over from the normal instance when needed.
+        const validator =
+          err instanceof Ajv.MissingRefError && this.ajv.getSchema(err.missingSchema);
+
+        if (!validator) {
+          throw err;
+        }
+
+        this.ajvQueryProps.addSchema(validator.schema, err.missingSchema);
+      }
+    }
   }
 }
 
@@ -283,10 +332,11 @@ function parseValidationError(errors, modelClass, options, ajvOptions) {
   });
 }
 
-function nestFieldExpressions(json) {
+function nestFieldExpressions(json, queryPropKeys, jsonSchema) {
+  const isFieldExpression = (key) => isFieldExpressionKey(key, jsonSchema.properties);
   const keys = Object.keys(json);
 
-  if (!keys.some(isFieldExpression)) {
+  if (!keys.some(isFieldExpression) && !queryPropKeys.some(isFieldExpression)) {
     return null;
   }
 
@@ -295,6 +345,15 @@ function nestFieldExpressions(json) {
   // The objects created here for the nested paths. Other objects are values
   // of the input json and must not be modified.
   const createdObjects = new Set();
+  // The json columns that are only written partially, by field expressions in
+  // the json or the query properties.
+  const columns = new Set();
+
+  const addColumn = (expression) => {
+    if (expression && !hasOwn(json, expression.column)) {
+      columns.add(expression.column);
+    }
+  };
 
   for (const key of keys) {
     if (!isFieldExpression(key)) {
@@ -305,7 +364,10 @@ function nestFieldExpressions(json) {
 
   for (const key of keys) {
     if (isFieldExpression(key)) {
-      const path = fieldExpressionPath(key);
+      const expression = parseFieldExpressionKey(key);
+      // Not a valid field expression, validate it as a top-level property:
+      const path = expression ? expression.path : [key];
+      addColumn(expression);
 
       // Field expressions with array access, and those that conflict with other
       // keys of the patch, can't be validated without the current value of the
@@ -316,10 +378,16 @@ function nestFieldExpressions(json) {
     }
   }
 
-  return { json: nested, paths };
+  for (const key of queryPropKeys) {
+    if (isFieldExpression(key)) {
+      addColumn(parseFieldExpressionKey(key));
+    }
+  }
+
+  return { json: nested, paths, columns: [...columns] };
 }
 
-function unnestFieldExpressions(json, { json: nested, paths }) {
+function unnestFieldExpressions(json, nested, { paths, columns }) {
   for (const [key, path] of paths) {
     let value = nested;
     let found = true;
@@ -341,27 +409,35 @@ function unnestFieldExpressions(json, { json: nested, paths }) {
       json[key] = value;
     }
   }
-}
 
-function isFieldExpression(key) {
-  return key.indexOf(':') !== -1;
+  // Copy over the default values that Ajv set for missing properties, but not
+  // the json columns written by the field expressions.
+  for (const key of Object.keys(nested)) {
+    if (!paths.has(key) && !columns.includes(key)) {
+      json[key] = nested[key];
+    }
+  }
 }
 
-function fieldExpressionPath(key) {
+// Parse a field expression key into its json column and nested path, with the
+// path set to `null` if the key accesses array elements.
+function parseFieldExpressionKey(key) {
   let parsed;
 
   try {
     parsed = parseFieldExpression(key);
   } catch (err) {
-    // Not a valid field expression, validate it as a top-level property.
-    return [key];
-  }
-
-  if (parsed.access.some((access) => access.type !== 'object')) {
     return null;
   }
 
-  return [parsed.column, ...parsed.access.map((access) => String(access.ref))];
+  const { column, access } = parsed;
+  // Numeric keys like the `0` in `tags:0` also access array elements when the
+  // json value is an array, so treat them like `[0]`.
+  const isArrayAccess = access.some(({ type, ref }) => type !== 'object' || /^-?\d+$/.test(ref));
+  return {
+    column,
+    path: isArrayAccess ? null : [column, ...access.map(({ ref }) => String(ref))],
+  };
 }
 
 function setPath(obj, path, value, createdObjects) {
@@ -445,22 +521,20 @@ function objectHasDefaults(obj) {
   return false;
 }
 
-// Returns the keys of the query properties of `model` (`raw()`, `val()`,
-// `ref()`, subqueries...) that are required by the schema but missing from
-// `json`, sorted, or `null` if there are none. Query properties are split from
-// the json before validation, but they do provide a value for the property.
-function getMissingQueryPropKeys(model, json, jsonSchema) {
+// Returns the `keys` that are required by the schema but given outside of
+// `json`, sorted, or `null` if there are none. Query properties (`raw()`,
+// `val()`, `ref()`, subqueries...) are split from the json before validation,
+// but they do provide a value for the property, and so do field expressions
+// for their json columns.
+function getRequiredKeysGivenOutside(json, jsonSchema, keys) {
   const required = jsonSchema.required;
 
   if (!Array.isArray(required) || required.length === 0) {
     return null;
   }
 
-  const keys = getQueryPropKeys(model).filter(
-    (key) => required.includes(key) && !Object.prototype.hasOwnProperty.call(json, key),
-  );
-
-  return keys.length > 0 ? keys.sort() : null;
+  const givenKeys = required.filter((key) => keys.includes(key) && !hasOwn(json, key));
+  return givenKeys.length > 0 ? givenKeys.sort() : null;
 }
 
 function jsonSchemaWithoutRequiredKeys(jsonSchema, keys) {
@@ -470,6 +544,11 @@ function jsonSchemaWithoutRequiredKeys(jsonSchema, keys) {
 }
 
 function jsonSchemaWithoutRequired(jsonSchema) {
+  // Boolean schemas (`true` / `false`) have no `required` to strip.
+  if (!isObject(jsonSchema)) {
+    return jsonSchema;
+  }
+
   // `not` is intentionally left untouched: Stripping `required` inside it
   // would turn it into a schema that rejects everything (e.g.
   // `not: { required: ['a'] }` -> `not: {}`). Kept as is, it still holds for
@@ -506,17 +585,18 @@ function definitionsWithoutRequired(jsonSchema, prop) {
 }
 
 function subSchemaWithoutRequired(jsonSchema, prop) {
-  if (jsonSchema[prop]) {
+  if (jsonSchema[prop] !== undefined) {
     if (Array.isArray(jsonSchema[prop])) {
       const schemaArray = jsonSchema[prop].map(jsonSchemaWithoutRequired);
-      const nonEmptySchemaArray = schemaArray.filter(isNotEmptyObject);
+      const nonEmptySchemaArray = schemaArray.filter((schema) => !matchesAnything(schema));
 
       // An `anyOf` or `oneOf` option that only consisted of `required` is
       // empty once `required` is stripped, and an empty schema matches any
-      // patch, just like the stripped `required` keywords elsewhere. Drop the
-      // whole keyword then: requiring the patch to match one of the remaining
-      // options would reject valid patches, and with `oneOf` keeping the empty
-      // option would fail every patch that also matches another option.
+      // patch, just like the stripped `required` keywords elsewhere and the
+      // `true` schema. Drop the whole keyword then: requiring the patch to
+      // match one of the remaining options would reject valid patches, and
+      // with `oneOf` keeping the empty option would fail every patch that also
+      // matches another option.
       if (prop !== 'allOf' && nonEmptySchemaArray.length !== schemaArray.length) {
         return {};
       } else if (nonEmptySchemaArray.length !== 0) {
@@ -548,8 +628,8 @@ function subSchemaWithoutRequired(jsonSchema, prop) {
   }
 }
 
-function isNotEmptyObject(obj) {
-  return Object.keys(obj).length !== 0;
+function matchesAnything(schema) {
+  return schema === true || (isObject(schema) && Object.keys(schema).length === 0);
 }
 
 module.exports = {

package/lib/model/modelClone.js

@@ -81,8 +81,6 @@ function cloneObject(value) {
     return cloneArray(value);
   } else if (value.$isObjectionModel) {
     return clone(value, false, false);
-  } else if (Buffer.isBuffer(value)) {
-    return new Buffer(value);
   } else {
     return cloneDeep(value);
   }

package/lib/queryBuilder/QueryBuilder.js

@@ -8,8 +8,10 @@ const { ValidationErrorType } = require('../model/ValidationError');
 const { isObject, isString, isFunction, last, flatten } = require('../utils/objectUtils');
 const { RelationExpression, DuplicateRelationError } = require('./RelationExpression');
 const { assertIdNotUndefined, assertHasIdColumn } = require('../utils/assert');
+const { warnOnce } = require('../utils/warnings');
+const { isMsSql } = require('../utils/knexUtils');
 
-const { Selection } = require('./operations/select/Selection');
+const { Selection, isSameIdentifier } = require('./operations/select/Selection');
 
 const { QueryBuilderContext } = require('./QueryBuilderContext');
 const { QueryBuilderBase } = require('./QueryBuilderBase');
@@ -44,9 +46,10 @@ const { EagerOperation } = require('./operations/eager/EagerOperation');
 const { RangeOperation } = require('./operations/RangeOperation');
 const { FirstOperation } = require('./operations/FirstOperation');
 const { NoneOperation } = require('./operations/NoneOperation');
+const { LimitPerParentOperation } = require('./operations/LimitPerParentOperation');
 const { FromOperation } = require('./operations/FromOperation');
 const { KnexOperation } = require('./operations/KnexOperation');
-const { wrapWhereGroups } = require('./whereGroups');
+const { clearUnsupportedOrder } = require('./withoutOrder');
 
 class QueryBuilder extends QueryBuilderBase {
   static init(self, modelClass) {
@@ -55,6 +58,7 @@ class QueryBuilder extends QueryBuilderBase {
     self._resultModelClass = null;
     self._explicitRejectValue = null;
     self._explicitResolveValue = null;
+    self._queryBatch = null;
     self._modifiers = {};
 
     self._allowedGraphExpression = null;
@@ -176,7 +180,7 @@ class QueryBuilder extends QueryBuilderBase {
   }
 
   isExplicitlyResolvedOrRejected() {
-    return !!(this._explicitRejectValue || this._explicitResolveValue);
+    return this._explicitRejectValue !== null || this._explicitResolveValue !== null;
   }
 
   isExecutable() {
@@ -256,12 +260,27 @@ class QueryBuilder extends QueryBuilderBase {
     // The `joinOperation` option only applies to the relations of this call,
     // see `RelationJoiner`. All other options are shared by all calls.
     const { joinOperation, ...graphOptions } = options;
+    const isJoined = eagerOp instanceof JoinEagerOperation;
 
     eagerOp.expression = eagerOp.expression.merge(parsedExp);
     eagerOp.graphOptions = { ...eagerOp.graphOptions, ...graphOptions };
 
     if (joinOperation) {
-      eagerOp.joinOperations.push({ expression: parsedExp, joinOperation });
+      if (isJoined) {
+        eagerOp.joinOperations.push({ expression: parsedExp, joinOperation });
+      } else {
+        warnOnce(
+          'The joinOperation option only applies to withGraphJoined() and is ignored for the ' +
+            `fetched relations "${parsedExp.toString()}".`,
+        );
+      }
+    }
+
+    if (graphOptions.limitPerParent && isJoined) {
+      warnOnce(
+        'The limitPerParent option only applies to withGraphFetched() and is ignored for the ' +
+          `joined relations "${parsedExp.toString()}".`,
+      );
     }
 
     checkMixedEager(this);
@@ -379,7 +398,7 @@ class QueryBuilder extends QueryBuilderBase {
     return this.everyOperation((op) => {
       if (op.constructor === SelectOperation) {
         // SelectOperations with zero selections are the ones that only have
-        // raw items or other non-trivial selections.
+        // raw items or other non-trivial selections, or `distinctOn()`.
         return (
           op.selections.length > 0 &&
           op.selections.every((select) => {
@@ -498,20 +517,38 @@ class QueryBuilder extends QueryBuilderBase {
 
     if (joinEagerOp) {
       // `withGraphJoined` needs the table metadata to build its selects.
-      await joinEagerOp.onBefore3(builder);
+      await joinEagerOp.fetchTableMetadata(builder);
+
+      // To-many joins return one row per joined child, so the root models are
+      // counted by their distinct ids, see below.
+      if (joinEagerOp.joiner.hasToManyJoins(builder)) {
+        assertHasIdColumn(builder.modelClass());
+      }
     }
 
-    const countQuery = knex.count('* as count').from((knexBuilder) => {
-      // 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`.
-      knexBuilder = builder.toKnexQuery(knexBuilder).clearOrder();
+    const idColumns = builder.modelClass().getIdColumnArray();
+
+    // Also clear the order on the built knex query, since `orderBy` calls
+    // can be added at build time, e.g. by a relation's `modify`.
+    const buildQuery = (knexBuilder) => builder.toKnexQuery(knexBuilder).clearOrder();
 
-      if (joinEagerOp) {
-        // The joins of `withGraphJoined` return one row per joined child.
-        // Count the distinct root models instead.
+    const countQuery = knex.count('* as count').from((knexBuilder) => {
+      if (!joinEagerOp || idColumns.length === 0) {
+        // Without ids, the joins are all to-one and return one row per root
+        // model.
+        buildQuery(knexBuilder);
+      } else if (refersToSelections(builder)) {
+        // `having`, and `groupBy` with an alias, may refer to aliased
+        // selections, so keep them and select the distinct ids from the
+        // result instead.
+        knexBuilder.distinct(idColumns).from((knexBuilder) => {
+          buildQuery(knexBuilder).as('inner');
+        });
+      } else {
         const tableRef = builder.tableRef();
-        const idColumns = builder.modelClass().getIdColumnArray();
-        knexBuilder.clearSelect().distinct(idColumns.map((col) => `${tableRef}.${col}`));
+        buildQuery(knexBuilder)
+          .clearSelect()
+          .distinct(idColumns.map((col) => `${tableRef}.${col}`));
       }
 
       knexBuilder.as('temp');
@@ -563,7 +600,7 @@ class QueryBuilder extends QueryBuilderBase {
     let selectionInstance = null;
 
     this.forEachOperation(true, (op) => {
-      if (op.constructor === SelectOperation) {
+      if (op.constructor === SelectOperation && !op.isDistinctOn) {
         selectionInstance = op.findSelection(this, selection);
         noSelectStatements = false;
 
@@ -615,9 +652,9 @@ class QueryBuilder extends QueryBuilderBase {
     } else {
       if (foundSelection.column === '*') {
         // * selects the columns with their column names as aliases.
-        return selection.column === alias;
+        return isSameIdentifier(this, selection.column, alias);
       } else {
-        return foundSelection.name === alias;
+        return isSameIdentifier(this, foundSelection.name, alias);
       }
     }
   }
@@ -1171,6 +1208,29 @@ function getEagerAlgorithmByName(builder, name) {
   }
 }
 
+// Returns true if the `having` or `groupBy` clauses of `builder` may refer to
+// aliased selections (#2329).
+function refersToSelections(builder) {
+  if (builder.has(/having/)) {
+    return true;
+  }
+
+  const aliases = builder
+    .findAllSelections()
+    .map((selection) => selection.alias)
+    .filter((alias) => !!alias);
+
+  let refersToAlias = false;
+
+  builder.forEachOperation(/^groupBy$/, (op) => {
+    if (flatten(op.args).some((arg) => aliases.includes(arg))) {
+      refersToAlias = true;
+    }
+  });
+
+  return refersToAlias;
+}
+
 function getEagerAlgorithmOfOperation(builder, eagerOp) {
   if (eagerOp instanceof JoinEagerOperation) {
     return getJoinEagerAlgorithm(builder);
@@ -1198,7 +1258,8 @@ function groupByEagerAlgorithm(builder, expression) {
 
   for (const childName of node.$childNames) {
     const eagerOp = findEagerOperations(builder).find(
-      (op) => op.expression.node.$allRecursive || op.expression.node[childName],
+      (op) =>
+        op.expression.node.$allRecursive || op.expression.node.$childNames.includes(childName),
     );
 
     const algorithm = eagerOp ? getEagerAlgorithmOfOperation(builder, eagerOp) : defaultAlgorithm;
@@ -1279,14 +1340,14 @@ function checkMixedEager(builder) {
 
   if (joinNode.$allRecursive || fetchNode.$allRecursive) {
     throw new Error(
-      'relation expression `*` cannot be used when mixing withGraphJoined and withGraphFetched',
+      'relation expression "*" cannot be used when mixing withGraphJoined and withGraphFetched',
     );
   }
 
   for (const childName of joinNode.$childNames) {
     if (fetchNode.$childNames.includes(childName)) {
       throw new Error(
-        `relation \`${childName}\` cannot be loaded with both withGraphJoined and withGraphFetched`,
+        `relation "${childName}" cannot be loaded with both withGraphJoined and withGraphFetched`,
       );
     }
   }
@@ -1336,10 +1397,13 @@ function beforeExecute(builder) {
   return promise;
 }
 
-function doExecute(builder) {
+async function doExecute(builder) {
   let promise = Promise.resolve();
 
   builder = callOnBuildHooks(builder);
+  // Unlike `onBuild`, `onAfterBuild` can be async, as it only runs when the
+  // query is executed, not when it's only built, e.g. with `toKnexQuery()`:
+  await chainOperationHooks(promise, builder, 'onAfterBuild');
   const queryExecutorOperation = findQueryExecutorOperation(builder);
 
   const explicitRejectValue = builder._explicitRejectValue;
@@ -1352,7 +1416,7 @@ function doExecute(builder) {
   } else if (queryExecutorOperation !== null) {
     promise = Promise.resolve(queryExecutorOperation.queryExecutor(builder));
   } else {
-    promise = Promise.resolve(buildKnexQuery(builder));
+    promise = executeKnexQuery(builder);
 
     promise = chainOperationHooks(promise, builder, 'onRawResult');
     promise = promise.then((result) => createModels(result, builder));
@@ -1361,6 +1425,30 @@ function doExecute(builder) {
   return promise;
 }
 
+// An operation can split the query into batches, e.g. to stay below the number
+// of values a database accepts in one statement. Build and execute the knex
+// query once per batch then, with the operation reading the current batch from
+// `builder._queryBatch`, and merge the counts or rows of all batches.
+async function executeKnexQuery(builder) {
+  const operation = builder.findOperation((op) => op.hasQueryBatches());
+  const batches = operation?.queryBatches(builder);
+
+  if (batches) {
+    const results = [];
+
+    for (const batch of batches) {
+      builder._queryBatch = batch;
+      results.push(await buildKnexQuery(builder));
+    }
+
+    return results.reduce((merged, result) =>
+      Array.isArray(merged) ? merged.concat(result) : merged + result,
+    );
+  } else {
+    return buildKnexQuery(builder);
+  }
+}
+
 function afterExecute(builder, result) {
   let promise = Promise.resolve(result);
 
@@ -1514,7 +1602,13 @@ function callOnBuildHooks(builder) {
   callOnBuildFuncs(builder, builder.internalContext().onBuild);
 
   builder.executeOnBuild();
-  return wrapWhereGroups(builder);
+
+  // Clear the order after all hooks, as any of them may add one.
+  if (builder.isUpdate()) {
+    clearUnsupportedOrder(builder);
+  }
+
+  return builder;
 }
 
 function callOnBuildFuncs(builder, func) {
@@ -1549,6 +1643,12 @@ function buildKnexQuery(builder, knexBuilder = builder.knex().queryBuilder()) {
     }
   }
 
+  const limitPerParentOperation = builder.findOperation(LimitPerParentOperation);
+
+  if (limitPerParentOperation) {
+    knexBuilder = limitPerParentOperation.onAfterBuildKnex(knexBuilder, builder);
+  }
+
   return knexBuilder;
 }
 
@@ -1558,6 +1658,10 @@ function setDefaultTable(builder, knexBuilder) {
 
   if (table === tableRef) {
     return knexBuilder.table(table);
+  } else if (isMsSql(builder.knex()) && (builder.isUpdate() || builder.isDelete())) {
+    // SQL Server can't alias the table of updates and deletes, but it can modify
+    // it through a common table expression named like the alias.
+    return knexBuilder.with(tableRef, (query) => query.select('*').from(table)).table(tableRef);
   } else {
     return knexBuilder.table(`${table} as ${tableRef}`);
   }

package/lib/queryBuilder/QueryBuilderOperationSupport.js

@@ -3,7 +3,8 @@
 const { isString, isFunction, isRegExp, mergeMaps, last } = require('../utils/objectUtils');
 const { QueryBuilderContextBase } = require('./QueryBuilderContextBase');
 const { QueryBuilderUserContext } = require('./QueryBuilderUserContext');
-const { deprecate } = require('../utils/deprecate');
+const { deprecate } = require('../utils/warnings');
+const { getWhereGroupOperations } = require('./whereGroups');
 
 const AllSelector = () => true;
 const SelectSelector =
@@ -489,8 +490,19 @@ class QueryBuilderOperationSupport {
   }
 
   executeOnBuildKnex(knexBuilder) {
-    this.forEachOperation(true, (op) => {
-      if (op.hasOnBuildKnex()) {
+    const whereGroupOps = getWhereGroupOperations(this);
+
+    // Visit the operations while building, so that operations added by
+    // `onBuildKnex` hooks are built too. Build each where group in place of its
+    // first operation, and skip the operations that the groups build.
+    this.forEachOperation(true, (it) => {
+      const op = whereGroupOps.has(it)
+        ? whereGroupOps.get(it)
+        : it.isAncestorInSet(whereGroupOps)
+          ? null
+          : it;
+
+      if (op?.hasOnBuildKnex()) {
         const newKnexBuilder = this.callOperationMethod(op, 'onBuildKnex', [knexBuilder, this]);
         // Default to the input knex builder for backwards compatibility
         // with QueryBuilder.onBuildKnex hooks.

package/lib/queryBuilder/RelationExpression.js

@@ -129,7 +129,8 @@ class RelationExpression {
       return new RelationExpression(this.node, this.recursionDepth + 1);
     }
 
-    const child = this.node[childName];
+    // Don't mistake inherited properties like `constructor` for children.
+    const child = this.node.$childNames.includes(childName) ? this.node[childName] : null;
 
     if (child) {
       return new RelationExpression(child);
@@ -292,7 +293,7 @@ function modelToNode(model, node) {
     const relName = relationNames[r];
 
     if (model[relName] !== undefined) {
-      let childNode = node[relName];
+      let childNode = node.$childNames.includes(relName) ? node[relName] : null;
 
       if (!childNode) {
         childNode = newNode(relName);
@@ -402,8 +403,9 @@ function mergeNodes(node1, node2) {
     node.$childNames = union(node1.$childNames, node2.$childNames);
 
     for (const childName of node.$childNames) {
-      const child1 = node1[childName];
-      const child2 = node2[childName];
+      // Don't mistake inherited properties like `constructor` for children.
+      const child1 = node1.$childNames.includes(childName) ? node1[childName] : null;
+      const child2 = node2.$childNames.includes(childName) ? node2[childName] : null;
 
       if (child1 && child2) {
         node[childName] = mergeNodes(child1, child2);