objection 3.9.0 → 4.0.0-rc.1

package/lib/queryBuilder/parsers/relationExpressionParser.pegjs

@@ -1,19 +1,37 @@
-{{
-  const { warnOnce } = require('../../utils/warnings');
-}}
-
 {
-  function assertDuplicateRelation(node, expr) {
+  function addChild(node, expr) {
+    if (isToken(expr.$relation)) {
+      throwMisplacedToken(expr.$relation);
+    }
+
     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.`);
+      const err = new Error();
+      err.duplicateRelationName = expr.$name;
+      throw err;
+    }
+
+    node[expr.$name] = expr;
+    node.$childNames.push(expr.$name);
+  }
+
+  // `*` and `^` end a relation path, without modifiers, aliases or relations
+  // after them.
+  function isToken(name) {
+    return /^(\*|\^\d*)$/.test(name);
+  }
 
-      // Throws in objection 4.0, see ditojs/objection#53.
-      // const err = new Error();
-      // err.duplicateRelationName = expr.$name;
-      // throw err;
+  function assertPlainToken(expr) {
+    if (expr.$childNames.length > 0 || expr.$modify.length > 0 || expr.$name !== expr.$relation) {
+      throwMisplacedToken(expr.$relation);
     }
   }
 
+  function throwMisplacedToken(token) {
+    const err = new Error();
+    err.misplacedToken = token;
+    throw err;
+  }
+
   function newNode() {
     return {
       $name: null,
@@ -30,12 +48,11 @@ start =
   expr:expression {
     const node = newNode()
 
-    if (expr.$name === '*') {
+    if (expr.$relation === '*') {
+      assertPlainToken(expr);
       node.$allRecursive = true;
     } else {
-      assertDuplicateRelation(node, expr);
-      node[expr.$name] = expr;
-      node.$childNames.push(expr.$name)
+      addChild(node, expr);
     }
 
     return node;
@@ -44,11 +61,7 @@ start =
   list:listExpression {
     const node = newNode()
 
-    list.forEach(expr => {
-      assertDuplicateRelation(node, expr);
-      node[expr.$name] = expr;
-      node.$childNames.push(expr.$name)
-    });
+    list.forEach(expr => addChild(node, expr));
 
     return node;
   }
@@ -61,11 +74,7 @@ expression =
     node.$relation = name;
     node.$modify = args || [];
 
-    list.forEach(expr => {
-      assertDuplicateRelation(node, expr);
-      node[expr.$name] = expr;
-      node.$childNames.push(expr.$name)
-    });
+    list.forEach(expr => addChild(node, expr));
 
     return node;
   }
@@ -78,20 +87,14 @@ expression =
     node.$modify = args || [];
 
     if (expr) {
-      const match = /^\^(\d*)$/.exec(expr.$name);
-
-      if (match) {
-        if (match[1]) {
-          node.$recursive = parseInt(match[1], 10);
-        } else {
-          node.$recursive = true;
-        }
-      } else if (expr.$name === '*') {
+      if (expr.$relation === '*') {
+        assertPlainToken(expr);
         node.$allRecursive = true;
+      } else if (isToken(expr.$relation)) {
+        assertPlainToken(expr);
+        node.$recursive = expr.$relation === '^' ? true : parseInt(expr.$relation.slice(1), 10);
       } else {
-        assertDuplicateRelation(node, expr);
-        node[expr.$name] = expr;
-        node.$childNames.push(expr.$name)
+        addChild(node, expr);
       }
     }
 

package/lib/queryBuilder/transformations/CompositeQueryTransformation.js

@@ -1,8 +1,6 @@
-'use strict';
+import { QueryTransformation } from './QueryTransformation.js';
 
-const { QueryTransformation } = require('./QueryTransformation');
-
-class CompositeQueryTransformation extends QueryTransformation {
+export class CompositeQueryTransformation extends QueryTransformation {
   constructor(transformations) {
     super();
     this.transformations = transformations;
@@ -16,7 +14,3 @@ class CompositeQueryTransformation extends QueryTransformation {
     return item;
   }
 }
-
-module.exports = {
-  CompositeQueryTransformation,
-};

package/lib/queryBuilder/transformations/QueryTransformation.js

@@ -1,11 +1,5 @@
-'use strict';
-
-class QueryTransformation {
+export class QueryTransformation {
   onConvertQueryBuilderBase(item, builder) {
     return item;
   }
 }
-
-module.exports = {
-  QueryTransformation,
-};

package/lib/queryBuilder/transformations/WrapMysqlModifySubqueryTransformation.js

@@ -1,7 +1,5 @@
-'use strict';
-
-const { QueryTransformation } = require('./QueryTransformation');
-const { isMySql } = require('../../utils/knexUtils');
+import { QueryTransformation } from './QueryTransformation.js';
+import { isMySql } from '../../utils/knexUtils.js';
 
 /**
  * Mysql doesn't allow queries like this:
@@ -15,7 +13,7 @@ const { isMySql } = require('../../utils/knexUtils');
  *
  *   update foo set bar = 1 where id in (select * from (select id from foo))
  */
-class WrapMysqlModifySubqueryTransformation extends QueryTransformation {
+export class WrapMysqlModifySubqueryTransformation extends QueryTransformation {
   onConvertQueryBuilderBase(query, parentQuery) {
     const knex = parentQuery.unsafeKnex();
 
@@ -66,7 +64,3 @@ function hasJoinsToTable(query, tableName) {
 
   return found;
 }
-
-module.exports = {
-  WrapMysqlModifySubqueryTransformation,
-};

package/lib/queryBuilder/transformations/index.js

@@ -1,15 +1,7 @@
-'use strict';
+import { CompositeQueryTransformation } from './CompositeQueryTransformation.js';
 
-const { CompositeQueryTransformation } = require('./CompositeQueryTransformation');
+import { WrapMysqlModifySubqueryTransformation } from './WrapMysqlModifySubqueryTransformation.js';
 
-const {
-  WrapMysqlModifySubqueryTransformation,
-} = require('./WrapMysqlModifySubqueryTransformation');
-
-const transformation = new CompositeQueryTransformation([
+export const transformation = new CompositeQueryTransformation([
   new WrapMysqlModifySubqueryTransformation(),
 ]);
-
-module.exports = {
-  transformation,
-};

package/lib/queryBuilder/whereGroups.js

@@ -1,15 +1,13 @@
-'use strict';
-
-const { WhereGroupOperation } = require('./operations/WhereGroupOperation');
-const { isObject, isFunction } = require('../utils/objectUtils');
-const { isKnexRaw } = require('../utils/knexUtils');
+import { WhereGroupOperation } from './operations/WhereGroupOperation.js';
+import { isObject, isFunction } from '../utils/objectUtils.js';
+import { isKnexRaw } from '../utils/knexUtils.js';
 
 // Where operations of a query can come from different sources: the user, a
 // 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.
+// condition of `findById()`, `findByIds()` and `$query()` and so on. Each
+// source forms its own "where group". All other 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
@@ -22,7 +20,7 @@ const { isKnexRaw } = require('../utils/knexUtils');
 // 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) {
+export function addWhereGroup(builder, callback) {
   const parentWhereGroup = builder._whereGroup;
   builder._whereGroup = {};
 
@@ -33,17 +31,10 @@ function addWhereGroup(builder, callback) {
   }
 }
 
-// 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) {
+export function getWhereGroupOperations(builder) {
   const WhereSelector = builder.constructor.WhereSelector;
   const whereOps = new Set();
   const groups = new Map();
@@ -112,9 +103,3 @@ function mayContainTopLevelOr(op) {
 function isRaw(arg) {
   return isKnexRaw(arg) || (isObject(arg) && isFunction(arg.toKnexRaw));
 }
-
-module.exports = {
-  addWhereGroup,
-  assignWhereGroup,
-  getWhereGroupOperations,
-};

package/lib/queryBuilder/withoutOrder.js

@@ -1,19 +1,17 @@
-'use strict';
-
-const { FirstOperation } = require('./operations/FirstOperation');
-const { isMsSql } = require('../utils/knexUtils');
+import { FirstOperation } from './operations/FirstOperation.js';
+import { isMsSql } from '../utils/knexUtils.js';
 
 // 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) {
+export 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) {
+export function clearUnsupportedOrder(builder) {
   if (isMsSql(builder.knex()) && !hasLimit(builder)) {
     builder.clearOrder();
   }
@@ -26,8 +24,3 @@ function hasLimit(builder) {
     builder.findOperation(FirstOperation)?.shouldLimit(builder)
   );
 }
-
-module.exports = {
-  withoutOrder,
-  clearUnsupportedOrder,
-};

package/lib/relations/Relation.js

@@ -1,19 +1,17 @@
-'use strict';
+import { RelationProperty } from './RelationProperty.js';
 
-const { RelationProperty } = require('./RelationProperty');
+import { RelationFindOperation } from './RelationFindOperation.js';
+import { RelationUpdateOperation } from './RelationUpdateOperation.js';
+import { RelationDeleteOperation } from './RelationDeleteOperation.js';
 
-const { RelationFindOperation } = require('./RelationFindOperation');
-const { RelationUpdateOperation } = require('./RelationUpdateOperation');
-const { RelationDeleteOperation } = require('./RelationDeleteOperation');
+import { resolveModel } from '../utils/resolveModel.js';
+import { get, isFunction } from '../utils/objectUtils.js';
+import { mapAfterAllReturn } from '../utils/promiseUtils/index.js';
+import { createModifier } from '../utils/createModifier.js';
+import { addWhereGroup } from '../queryBuilder/whereGroups.js';
+import { withoutOrder } from '../queryBuilder/withoutOrder.js';
 
-const { resolveModel } = require('../utils/resolveModel');
-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 {
+export class Relation {
   constructor(relationName, OwnerClass) {
     this.name = relationName;
     this.ownerModelClass = OwnerClass;
@@ -84,10 +82,11 @@ class Relation {
     return false;
   }
 
-  // Whether owner models may legitimately lack the owner join property at
-  // `index`, so that it isn't reported as missing (#132).
-  isOptionalOwnerProp(_index) {
-    return false;
+  // Where the keys that connect owners and related models are stored: in the
+  // `'owner'` rows, the `'related'` rows or the rows of a `'join'` table. Owners
+  // of relations that aren't one-to-one hold arrays of keys.
+  get keySide() {
+    throw new Error('not implemented');
   }
 
   clone() {
@@ -151,6 +150,7 @@ class Relation {
       relatedJoinSelectQuery = this.relatedModelClass.query().childQueryOf(builder),
       relatedTable = builder.tableNameFor(this.relatedModelClass),
       ownerTable = builder.tableRefFor(this.ownerModelClass),
+      modifyJoin,
     } = {},
   ) {
     let relatedJoinSelect = this.applyModify(relatedJoinSelectQuery).as(relatedTableAlias);
@@ -163,18 +163,41 @@ class Relation {
     }
 
     return builder[joinOperation](relatedJoinSelect, (join) => {
-      const relatedProp = this.relatedProp;
-      const ownerProp = this.ownerProp;
+      this.joinOn(builder, join, { relatedTableAlias, ownerTable });
 
-      relatedProp.forEach((i) => {
-        const relatedRef = relatedProp.ref(builder, i).table(relatedTableAlias);
-        const ownerRef = ownerProp.ref(builder, i).table(ownerTable);
+      if (modifyJoin) {
+        this._applyModifyJoin(join, modifyJoin, { owner: ownerTable, related: relatedTableAlias });
+      }
+    });
+  }
 
-        join.on(relatedRef, ownerRef);
-      });
+  // @overridable
+  joinOn(builder, join, { relatedTableAlias, ownerTable }) {
+    const relatedProp = this.relatedProp;
+    const ownerProp = this.ownerProp;
+
+    relatedProp.forEach((i) => {
+      const relatedRef = relatedProp.ref(builder, i).table(relatedTableAlias);
+      const ownerRef = ownerProp.ref(builder, i).table(ownerTable);
+
+      join.on(relatedRef, ownerRef);
     });
   }
 
+  // Group the conditions of `modifyJoin()`, so that an `orOn` in them can't
+  // escape the key conditions of the relation. Knex renders an empty group as
+  // a dangling `and`, so we only add it if there are conditions.
+  _applyModifyJoin(join, modifyJoin, aliases) {
+    const group = join.clone().clear(true);
+    modifyJoin(group, aliases);
+
+    if (group.has(true)) {
+      join.andOn(function () {
+        this.copyFrom(group, true);
+      });
+    }
+  }
+
   find(_, owner) {
     return new RelationFindOperation('find', {
       relation: this,
@@ -406,7 +429,3 @@ function aliasedTableName(tableName, alias) {
     return `${tableName} as ${alias}`;
   }
 }
-
-module.exports = {
-  Relation,
-};

package/lib/relations/RelationDeleteOperation.js

@@ -1,9 +1,6 @@
-'use strict';
+import { DeleteOperation } from '../queryBuilder/operations/DeleteOperation.js';
 
-const { DeleteOperation } = require('../queryBuilder/operations/DeleteOperation');
-const { RelationFindOperation } = require('./RelationFindOperation');
-
-class RelationDeleteOperation extends DeleteOperation {
+export class RelationDeleteOperation extends DeleteOperation {
   constructor(name, opt) {
     super(name, opt);
 
@@ -16,14 +13,7 @@ class RelationDeleteOperation extends DeleteOperation {
     this.relation.findQuery(builder, this.owner);
   }
 
-  toFindOperation() {
-    return new RelationFindOperation('find', {
-      relation: this.relation,
-      owner: this.owner,
-    });
+  toFindOperation(builder) {
+    return this.relation.find(builder, this.owner);
   }
 }
-
-module.exports = {
-  RelationDeleteOperation,
-};