objection 3.9.0 → 4.0.0-rc.1

package/lib/queryBuilder/StaticHookArguments.js

@@ -1,11 +1,9 @@
-'use strict';
-
-const { asArray } = require('../utils/objectUtils');
+import { asArray, isObject } from '../utils/objectUtils.js';
 
 const BUILDER_SYMBOL = Symbol();
 
-class StaticHookArguments {
-  constructor({ builder, result = null }) {
+export class StaticHookArguments {
+  constructor({ builder, result }) {
     // The builder should never be accessed through the arguments.
     // Hide it as well as possible to discourage people from
     // digging it out.
@@ -14,7 +12,7 @@ class StaticHookArguments {
     });
 
     Object.defineProperty(this, 'result', {
-      value: asArray(result),
+      value: result,
     });
   }
 
@@ -33,7 +31,7 @@ class StaticHookArguments {
         .clear('runAfter')
         .clearResolve()
         .clearWithGraphFetched()
-        .runAfter(toArray);
+        .runAfter(asArray);
     };
   }
 
@@ -46,7 +44,7 @@ class StaticHookArguments {
   }
 
   get relation() {
-    const op = this[BUILDER_SYMBOL].findOperation(hasRelation);
+    const op = findRelationOperation(this[BUILDER_SYMBOL], hasRelation);
 
     if (op) {
       return getRelation(op);
@@ -66,7 +64,7 @@ class StaticHookArguments {
   }
 
   get items() {
-    const op = this[BUILDER_SYMBOL].findOperation(hasItems);
+    const op = findRelationOperation(this[BUILDER_SYMBOL], hasItems);
 
     if (op) {
       return asArray(getItems(op));
@@ -99,6 +97,9 @@ class StaticHookArguments {
         } else {
           cancelValue = 0;
         }
+      } else if (builder.isInsert() && isObject(cancelValue)) {
+        // A single row is merged into the input model, like an array of rows.
+        cancelValue = asArray(cancelValue);
       }
 
       builder.resolve(cancelValue);
@@ -106,9 +107,70 @@ class StaticHookArguments {
   }
 }
 
-// Like `asArray()`, but an empty `first()` result becomes an empty array.
-function toArray(result) {
-  return result === undefined ? [] : asArray(result);
+// The outer queries of `insertGraph()` and `upsertGraph()` call no static hooks,
+// the queries that they run for the graph do. Match their operations by name,
+// as importing them here would create an import cycle.
+export function isGraphQuery(builder) {
+  return builder.has(/^(insertGraph|upsertGraph)/);
+}
+
+// The relations that `withGraphJoined()` fetches have no query of their own, so
+// the hooks of their model classes get the relation and its owners instead.
+export class JoinedStaticHookArguments extends StaticHookArguments {
+  #relation;
+  #items;
+
+  constructor({ builder, result, relation, items }) {
+    super({ builder, result });
+    this.#relation = relation;
+    this.#items = items;
+  }
+
+  static create(args) {
+    return new JoinedStaticHookArguments(args);
+  }
+
+  get asFindQuery() {
+    return () => {
+      throw new Error(
+        'asFindQuery() is not available for relations fetched with withGraphJoined().',
+      );
+    };
+  }
+
+  get relation() {
+    return this.#relation;
+  }
+
+  get modelOptions() {
+    return undefined;
+  }
+
+  get items() {
+    return this.#items;
+  }
+
+  get inputItems() {
+    return [];
+  }
+
+  get cancelQuery() {
+    return () => {
+      throw new Error(
+        'cancelQuery() is not available for relations fetched with withGraphJoined().',
+      );
+    };
+  }
+}
+
+// The queries that `relate()` and `unrelate()` run in their place get the
+// relation and the owners of the relate or unrelate query.
+function findRelationOperation(builder, predicate) {
+  const parent = builder.parentQuery();
+  return (
+    builder.findOperation(predicate) ||
+    (parent?.isRelate() || parent?.isUnrelate() ? parent.findOperation(predicate) : null)
+  );
 }
 
 function getRelation(op) {
@@ -142,7 +204,3 @@ function getInputItems(op) {
 function hasInputItems(op) {
   return !!getInputItems(op);
 }
-
-module.exports = {
-  StaticHookArguments,
-};

package/lib/queryBuilder/ValueBuilder.js

@@ -1,9 +1,8 @@
-'use strict';
+import { isObject } from '../utils/objectUtils.js';
+import { buildArg } from '../utils/buildUtils.js';
+import { getJsonDialect } from './jsonDialects/index.js';
 
-const { asArray, isObject } = require('../utils/objectUtils');
-const { buildArg } = require('../utils/buildUtils');
-
-class ValueBuilder {
+export class ValueBuilder {
   constructor(value) {
     this._value = value;
     this._cast = null;
@@ -73,6 +72,7 @@ class ValueBuilder {
   }
 
   _createRawArgs(builder) {
+    const dialect = getJsonDialect(builder.knex());
     let sql = null;
     let bindings = [];
 
@@ -80,7 +80,8 @@ class ValueBuilder {
       bindings.push(JSON.stringify(this._value));
       sql = '?';
     } else if (this._toArray) {
-      const values = asArray(this._value);
+      // Wrap `undefined` too, it is a value here:
+      const values = Array.isArray(this._value) ? this._value : [this._value];
       bindings.push(...values.map((it) => buildArg(it, builder)));
       sql = `ARRAY[${values.map(() => '?').join(', ')}]`;
     } else {
@@ -89,7 +90,9 @@ class ValueBuilder {
     }
 
     if (this._cast) {
-      sql = `CAST(${sql} AS ${this._cast})`;
+      sql = dialect.cast(sql, this._cast);
+    } else if (this._toJson) {
+      sql = dialect.json(sql);
     }
 
     if (this._alias) {
@@ -101,11 +104,6 @@ class ValueBuilder {
   }
 }
 
-function val(val) {
+export function val(val) {
   return new ValueBuilder(val);
 }
-
-module.exports = {
-  ValueBuilder,
-  val,
-};

package/lib/queryBuilder/getJoinBuilder.js

@@ -0,0 +1,10 @@
+// A small helper for lazy access to the JoinBuilder class, for modules that the
+// JoinBuilder module imports itself. Importing JoinBuilder.js there would create
+// a circular import, so JoinBuilder.js registers itself here instead.
+let JoinBuilder;
+
+export const getJoinBuilder = () => JoinBuilder;
+
+export const setJoinBuilder = (joinBuilder) => {
+  JoinBuilder = joinBuilder;
+};

package/lib/queryBuilder/graph/GraphLoader.js

@@ -0,0 +1,304 @@
+import { asArray, chunk, groupBy, uniqBy } from '../../utils/objectUtils.js';
+import { getMaxRows } from '../../utils/knexUtils.js';
+import { FetchStrategy } from './GraphOptions.js';
+import { GraphNode } from './GraphNode.js';
+import { RelationExpression } from '../RelationExpression.js';
+import { getDeclaredColumns } from '../operations/fieldExpressions.js';
+import { getFieldExpressionColumn } from '../../utils/parseFieldExpression.js';
+
+// Fetch the current state of the graph from the database and pair its rows with
+// the models of the graph: First the roots of the pass with their relations,
+// then the rows of the models that the graph relates from elsewhere, with the
+// relations that the graph gives them, level by level, as the rows of related
+// models decide which models below them are related too. Models that
+// `insertMissing` inserts if they don't exist are looked up too. The rows that
+// a relate moves into a HasManyRelation or HasOneRelation are fetched without
+// their relations, which change with the move. Return the ones that the graph
+// gives relations, to be upserted in a pass of their own after the move.
+export async function loadCurrentGraph(builder, plan) {
+  const passNodes = new Set(plan.nodes);
+  const fetchedNodes = new Set();
+  const movedNodes = [];
+
+  const fetch = async (nodes, { areRelated }) => {
+    for (const node of nodes) {
+      fetchedNodes.add(node);
+    }
+
+    for (const [isMovedRow, groupNodes] of groupBy(nodes, (node) => areRelated && isMoved(node))) {
+      for (const nodesOfClass of groupBy(groupNodes, (node) => node.modelClass).values()) {
+        const models = await fetchModels(builder, plan.graphOptions, nodesOfClass, {
+          withRelations: !isMovedRow,
+        });
+        const modelsByKey = new Map(models.map((model) => [model.$idKey(), model]));
+
+        for (const node of nodesOfClass) {
+          const model = modelsByKey.get(node.obj.$idKey());
+
+          if (model && isMovedRow && hasRelations(node.obj)) {
+            movedNodes.push(node);
+          } else if (model) {
+            const currentNodes = GraphNode.buildGraph(node.modelClass, model, node.relationPath);
+            const [currentNode] = currentNodes;
+            plan.currentNodes.push(...currentNodes);
+
+            if (areRelated) {
+              node.row = currentNode;
+              currentNode.node = node;
+              pairChildren(node, currentNode);
+            } else {
+              pair(node, currentNode);
+            }
+          } else if (areRelated) {
+            node.isMissing = true;
+          }
+        }
+      }
+    }
+  };
+
+  // Find the models that the graph relates and that aren't fetched yet, for
+  // which `isFetched(node, rowKeys)` is true. The ones below others wait for
+  // their rows, and the ones in branches that the graph doesn't write are left
+  // out.
+  const findRelatedNodes = (isFetched) => {
+    const rowKeys = new Set(plan.currentNodes.map((currentNode) => currentNode.rowKey));
+    const nodes = plan.nodes.filter(
+      (node) =>
+        !fetchedNodes.has(node) &&
+        !node.current &&
+        node.obj.$hasId() &&
+        plan.actionFor(node) === 'relate' &&
+        isFetched(node, rowKeys),
+    );
+    const nodeSet = new Set(nodes);
+
+    return nodes.filter((node) => {
+      for (let parent = node.parent; passNodes.has(parent); parent = parent.parent) {
+        if (nodeSet.has(parent) || !plan.writesBranchOf(parent)) {
+          return false;
+        }
+      }
+
+      return true;
+    });
+  };
+
+  await fetch(
+    plan.nodes.filter((node) => !passNodes.has(node.parent) && node.hasId),
+    { areRelated: false },
+  );
+
+  // The rows of the related models that the graph gives relations, or inserts
+  // with `insertMissing` if they don't exist:
+  const hasRelatedRow = (node, rowKeys) =>
+    hasRelations(node.obj) ||
+    (plan.graphOptions.has(node, 'insertMissing') && !rowKeys.has(node.rowKey));
+
+  for (
+    let nodes = findRelatedNodes(hasRelatedRow);
+    nodes.length > 0;
+    nodes = findRelatedNodes(hasRelatedRow)
+  ) {
+    await fetch(nodes, { areRelated: true });
+  }
+
+  // The other related models only need to exist, except for `#ref` models,
+  // which are the models that they refer to, and the rows of the current graph
+  // (#372):
+  const nodes = findRelatedNodes((node, rowKeys) => !node.isReference && !rowKeys.has(node.rowKey));
+
+  for (const nodesOfClass of groupBy(nodes, (node) => node.modelClass).values()) {
+    const models = await fetchModels(builder, plan.graphOptions, nodesOfClass, {
+      onlyIds: true,
+    });
+    const idKeys = new Set(models.map((model) => model.$idKey()));
+
+    for (const node of nodesOfClass) {
+      node.isMissing = !idKeys.has(node.obj.$idKey());
+    }
+  }
+
+  return movedNodes;
+}
+
+function pair(node, currentNode) {
+  node.current ??= currentNode;
+  currentNode.node = node;
+  pairChildren(node, currentNode);
+}
+
+// Pair the related models with ids with the current rows in the same relations.
+// Rows can be related more than once through duplicate join rows, and all of
+// them pair with the same model.
+function pairChildren(node, currentNode) {
+  const childrenByRelation = groupBy(currentNode.children, (child) => child.relation.name);
+
+  for (const child of node.children) {
+    if (child.obj.$hasId()) {
+      const key = child.obj.$idKey();
+
+      for (const currentChild of childrenByRelation.get(child.relation.name) || []) {
+        if (currentChild.obj.$idKey() === key) {
+          pair(child, currentChild);
+        }
+      }
+    }
+  }
+}
+
+function isMoved(node) {
+  return node.relation.keySide === 'related';
+}
+
+function hasRelations(obj) {
+  return obj.constructor.getRelationNames().some((name) => obj[name] !== undefined);
+}
+
+// Fetch the rows of `nodes`, with their relations unless they're moved, or only
+// their ids, in as many queries as the number of their ids requires.
+async function fetchModels(builder, graphOptions, nodes, options) {
+  const [{ modelClass }] = nodes;
+  const uniqueNodes = uniqBy(nodes, (node) => node.obj.$idKey());
+  const maxIds = getMaxRows(builder.unsafeKnex(), modelClass.getIdColumnArray().length);
+  const models = [];
+
+  for (const chunkNodes of chunk(uniqueNodes, maxIds)) {
+    models.push(...(await fetchModelsOfNodes(builder, graphOptions, chunkNodes, options)));
+  }
+
+  return models;
+}
+
+function fetchModelsOfNodes(
+  builder,
+  graphOptions,
+  nodes,
+  { withRelations = false, onlyIds = false },
+) {
+  const [{ modelClass }] = nodes;
+  const ids = nodes.map((node) => node.obj.$id());
+  const expression = RelationExpression.fromModelGraph(
+    withRelations ? nodes.map((node) => node.obj) : [],
+  );
+
+  return modelClass
+    .query()
+    .childQueryOf(builder, { fork: true, isInternalQuery: true })
+    .modify((fetchBuilder) => {
+      // Lock the fetched rows like the upsert query asks for.
+      for (const method of ['forUpdate', 'forShare', 'forNoKeyUpdate', 'forKeyShare']) {
+        if (builder.has(method)) {
+          fetchBuilder[method]();
+        }
+      }
+    })
+    .modify((fetchBuilder) => {
+      const nodesByRelationPath = withRelations
+        ? getNodesByRelationPath(nodes, expression)
+        : new Map([['', nodes]]);
+
+      for (const [relationPath, pathNodes] of nodesByRelationPath) {
+        const select = onlyIds
+          ? (builder) => builder.select(builder.fullIdColumn())
+          : createSelect(pathNodes, graphOptions, !relationPath);
+
+        if (!relationPath) {
+          fetchBuilder.modify(select);
+        } else {
+          fetchBuilder.modifyGraph(relationPath, select);
+        }
+      }
+    })
+    .findByIds(ids)
+    .withGraphFetched(expression)
+    .internalOptions({ keepImplicitJoinProps: true });
+}
+
+// Group the fetched nodes and their descendants by their relation paths below
+// the fetched nodes. Relations with nulls or empty arrays have no nodes, but
+// are fetched too.
+function getNodesByRelationPath(nodes, expression) {
+  const nodesByRelationPath = new Map();
+
+  for (const node of nodes) {
+    const depth = node.relationPath.length;
+
+    for (const descendant of [node, ...node.descendants]) {
+      const relationPath = descendant.relationPath.slice(depth).join('.');
+      const pathNodes = nodesByRelationPath.get(relationPath);
+
+      if (pathNodes) {
+        pathNodes.push(descendant);
+      } else {
+        nodesByRelationPath.set(relationPath, [descendant]);
+      }
+    }
+  }
+
+  const addPaths = (expressionNode, path) => {
+    for (const name of expressionNode.$childNames) {
+      const relationPath = [...path, name];
+      const key = relationPath.join('.');
+
+      if (!nodesByRelationPath.has(key)) {
+        nodesByRelationPath.set(key, []);
+      }
+
+      addPaths(expressionNode[name], relationPath);
+    }
+  };
+
+  addPaths(expression.node, []);
+  return nodesByRelationPath;
+}
+
+function createSelect(nodes, graphOptions, isFetchRoot) {
+  if (graphOptions.isFetchStrategy(FetchStrategy.OnlyIdentifiers)) {
+    return (builder) => builder.select(builder.fullIdColumn());
+  } else if (graphOptions.isFetchStrategy(FetchStrategy.OnlyNeeded)) {
+    return (builder) => builder.select(getInputColumnSelections(builder, nodes, isFetchRoot));
+  } else {
+    return () => {};
+  }
+}
+
+// Select only the columns that the graph gives, and always the ids. Related
+// models are fetched without the join tables of their relations, so their join
+// table extras are left out at the root of the fetch.
+function getInputColumnSelections(builder, nodes, isFetchRoot) {
+  const selections = new Map();
+
+  for (const node of nodes) {
+    const declaredColumns = getDeclaredColumns(node.modelClass);
+
+    for (const key of Object.keys(node.obj.$toDatabaseJson(builder))) {
+      // Select the json column of field expressions like `'meta:a'`:
+      const column = getFieldExpressionColumn(key, declaredColumns) ?? key;
+
+      if (!selections.has(column)) {
+        const { relation } = node;
+        const extra =
+          relation?.keySide === 'join' &&
+          relation.joinTableExtras.find((extra) => extra.aliasCol === column);
+
+        if (!extra) {
+          selections.set(column, `${builder.tableRefFor(node.modelClass)}.${column}`);
+        } else if (!isFetchRoot) {
+          const alias = relation.joinTableAliasFor(builder);
+          selections.set(column, `${alias}.${extra.joinTableCol} as ${extra.aliasCol}`);
+        }
+      }
+    }
+  }
+
+  const values = [...selections.values()];
+
+  for (const idColumn of asArray(builder.fullIdColumn())) {
+    if (!values.includes(idColumn)) {
+      values.push(idColumn);
+    }
+  }
+
+  return values;
+}