objection 3.6.0 → 3.8.0

package/lib/queryBuilder/operations/LimitPerParentOperation.js

@@ -0,0 +1,145 @@
+'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');
+
+// 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.
+      const numberedQuery = knex
+        .queryBuilder()
+        .select('*')
+        .rowNumber(rowNumberColumn, (window) =>
+          window
+            .orderBy(getWindowOrder(builder, knex))
+            .partitionBy(this.findOperation.ownerKeyColumns()),
+        )
+        .from(
+          knexBuilder
+            .clone()
+            .clear('with')
+            .clear('limit')
+            .clear('offset')
+            .clear('order')
+            .as(builder.tableRef()),
+        );
+
+      // 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.
+function getWindowOrder(builder, knex) {
+  const order = [];
+
+  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) {
+        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(item.column) ? knex.ref(item.column) : item.column,
+            ]),
+            order: item.nulls === 'first' ? 'asc' : 'desc',
+          });
+        }
+
+        // Unlike in `orderBy()`, knex adds the direction to the window as it is:
+        order.push({ column: item.column, 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,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');
@@ -14,6 +17,7 @@ class UpdateOperation extends QueryBuilderOperation {
 
     this.model = null;
     this.modelOptions = Object.assign({}, this.opt.modelOptions || {});
+    this.hasNothingToUpdate = false;
   }
 
   onAdd(builder, args) {
@@ -34,10 +38,19 @@ class UpdateOperation extends QueryBuilderOperation {
 
     if (isEmpty(row)) {
       // Resolve the query if there is nothing to update.
+      this.hasNothingToUpdate = !builder.isExplicitlyResolvedOrRejected();
       builder.resolve(0);
     }
   }
 
+  // Returns true if the query was resolved without updating anything, e.g.
+  // with `none()` or `resolve()` in a hook, but not if it was only resolved
+  // because there is nothing to update in the table, as the update still
+  // applies to everything else (#2184).
+  isResolvedWithoutUpdate(builder) {
+    return builder.isExplicitlyResolvedOrRejected() && !this.hasNothingToUpdate;
+  }
+
   onBuildKnex(knexBuilder, builder) {
     const json = this.model.$toDatabaseJson(builder);
     const convertedJson = convertFieldExpressionsToRaw(builder, this.model, json);
@@ -56,6 +69,7 @@ class UpdateOperation extends QueryBuilderOperation {
   clone() {
     const clone = super.clone();
     clone.model = this.model;
+    clone.hasNothingToUpdate = this.hasNothingToUpdate;
     return clone;
   }
 }
@@ -96,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);
@@ -130,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/operations/whereInComposite/WhereInCompositeMsSqlOperation.js

@@ -42,7 +42,9 @@ class WhereInCompositeMsSqlOperation extends ObjectionToKnexConvertingOperation
         knexBuilder,
         columns,
         helperColumns,
-        values.as(knex.raw(`V(${helperColumns.map((_) => '??')})`, helperColumns)),
+        // knex only accepts strings as aliases, so the subquery is aliased in
+        // a raw query.
+        knex.raw(`? AS V(${helperColumns.map((_) => '??')})`, [values, ...helperColumns]),
       );
     }
   }

package/lib/queryBuilder/operations/whereInComposite/WhereInCompositeSqliteOperation.js

@@ -48,18 +48,13 @@ function isCompositeKey(columns) {
 }
 
 function buildCompositeArgs(columns, values) {
-  if (!Array.isArray(values)) {
-    // If the `values` is not an array of values but a function or a subquery
-    // we have no way to implement this method.
-    throw new Error(`sqlite doesn't support multi-column where in clauses`);
-  }
-
-  if (values.length === 0) {
+  if (!Array.isArray(values) || values.length === 0) {
     // knex turns an empty `whereIn` into `1 = 0` and an empty `whereNotIn`
-    // into `1 = 1`.
+    // into `1 = 1`. Subqueries are compared as row values, which sqlite
+    // supports since version 3.15.
     return {
       method: 'whereIn',
-      args: [columns, []],
+      args: [columns, values],
     };
   }
 

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);
@@ -943,12 +945,12 @@ function peg$parse(input, options) {
   }
 
   function assertDuplicateRelation(node, expr) {
-    if (expr.$name in node) {
-      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`,
+    if (Object.prototype.hasOwnProperty.call(node, expr.$name)) {
+      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 (expr.$name in node) {
-      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`);
+    if (Object.prototype.hasOwnProperty.call(node, expr.$name)) {
+      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;