objection 3.2.0 → 3.4.0

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

@@ -1,6 +1,7 @@
 'use strict';
 
 const { JoinRowGraphInsertAction } = require('./JoinRowGraphInsertAction');
+const { DeferredRelationGraphInsertAction } = require('./DeferredRelationGraphInsertAction');
 const { GraphInsertAction } = require('./GraphInsertAction');
 const { GraphOperation } = require('../GraphOperation');
 const { ModelGraphEdge } = require('../../../model/graph/ModelGraphEdge');
@@ -9,10 +10,15 @@ class GraphInsert extends GraphOperation {
   constructor(...args) {
     super(...args);
     this.dependencies = this._createDependencyMap();
+    this.deferredEdges = new Set();
   }
 
   createActions() {
-    return [...this._createNormalActions(), ...this._createJoinRowActions()];
+    return [
+      ...this._createNormalActions(),
+      ...this._createDeferredRelationActions(),
+      ...this._createJoinRowActions(),
+    ];
   }
 
   _createDependencyMap() {
@@ -76,6 +82,10 @@ class GraphInsert extends GraphOperation {
       });
 
       if (nodesToInsert.length === 0) {
+        if (handledNodes.size !== this.graph.nodes.length && this._breakCycle(handledNodes)) {
+          continue;
+        }
+
         break;
       }
 
@@ -83,6 +93,7 @@ class GraphInsert extends GraphOperation {
         new GraphInsertAction(this.graphData, {
           nodes: nodesToInsert,
           dependencies: this.dependencies,
+          deferredEdges: this.deferredEdges,
         }),
       );
 
@@ -98,19 +109,71 @@ class GraphInsert extends GraphOperation {
     return actions;
   }
 
-  _isHandled(node, handledNodes) {
-    return handledNodes.has(node);
+  // Tries to break a dependency cycle by deferring one `BelongsToOneRelation`
+  // edge that points to a `#ref` node. The owner node is then inserted without
+  // the foreign key, which is patched in by `DeferredRelationGraphInsertAction`
+  // once the referenced node has been inserted. Cycles can only exist through
+  // `#ref` nodes, since the graph is a tree otherwise.
+  _breakCycle(handledNodes) {
+    for (const node of this.graph.nodes) {
+      if (this._isHandled(node, handledNodes)) {
+        continue;
+      }
+
+      for (const edge of this._pendingDependencyEdges(node, handledNodes)) {
+        if (
+          this._canDeferEdge(edge, node) &&
+          this._isBlockedBy(edge.relatedNode, node, handledNodes, new Set())
+        ) {
+          this.deferredEdges.add(edge);
+          return true;
+        }
+      }
+    }
+
+    return false;
   }
 
-  _hasDependencies(node, handledNodes) {
-    if (!this.dependencies.has(node)) {
+  _canDeferEdge(edge, node) {
+    return (
+      edge.type === ModelGraphEdge.Type.Relation &&
+      edge.relation.isObjectionBelongsToOneRelation &&
+      edge.isOwnerNode(node) &&
+      edge.relatedNode.isReference &&
+      // Both ends need to be inserted for the foreign key to be patched in later.
+      this.graphOptions.shouldInsert(node, this.graphData) &&
+      this.graphOptions.shouldInsert(edge.relatedNode.referencedNode, this.graphData) &&
+      !this._isReadByPropertyReference(node, edge.relation.ownerProp)
+    );
+  }
+
+  // Returns true if a `#ref{}` property reference reads one of the `props` of
+  // `node`. Such references may be resolved before a deferred prop is set,
+  // which would resolve them to `undefined`.
+  _isReadByPropertyReference(node, props) {
+    return node.refEdges.some((edge) => {
+      return (
+        edge.refType === ModelGraphEdge.ReferenceType.Property &&
+        edge.isRelatedNode(node) &&
+        props.props.includes(edge.refRelatedDataPath[0])
+      );
+    });
+  }
+
+  // Returns true if `node` (transitively) waits for `blockingNode` to be handled.
+  _isBlockedBy(node, blockingNode, handledNodes, visitedNodes) {
+    if (node === blockingNode) {
+      return true;
+    }
+
+    if (visitedNodes.has(node)) {
       return false;
     }
 
-    for (const edge of this.dependencies.get(node)) {
-      const dependencyNode = edge.getOtherNode(node);
+    visitedNodes.add(node);
 
-      if (!handledNodes.has(dependencyNode) && !this.currentGraph.nodeForNode(dependencyNode)) {
+    for (const edge of this._pendingDependencyEdges(node, handledNodes)) {
+      if (this._isBlockedBy(edge.getOtherNode(node), blockingNode, handledNodes, visitedNodes)) {
         return true;
       }
     }
@@ -118,6 +181,42 @@ class GraphInsert extends GraphOperation {
     return false;
   }
 
+  _createDeferredRelationActions() {
+    if (this.deferredEdges.size === 0) {
+      return [];
+    }
+
+    return [
+      new DeferredRelationGraphInsertAction(this.graphData, {
+        edges: [...this.deferredEdges],
+      }),
+    ];
+  }
+
+  _isHandled(node, handledNodes) {
+    return handledNodes.has(node);
+  }
+
+  _hasDependencies(node, handledNodes) {
+    return this._pendingDependencyEdges(node, handledNodes).length > 0;
+  }
+
+  // Returns the dependency edges of `node` whose other node still needs to be
+  // inserted first. Deferred edges are ignored.
+  _pendingDependencyEdges(node, handledNodes) {
+    const edges = this.dependencies.get(node) || [];
+
+    return edges.filter((edge) => {
+      const dependencyNode = edge.getOtherNode(node);
+
+      return (
+        !this.deferredEdges.has(edge) &&
+        !handledNodes.has(dependencyNode) &&
+        !this.currentGraph.nodeForNode(dependencyNode)
+      );
+    });
+  }
+
   _markHandled(node, handledNodes) {
     handledNodes.add(node);
 

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

@@ -14,12 +14,15 @@ const promiseUtils = require('../../../utils/promiseUtils');
  * when needed.
  */
 class GraphInsertAction extends GraphAction {
-  constructor(graphData, { nodes, dependencies }) {
+  constructor(graphData, { nodes, dependencies, deferredEdges }) {
     super(graphData);
 
     // Nodes to insert.
     this.nodes = nodes;
     this.dependencies = dependencies;
+    // Dependency edges that are resolved once the dependency node has been
+    // inserted, and are patched in by `DeferredRelationGraphInsertAction`.
+    this.deferredEdges = deferredEdges;
   }
 
   run(builder) {
@@ -63,6 +66,10 @@ class GraphInsertAction extends GraphAction {
 
       if (edges) {
         for (const edge of edges) {
+          if (this.deferredEdges.has(edge)) {
+            continue;
+          }
+
           // `node` needs `dependencyNode` to have been inserted (and it has been).
           const dependencyNode = edge.getOtherNode(node);
 

package/lib/queryBuilder/graph/patch/GraphPatchAction.js

@@ -3,7 +3,7 @@
 const { getModel } = require('../../../model/getModel');
 const { GraphAction } = require('../GraphAction');
 const { isInternalProp } = require('../../../utils/internalPropUtils');
-const { difference, isObject, jsonEquals } = require('../../../utils/objectUtils');
+const { difference, isObject, isPlainObject, jsonEquals } = require('../../../utils/objectUtils');
 const promiseUtils = require('../../../utils/promiseUtils');
 
 class GraphPatchAction extends GraphAction {
@@ -251,13 +251,19 @@ function childQueryOptions() {
 }
 
 function nonStrictEquals(val1, val2) {
-  if (val1 == val2) {
+  // Only use loose equality for non-JSON values, so that for example `false`
+  // and `[]` are not considered equal. See issue #1874.
+  if (!isJsonValue(val1) && !isJsonValue(val2) && val1 == val2) {
     return true;
   }
 
   return jsonEquals(val1, val2);
 }
 
+function isJsonValue(value) {
+  return Array.isArray(value) || isPlainObject(value);
+}
+
 function isToBeUnrelatedOrDeleted(node) {
   return !!node && node.toBeUnrelatedOrDeleted;
 }

package/lib/queryBuilder/join/JoinResultParser.js

@@ -22,6 +22,8 @@ class JoinResultParser {
       return flatRows;
     }
 
+    this._checkIdColumns(flatRows[0]);
+
     this.columnsByTableNode = this._createColumns(flatRows[0]);
     this.parentMap = new Map();
     this.rootModels = [];
@@ -93,6 +95,26 @@ class JoinResultParser {
     }
   }
 
+  _checkIdColumns(row) {
+    for (const tableNode of this.tableTree.nodes) {
+      const idColumns = tableNode.modelClass.getIdColumnArray();
+      const hasIdColumns =
+        idColumns.length > 0 &&
+        idColumns.every((column) =>
+          Object.prototype.hasOwnProperty.call(row, tableNode.getColumnAliasForColumn(column)),
+        );
+
+      if (!hasIdColumns) {
+        throw new Error(
+          `withGraphJoined: the id column(s) [${idColumns.join(', ')}] of model ${tableNode.modelClass.name} ` +
+            `are missing from the result, so the joined rows can't be grouped into models. ` +
+            `withGraphJoined requires all models in the relation expression to have a primary key ` +
+            `(idColumn) that exists in the table. Use withGraphFetched for models without one.`,
+        );
+      }
+    }
+  }
+
   _createColumns(row) {
     const columns = Object.keys(row).map((columnAlias) =>
       JoinResultColumn.create({ tableTree: this.tableTree, columnAlias }),

package/lib/queryBuilder/join/RelationJoiner.js

@@ -8,7 +8,7 @@ const { ValidationErrorType } = require('../../model/ValidationError');
 
 const { TableTree } = require('./TableTree');
 const { JoinResultParser } = require('./JoinResultParser');
-const { ID_LENGTH_LIMIT } = require('./utils');
+const { getIdentifierLengthLimit } = require('./utils');
 
 /**
  * Given a relation expression, builds a query using joins to fetch it.
@@ -24,6 +24,8 @@ class RelationJoiner {
     this.modifiers = null;
 
     this.options = defaultOptions();
+    // The `joinOperation` options of the individual `withGraphJoined` calls.
+    this.joinOperations = [];
     this.tableTree = null;
     this.internalSelections = null;
   }
@@ -49,6 +51,11 @@ class RelationJoiner {
     return this;
   }
 
+  setJoinOperations(joinOperations) {
+    this.joinOperations = joinOperations;
+    return this;
+  }
+
   /**
    * Fetches the column information needed for building the select clauses.
    *
@@ -81,23 +88,6 @@ class RelationJoiner {
     }
   }
 
-  releaseInternalRootSelection(column) {
-    const rootTableNode = this.tableTree && this.tableTree.rootNode;
-
-    if (!rootTableNode || !this.internalSelections) {
-      return false;
-    }
-
-    const alias = rootTableNode.getColumnAliasForColumn(column);
-    const count = this.internalSelections.length;
-
-    this.internalSelections = this.internalSelections.filter(
-      (it) => it.table !== rootTableNode.alias || it.alias !== alias,
-    );
-
-    return this.internalSelections.length !== count;
-  }
-
   parseResult(builder, flatRows) {
     const parser = JoinResultParser.create({
       tableTree: this._getTableTree(builder),
@@ -134,12 +124,18 @@ class RelationJoiner {
     // also contain selects.
     userSelectQuery.modify(tableNode.relation.modify);
 
+    if (selectsOnlyAliasesKeepingSelectAll(userSelectQuery.findAllSelections())) {
+      // All columns are selected from the joined subquery in the main query,
+      // so the subquery needs to select them too.
+      subqueryToJoin.select(`${subqueryToJoin.tableRef()}.*`);
+    }
+
     // Save the query that contains the user specified selects
     // for later use.
     userSelectQueries.set(tableNode, userSelectQuery);
 
     tableNode.relation.join(builder, {
-      joinOperation: this.options.joinOperation,
+      joinOperation: this._getJoinOperation(tableNode),
 
       ownerTable: tableNode.parentNode.alias,
       relatedTableAlias: tableNode.alias,
@@ -156,6 +152,26 @@ class RelationJoiner {
     }
   }
 
+  // Returns the `joinOperation` of the last `withGraphJoined` call that
+  // contains the relation of `tableNode`, falling back to the default.
+  _getJoinOperation(tableNode) {
+    const path = [];
+
+    for (let node = tableNode; node.parentNode; node = node.parentNode) {
+      path.unshift(node.relationProperty);
+    }
+
+    for (let i = this.joinOperations.length - 1; i >= 0; --i) {
+      const { expression, joinOperation } = this.joinOperations[i];
+
+      if (containsPath(expression, path)) {
+        return joinOperation;
+      }
+    }
+
+    return this.options.joinOperation;
+  }
+
   _buildSelects({ builder, tableNode, userSelectQueries }) {
     const { selections, internalSelections } = getSelectionsForNode({
       builder,
@@ -163,14 +179,28 @@ class RelationJoiner {
       userSelectQueries,
     });
 
+    const lengthLimit = getIdentifierLengthLimit(builder.knex());
+
     for (const selection of selections) {
-      checkAliasLength(tableNode.modelClass, selection.name);
+      checkAliasLength(tableNode.modelClass, selection.name, lengthLimit);
     }
 
     // Save the selections that were added internally (not by the user)
-    // so that we can later remove the corresponding properties when
-    // parsing the result.
-    this.internalSelections = internalSelections;
+    // so that we can later remove the corresponding properties. The root
+    // ones are registered with the builder, which removes them from the
+    // result models after all eager operations have run, as they may still
+    // need them. The nested ones are removed when parsing the result.
+    this.internalSelections = [];
+
+    for (const selection of internalSelections) {
+      if (selection.table === tableNode.alias) {
+        builder.addInternalSelection(
+          tableNode.modelClass.columnNameToPropertyName(selection.column),
+        );
+      } else {
+        this.internalSelections.push(selection);
+      }
+    }
 
     builder.select(selectionsToStrings(selections));
   }
@@ -185,9 +215,21 @@ function defaultOptions() {
   };
 }
 
+function containsPath(expression, path) {
+  for (const name of path) {
+    expression = expression.childExpression(name);
+
+    if (!expression) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
 function createSubqueryToJoin({ builder, tableNode, modifiers }) {
   const { relation, expression, modelClass } = tableNode;
-  const modifierQuery = modelClass.query().childQueryOf(builder);
+  const modifierQuery = modelClass.query().childQueryOf(builder, { isJoinChildQuery: true });
 
   for (const modifierName of expression.node.$modify) {
     const modifier = createModifier({
@@ -341,14 +383,25 @@ function isNotSelectAll(selection) {
 }
 
 function isSelectAllSelectionSet(selections) {
+  selections = selections.filter(isNotKeepingSelectAll);
   return selections.length === 0 || selections.some(isSelectAll);
 }
 
-function checkAliasLength(modelClass, alias) {
-  if (alias.length > ID_LENGTH_LIMIT) {
+function isNotKeepingSelectAll(selection) {
+  return !selection.keepsSelectAll;
+}
+
+function selectsOnlyAliasesKeepingSelectAll(selections) {
+  return selections.length > 0 && selections.every((it) => it.keepsSelectAll);
+}
+
+function checkAliasLength(modelClass, alias, lengthLimit) {
+  if (alias.length > lengthLimit) {
     throw modelClass.createValidationError({
       type: ValidationErrorType.RelationExpression,
-      message: `identifier ${alias} is over ${ID_LENGTH_LIMIT} characters long and would be truncated by the database engine.`,
+      message:
+        `identifier ${alias} is over ${lengthLimit} characters long and would be truncated by the database engine. ` +
+        'Use the `minimize` option of withGraphJoined() to shorten the aliases.',
     });
   }
 }

package/lib/queryBuilder/join/utils.js

@@ -1,10 +1,27 @@
 'use strict';
 
 const { ValidationErrorType } = require('../../model/ValidationError');
+const { isPostgres, isMySql, isMsSql, isSqlite } = require('../../utils/knexUtils');
 
-const ID_LENGTH_LIMIT = 63;
 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.
+function getIdentifierLengthLimit(knex) {
+  if (isPostgres(knex)) {
+    return 63;
+  } else if (isMySql(knex)) {
+    return 256;
+  } else if (isMsSql(knex)) {
+    return 128;
+  } else if (isSqlite(knex)) {
+    return Infinity;
+  } else {
+    return 63;
+  }
+}
+
 // Given a relation expression, goes through all first level children.
 function forEachChildExpression(expr, modelClass, callback) {
   if (expr.node.$allRecursive || expr.maxRecursionDepth > RELATION_RECURSION_LIMIT) {
@@ -18,8 +35,9 @@ function forEachChildExpression(expr, modelClass, callback) {
 }
 
 module.exports = {
-  ID_LENGTH_LIMIT,
   RELATION_RECURSION_LIMIT,
 
+  getIdentifierLengthLimit,
+
   forEachChildExpression,
 };

package/lib/queryBuilder/operations/InsertAndFetchOperation.js

@@ -22,10 +22,16 @@ class InsertAndFetchOperation extends DelegateOperation {
     const modelClass = builder.modelClass();
     const insertedModels = await super.onAfter2(builder, inserted);
 
-    const insertedModelArray = asArray(insertedModels);
+    // Models without identifiers can't be fetched. This happens when a row
+    // with a database generated identifier is ignored by `onConflict()`.
+    const insertedModelArray = asArray(insertedModels).filter((model) => model && model.$hasId());
     const idProps = modelClass.getIdPropertyArray();
     const ids = insertedModelArray.map((model) => model.$id());
 
+    if (ids.length === 0) {
+      return insertedModels;
+    }
+
     const fetchedModels = await modelClass
       .query()
       .childQueryOf(builder)

package/lib/queryBuilder/operations/InsertGraphOperation.js

@@ -51,8 +51,8 @@ class InsertGraphOperation extends DelegateOperation {
     return retVal;
   }
 
-  onBefore1(_, result) {
-    // Do nothing.
+  onBefore1(builder, result) {
+    GraphUpsert.warnOnConflict(builder, this.name);
     return result;
   }