objection 3.2.0 → 3.4.0

package/lib/queryBuilder/QueryBuilder.js

@@ -1,13 +1,13 @@
 'use strict';
 
-const { wrapError } = require('db-errors');
+const { wrapDbError } = require('../utils/wrapDbError');
 
 const { raw } = require('./RawBuilder');
 const { createModifier } = require('../utils/createModifier');
 const { ValidationErrorType } = require('../model/ValidationError');
 const { isObject, isString, isFunction, last, flatten } = require('../utils/objectUtils');
 const { RelationExpression, DuplicateRelationError } = require('./RelationExpression');
-const { assertIdNotUndefined } = require('../utils/assert');
+const { assertIdNotUndefined, assertHasIdColumn } = require('../utils/assert');
 
 const { Selection } = require('./operations/select/Selection');
 
@@ -46,6 +46,7 @@ const { FirstOperation } = require('./operations/FirstOperation');
 const { NoneOperation } = require('./operations/NoneOperation');
 const { FromOperation } = require('./operations/FromOperation');
 const { KnexOperation } = require('./operations/KnexOperation');
+const { wrapWhereGroups } = require('./whereGroups');
 
 class QueryBuilder extends QueryBuilderBase {
   static init(self, modelClass) {
@@ -58,8 +59,12 @@ class QueryBuilder extends QueryBuilderBase {
 
     self._allowedGraphExpression = null;
     self._graphModifiersAtPath = [];
+    // The eager algorithm that was most recently used explicitly, see `withGraph()`.
+    self._graphAlgorithm = null;
+    self._isJoinChildQuery = false;
     self._findOperationOptions = modelClass.defaultFindOptions;
     self._relatedQueryFor = null;
+    self._internalSelections = new Set();
 
     self._findOperationFactory = findOperationFactory;
     self._insertOperationFactory = insertOperationFactory;
@@ -78,6 +83,27 @@ class QueryBuilder extends QueryBuilderBase {
     return RelationExpression.create(expr).toPojo();
   }
 
+  childQueryOf(query, options = {}) {
+    super.childQueryOf(query, options);
+
+    if (query) {
+      this._isJoinChildQuery = !!options.isJoinChildQuery;
+
+      if (query.isObjectionQueryBuilder) {
+        this._graphAlgorithm = query._graphAlgorithm;
+      }
+    }
+
+    return this;
+  }
+
+  // Returns true if this query was created for a relation that is loaded using
+  // `withGraphJoined()`. Such queries are only used to build the join and are
+  // never executed themselves.
+  isJoinChildQuery() {
+    return this._isJoinChildQuery;
+  }
+
   tableNameFor(modelClassOrTableName, newTableName) {
     return super.tableNameFor(getTableName(modelClassOrTableName), newTableName);
   }
@@ -99,6 +125,8 @@ class QueryBuilder extends QueryBuilderBase {
   }
 
   fullIdColumnFor(modelClass) {
+    assertHasIdColumn(modelClass);
+
     const tableName = this.tableRefFor(modelClass);
     const idColumn = modelClass.getIdColumn();
 
@@ -191,19 +219,50 @@ class QueryBuilder extends QueryBuilderBase {
   }
 
   withGraphFetched(exp, options = {}) {
-    return this._withGraph(exp, options, getWhereInEagerAlgorithm(this));
+    return this._withGraphUsing(exp, options, getWhereInEagerAlgorithm(this));
   }
 
   withGraphJoined(exp, options = {}) {
-    return this._withGraph(exp, options, getJoinEagerAlgorithm(this));
+    return this._withGraphUsing(exp, options, getJoinEagerAlgorithm(this));
+  }
+
+  // Like `withGraphFetched()` or `withGraphJoined()` with `options.algorithm`
+  // set to 'fetch' or 'join'. Without it, the top-level relations that are
+  // already loaded by one of the algorithms are merged into it, and new ones
+  // use the most recently used algorithm.
+  withGraph(exp, { algorithm, ...options } = {}) {
+    if (algorithm !== undefined) {
+      return this._withGraphUsing(exp, options, getEagerAlgorithmByName(this, algorithm));
+    }
+
+    const parsedExp = parseRelationExpression(this.modelClass(), exp);
+
+    for (const [algorithm, groupExp] of groupByEagerAlgorithm(this, parsedExp)) {
+      this._withGraph(groupExp, options, algorithm);
+    }
+
+    return this;
+  }
+
+  _withGraphUsing(exp, options, algorithm) {
+    this._graphAlgorithm = algorithm;
+    return this._withGraph(exp, options, algorithm);
   }
 
   _withGraph(exp, options, algorithm) {
     const eagerOp = ensureEagerOperation(this, algorithm);
     const parsedExp = parseRelationExpression(this.modelClass(), exp);
 
+    // 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;
+
     eagerOp.expression = eagerOp.expression.merge(parsedExp);
-    eagerOp.graphOptions = { ...eagerOp.graphOptions, ...options };
+    eagerOp.graphOptions = { ...eagerOp.graphOptions, ...graphOptions };
+
+    if (joinOperation) {
+      eagerOp.joinOperations.push({ expression: parsedExp, joinOperation });
+    }
 
     checkMixedEager(this);
     checkEager(this);
@@ -355,6 +414,8 @@ class QueryBuilder extends QueryBuilderBase {
 
     builder._allowedGraphExpression = this._allowedGraphExpression;
     builder._graphModifiersAtPath = this._graphModifiersAtPath.slice();
+    builder._graphAlgorithm = this._graphAlgorithm;
+    builder._isJoinChildQuery = this._isJoinChildQuery;
     builder._findOperationOptions = this._findOperationOptions;
     builder._relatedQueryFor = this._relatedQueryFor;
 
@@ -376,8 +437,17 @@ class QueryBuilder extends QueryBuilderBase {
     return builder;
   }
 
+  // Registers a property of the result models that was selected internally,
+  // e.g. by an eager operation, without the user asking for it. Such properties
+  // are omitted from the result models before `runAfter` hooks are called.
+  addInternalSelection(prop) {
+    this._internalSelections.add(prop);
+    return this;
+  }
+
   clearWithGraph() {
     this.clear(EagerOperation);
+    this._graphAlgorithm = null;
     return this;
   }
 
@@ -424,11 +494,27 @@ class QueryBuilder extends QueryBuilderBase {
   async resultSize() {
     const knex = this.knex();
     const builder = this.clone().clear(/orderBy|offset|limit/);
+    const joinEagerOp = builder.findOperation(JoinEagerOperation);
+
+    if (joinEagerOp) {
+      // `withGraphJoined` needs the table metadata to build its selects.
+      await joinEagerOp.onBefore3(builder);
+    }
 
     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`.
-      builder.toKnexQuery(knexBuilder).clearOrder().as('temp');
+      knexBuilder = builder.toKnexQuery(knexBuilder).clearOrder();
+
+      if (joinEagerOp) {
+        // The joins of `withGraphJoined` return one row per joined child.
+        // Count the distinct root models instead.
+        const tableRef = builder.tableRef();
+        const idColumns = builder.modelClass().getIdColumnArray();
+        knexBuilder.clearSelect().distinct(idColumns.map((col) => `${tableRef}.${col}`));
+      }
+
+      knexBuilder.as('temp');
     });
 
     if (this.internalOptions().debug) {
@@ -891,6 +977,26 @@ class QueryBuilder extends QueryBuilderBase {
     return this;
   }
 
+  updateById(id, modelOrObject) {
+    return this.findById(id)
+      .update(modelOrObject)
+      .runBefore((_, builder) => {
+        if (!builder.internalOptions().skipUndefined) {
+          assertIdNotUndefined(id, `undefined was passed to updateById`);
+        }
+      });
+  }
+
+  patchById(id, modelOrObject) {
+    return this.findById(id)
+      .patch(modelOrObject)
+      .runBefore((_, builder) => {
+        if (!builder.internalOptions().skipUndefined) {
+          assertIdNotUndefined(id, `undefined was passed to patchById`);
+        }
+      });
+  }
+
   deleteById(id) {
     return this.findById(id)
       .delete()
@@ -1055,6 +1161,66 @@ function getGraphExpression(builder) {
   );
 }
 
+function getEagerAlgorithmByName(builder, name) {
+  if (name === 'fetch') {
+    return getWhereInEagerAlgorithm(builder);
+  } else if (name === 'join') {
+    return getJoinEagerAlgorithm(builder);
+  } else {
+    throw new Error(`unknown graph algorithm "${name}", expected "fetch" or "join"`);
+  }
+}
+
+function getEagerAlgorithmOfOperation(builder, eagerOp) {
+  if (eagerOp instanceof JoinEagerOperation) {
+    return getJoinEagerAlgorithm(builder);
+  } else if (eagerOp instanceof NaiveEagerOperation) {
+    return getNaiveEagerAlgorithm(builder);
+  } else {
+    return getWhereInEagerAlgorithm(builder);
+  }
+}
+
+// Splits `expression` by its top-level relations into one expression per eager
+// algorithm. Relations that are already loaded by one of the eager operations
+// keep its algorithm, new ones use the most recently used one.
+function groupByEagerAlgorithm(builder, expression) {
+  const defaultAlgorithm = builder._graphAlgorithm || getWhereInEagerAlgorithm(builder);
+  const { node } = expression;
+  const rootProps = {};
+  const groups = new Map();
+
+  for (const key of Object.keys(node)) {
+    if (key.startsWith('$')) {
+      rootProps[key] = node[key];
+    }
+  }
+
+  for (const childName of node.$childNames) {
+    const eagerOp = findEagerOperations(builder).find(
+      (op) => op.expression.node.$allRecursive || op.expression.node[childName],
+    );
+
+    const algorithm = eagerOp ? getEagerAlgorithmOfOperation(builder, eagerOp) : defaultAlgorithm;
+    let group = groups.get(algorithm);
+
+    if (!group) {
+      group = { ...rootProps, $childNames: [] };
+      groups.set(algorithm, group);
+    }
+
+    group.$childNames.push(childName);
+    group[childName] = node[childName];
+  }
+
+  if (groups.size === 0) {
+    // No top-level relations, e.g. `*` or an empty expression.
+    return [[defaultAlgorithm, expression]];
+  }
+
+  return [...groups].map(([algorithm, group]) => [algorithm, RelationExpression.create(group)]);
+}
+
 function getWhereInEagerAlgorithm(builder) {
   return builder.modelClass().WhereInEagerAlgorithm;
 }
@@ -1200,6 +1366,7 @@ function afterExecute(builder, result) {
 
   promise = chainOperationHooks(promise, builder, 'onAfter1');
   promise = chainOperationHooks(promise, builder, 'onAfter2');
+  promise = promise.then((result) => omitInternalSelections(builder, result));
 
   promise = chainHooks(promise, builder, builder.context().runAfter);
   promise = chainHooks(promise, builder, builder.internalContext().runAfter);
@@ -1209,6 +1376,22 @@ function afterExecute(builder, result) {
   return promise;
 }
 
+function omitInternalSelections(builder, result) {
+  const props = builder._internalSelections;
+
+  if (props.size && Array.isArray(result) && isObject(result[0])) {
+    const modelClass = builder.resultModelClass();
+
+    for (const model of result) {
+      for (const prop of props) {
+        modelClass.omitImpl(model, prop);
+      }
+    }
+  }
+
+  return result;
+}
+
 class ReturnImmediatelyException {
   constructor(value) {
     this.value = value;
@@ -1227,7 +1410,7 @@ function handleExecuteError(builder, err) {
     return Promise.resolve(err.value);
   }
 
-  let promise = Promise.reject(wrapError(err));
+  let promise = Promise.reject(wrapDbError(err));
 
   builder.forEachOperation(true, (op) => {
     if (op.hasOnError()) {
@@ -1331,7 +1514,7 @@ function callOnBuildHooks(builder) {
   callOnBuildFuncs(builder, builder.internalContext().onBuild);
 
   builder.executeOnBuild();
-  return builder;
+  return wrapWhereGroups(builder);
 }
 
 function callOnBuildFuncs(builder, func) {

package/lib/queryBuilder/QueryBuilderOperationSupport.js

@@ -26,6 +26,7 @@ class QueryBuilderOperationSupport {
     self._parentQuery = null;
     self._isPartialQuery = false;
     self._activeOperations = [];
+    self._whereGroup = null;
   }
 
   static forClass(modelClass) {
@@ -413,6 +414,10 @@ class QueryBuilderOperationSupport {
     const shouldAdd = this.callOperationMethod(operation, 'onAdd', [this, args]);
 
     if (shouldAdd) {
+      if (this._whereGroup) {
+        operation.whereGroup = this._whereGroup;
+      }
+
       if (this._activeOperations.length) {
         const { operation: parentOperation, hookName } = last(this._activeOperations);
         parentOperation.addChildOperation(hookName, operation);

package/lib/queryBuilder/ReferenceBuilder.js

@@ -1,6 +1,9 @@
 'use strict';
 
-const { parseFieldExpression } = require('../utils/parseFieldExpression');
+const {
+  parseFieldExpression,
+  toPostgresJsonPathLiteral,
+} = require('../utils/parseFieldExpression');
 const { isObject } = require('../utils/objectUtils');
 
 class ReferenceBuilder {
@@ -185,8 +188,7 @@ class ReferenceBuilder {
 
     if (this._parsedExpr.access.length > 0) {
       const extractor = this._cast ? '#>>' : '#>';
-      const jsonFieldRef = this._parsedExpr.access.map((field) => field.ref).join(',');
-      return `??${extractor}'{${jsonFieldRef}}'`;
+      return `??${extractor}${toPostgresJsonPathLiteral(this._parsedExpr.access)}`;
     } else {
       return '??';
     }

package/lib/queryBuilder/RelationExpression.js

@@ -355,7 +355,19 @@ function normalizeAllRecursive(node, allRecusive) {
 }
 
 function normalizeChildNames(node) {
-  return (node && node.$childNames && node.$childNames.slice()) || getChildNames(node);
+  const childNames = getChildNames(node);
+
+  if (node && node.$childNames) {
+    // The actual keys of the node are authoritative, since the node may be a
+    // modified copy of `graphExpressionObject()` with a stale `$childNames`.
+    // Keep the order of `$childNames` for the children that still exist.
+    return union(
+      node.$childNames.filter((childName) => childNames.includes(childName)),
+      childNames,
+    );
+  } else {
+    return childNames;
+  }
 }
 
 function findExpressionsAtPath(target, path, results) {

package/lib/queryBuilder/StaticHookArguments.js

@@ -24,7 +24,13 @@ class StaticHookArguments {
 
   get asFindQuery() {
     return () => {
-      return this[BUILDER_SYMBOL].toFindQuery().clearWithGraphFetched().runAfter(asArray);
+      // The `runAfter()` callbacks of the query being executed (including the
+      // ones installed by `throwIfNotFound()` and `traverse()`) are meant for
+      // its result, not for the result of this find query.
+      return this[BUILDER_SYMBOL].toFindQuery()
+        .clear('runAfter')
+        .clearWithGraphFetched()
+        .runAfter(toArray);
     };
   }
 
@@ -97,6 +103,11 @@ class StaticHookArguments {
   }
 }
 
+// Like `asArray()`, but an empty `first()` result becomes an empty array.
+function toArray(result) {
+  return result === undefined ? [] : asArray(result);
+}
+
 function getRelation(op) {
   return op.relation;
 }

package/lib/queryBuilder/graph/GraphFetcher.js

@@ -153,9 +153,7 @@ function createManyToManyExtraSelectionIfNeeded(builder, column, node) {
     const extra = relation.joinTableExtras.find((extra) => extra.aliasCol === column);
 
     if (extra) {
-      return `${builder.tableRefFor(relation.joinModelClass)}.${extra.joinTableCol} as ${
-        extra.aliasCol
-      }`;
+      return `${relation.joinTableAliasFor(builder)}.${extra.joinTableCol} as ${extra.aliasCol}`;
     }
   }
 

package/lib/queryBuilder/graph/GraphOptions.js

@@ -13,6 +13,20 @@ const INSERT_MISSING = 'insertMissing';
 const FETCH_STRATEGY = 'fetchStrategy';
 const ALLOW_REFS = 'allowRefs';
 
+const OPTION_NAMES = [
+  NO_RELATE,
+  NO_UNRELATE,
+  NO_INSERT,
+  NO_UPDATE,
+  NO_DELETE,
+  UPDATE,
+  RELATE,
+  UNRELATE,
+  INSERT_MISSING,
+  FETCH_STRATEGY,
+  ALLOW_REFS,
+];
+
 const FetchStrategy = {
   OnlyIdentifiers: 'OnlyIdentifiers',
   Everything: 'Everything',
@@ -64,7 +78,7 @@ class GraphOptions {
       !getCurrentNode(node, graphData) &&
       !!node.parentEdge &&
       !!node.parentEdge.relation &&
-      node.parentEdge.relation.hasRelateProp(node.obj) &&
+      hasRelateProp(node) &&
       graphData.nodeDbExistence.doesNodeExistInDb(node)
     );
   }
@@ -212,6 +226,20 @@ function getCurrentNode(node, graphData) {
   return graphData.currentGraph.nodeForNode(node);
 }
 
+// For `HasMany` and `HasOne` relations, the relate prop is the id of the
+// related model. Use the id state of the input graph, since the parent's
+// insert copies the foreign key into the related model, which can complete
+// a composite id that contains it and would turn an insert into a relate (#2544).
+function hasRelateProp(node) {
+  const relation = node.parentEdge.relation;
+
+  if (relation.isObjectionHasManyRelation) {
+    return node.hasId;
+  } else {
+    return relation.hasRelateProp(node.obj);
+  }
+}
+
 function getNode(currentNode, graph) {
   if (!graph || !currentNode) {
     return null;
@@ -222,5 +250,6 @@ function getNode(currentNode, graph) {
 
 module.exports = {
   GraphOptions,
+  OPTION_NAMES,
   FetchStrategy,
 };

package/lib/queryBuilder/graph/GraphUpsert.js

@@ -8,16 +8,18 @@ const { GraphInsert } = require('./insert/GraphInsert');
 const { GraphPatch } = require('./patch/GraphPatch');
 const { GraphDelete } = require('./delete/GraphDelete');
 const { GraphRecursiveUpsert } = require('./recursiveUpsert/GraphRecursiveUpsert');
-const { GraphOptions } = require('./GraphOptions');
+const { GraphOptions, OPTION_NAMES } = require('./GraphOptions');
 const { ValidationErrorType } = require('../../model/ValidationError');
 const { RelationExpression } = require('../RelationExpression');
 const { GraphNodeDbExistence } = require('./GraphNodeDbExistence');
 const { GraphData } = require('./GraphData');
 const { uniqBy, asArray, isObject } = require('../../utils/objectUtils');
+const { deprecate } = require('../../utils/deprecate');
 
 class GraphUpsert {
   constructor({ rootModelClass, objects, upsertOptions }) {
     checkCanBeConvertedToModels(rootModelClass, objects);
+    warnOnUnknownOptions(upsertOptions);
 
     this.objects = rootModelClass.ensureModelArray(objects, GraphUpsert.modelOptions);
     this.isArray = Array.isArray(objects);
@@ -28,6 +30,23 @@ class GraphUpsert {
     return { skipValidation: true };
   }
 
+  // A graph is written using many insert queries (one per batch and table),
+  // so there's no single insert query an `onConflict` clause could be applied
+  // to. Even applying it to the root table only would be unsound: rows skipped
+  // by `ignore()` aren't returned, which leaves the root models without ids,
+  // so that related rows would be inserted with missing or wrong foreign keys.
+  // The clause is ignored, and a warning is logged once per method.
+  // TODO: Throw an error instead in objection 4.0.
+  static warnOnConflict(builder, method) {
+    if (builder.has(isOnConflictOperation)) {
+      deprecate(
+        `onConflict(), ignore() and merge() are not supported by ${method}(). ` +
+          'Insert the conflicting rows with a separate insert() query instead. ' +
+          'This will throw in objection 4.0.',
+      );
+    }
+  }
+
   run(builder) {
     const modelClass = builder.modelClass();
     const graphOptions = new GraphOptions(this.upsertOpt);
@@ -43,6 +62,20 @@ class GraphUpsert {
   }
 }
 
+// Misspelled options are silently ignored, so the operation runs with the
+// default behaviour instead (#84). A warning is logged once per option.
+// TODO: Throw an error instead in objection 4.0.
+function warnOnUnknownOptions(upsertOptions) {
+  for (const name of Object.keys(upsertOptions)) {
+    if (!OPTION_NAMES.includes(name)) {
+      deprecate(
+        `Unknown graph option "${name}" is ignored. ` +
+          `Valid options are: ${OPTION_NAMES.join(', ')}. This will throw in objection 4.0.`,
+      );
+    }
+  }
+}
+
 function checkCanBeConvertedToModels(modelClass, objects) {
   asArray(objects).forEach((obj) => {
     if (!isObject(obj)) {
@@ -326,6 +359,10 @@ function executeActions(builder, actions) {
   );
 }
 
+function isOnConflictOperation(op) {
+  return op.name === 'onConflict' || op.name === 'ignore' || op.name === 'merge';
+}
+
 function returnResult(objects, isArray) {
   return () => (isArray ? objects : objects[0]);
 }

package/lib/queryBuilder/graph/insert/DeferredRelationGraphInsertAction.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const { GraphAction } = require('../GraphAction');
+const { groupBy } = require('../../../utils/objectUtils');
+const promiseUtils = require('../../../utils/promiseUtils');
+
+/**
+ * Patches in the foreign keys of `BelongsToOneRelation` edges that `GraphInsert`
+ * had to defer to break a dependency cycle. The owner nodes of these edges were
+ * inserted without the foreign keys. `GraphInsertAction` already copied them to
+ * the owner objects once the related nodes were inserted, so all that's left to
+ * do is one patch query per owner.
+ */
+class DeferredRelationGraphInsertAction extends GraphAction {
+  constructor(graphData, { edges }) {
+    super(graphData);
+
+    // `BelongsToOneRelation` edges whose owner node needs to be patched.
+    this.edges = edges;
+  }
+
+  run(builder) {
+    const edgesByOwner = groupBy(this.edges, (edge) => edge.ownerNode);
+    const owners = [...edgesByOwner.keys()];
+    const concurrency = this._getConcurrency(builder, owners);
+
+    return promiseUtils.map(
+      owners,
+      (owner) => this._patchOwner(builder, owner, edgesByOwner.get(owner)),
+      { concurrency },
+    );
+  }
+
+  _patchOwner(builder, ownerNode, edges) {
+    const { modelClass } = ownerNode;
+    const ownerIdProp = modelClass.getIdRelationProperty();
+    const patch = {};
+
+    for (const { relation } of edges) {
+      const { ownerProp } = relation;
+
+      ownerProp.forEach((i) => {
+        ownerProp.patch(patch, i, ownerProp.getProp(ownerNode.obj, i));
+      });
+    }
+
+    return modelClass
+      .query()
+      .childQueryOf(builder)
+      .patch(patch)
+      .whereInComposite(ownerIdProp.refs(builder), [ownerIdProp.getProps(ownerNode.obj)]);
+  }
+}
+
+module.exports = {
+  DeferredRelationGraphInsertAction,
+};