objection 3.9.1 → 4.0.0-rc.2

package/lib/queryBuilder/graph/GraphData.js

@@ -1,53 +0,0 @@
-'use strict';
-
-class GraphData {
-  constructor({ graph, currentGraph, graphOptions, nodeDbExistence }) {
-    this.graph = graph;
-    this.currentGraph = currentGraph;
-    this.graphOptions = graphOptions;
-    this.nodeDbExistence = nodeDbExistence;
-    // Pruning replaces `graph.nodes`, but `keptNodeForRow()` also needs the
-    // branches below related nodes.
-    this._unprunedNodes = graph.nodes;
-    this._keptNodesByRowKey = null;
-  }
-
-  // Find the node that keeps the row of `currentNode` in another place of the
-  // graph, by relating or patching it there, or by upserting it below a related
-  // node. Only call this after pruning.
-  keptNodeForRow(currentNode) {
-    if (!this._keptNodesByRowKey) {
-      this._keptNodesByRowKey = new Map();
-      const nodes = new Set(this.graph.nodes);
-
-      // Nested upserts write the pruned branches below related nodes, except
-      // for models marked with `#unrelate` or `#delete` and their descendants:
-      const isUpsertedBelowRelatedNode = (node) =>
-        !node.toBeUnrelatedOrDeleted &&
-        (nodes.has(node.parentNode)
-          ? this.graphOptions.shouldRelate(node.parentNode, this)
-          : isUpsertedBelowRelatedNode(node.parentNode));
-
-      for (const node of this._unprunedNodes) {
-        if (
-          node.obj.$hasId() &&
-          (nodes.has(node)
-            ? this.graphOptions.shouldPatchOrUpdateIgnoreDisable(node, this)
-            : isUpsertedBelowRelatedNode(node))
-        ) {
-          this._keptNodesByRowKey.set(getRowKey(node), node);
-        }
-      }
-    }
-
-    return this._keptNodesByRowKey.get(getRowKey(currentNode)) || null;
-  }
-}
-
-function getRowKey(node) {
-  return `${node.modelClass.getTableName()}:${node.obj.$idKey()}`;
-}
-
-module.exports = {
-  GraphData,
-};

package/lib/queryBuilder/graph/GraphFetcher.js

@@ -1,197 +0,0 @@
-'use strict';
-
-const { asArray, groupBy } = require('../../utils/objectUtils');
-const { ModelGraph } = require('../../model/graph/ModelGraph');
-const { FetchStrategy } = require('./GraphOptions');
-const { RelationExpression } = require('../RelationExpression');
-const { getDeclaredColumns } = require('../operations/UpdateOperation');
-const { getFieldExpressionColumn } = require('../../utils/parseFieldExpression');
-
-class GraphFetcher {
-  /**
-   * Given a graph and options, fetches the current state of that graph
-   * from the database and returns it as a ModelGraph instance.
-   */
-  static async fetchCurrentGraph({ builder, graph, graphOptions }) {
-    const { rootObjects } = graph;
-
-    const rootIds = getRootIds(rootObjects);
-    const modelClass = builder.modelClass();
-
-    if (rootIds.length === 0) {
-      return Promise.resolve(ModelGraph.create(modelClass, []));
-    }
-
-    const eagerExpr = RelationExpression.fromModelGraph(rootObjects);
-    const models = await modelClass
-      .query()
-      .childQueryOf(builder, childQueryOptions())
-      .modify(propagateMethodCallsFromQuery(builder))
-      .modify(buildFetchQuerySelects(graph, graphOptions, eagerExpr))
-      .findByIds(rootIds)
-      .withGraphFetched(eagerExpr)
-      .internalOptions(fetchQueryInternalOptions());
-
-    return ModelGraph.create(modelClass, models);
-  }
-}
-
-function getRootIds(rootObjects) {
-  return asArray(rootObjects)
-    .filter((it) => it.$hasId())
-    .map((root) => root.$id());
-}
-
-function propagateMethodCallsFromQuery(builder) {
-  return (fetchBuilder) => {
-    // Propagate some method calls from the root query.
-    for (const method of ['forUpdate', 'forShare', 'forNoKeyUpdate', 'forKeyShare']) {
-      if (builder.has(method)) {
-        fetchBuilder[method]();
-      }
-    }
-  };
-}
-
-function buildFetchQuerySelects(graph, graphOptions, eagerExpr) {
-  return (builder) => {
-    const nodesByRelationPath = groupNodesByRelationPath(graph, eagerExpr);
-
-    for (const [relationPath, nodes] of nodesByRelationPath.entries()) {
-      const selectModifier = createFetchSelectModifier(nodes, graphOptions);
-
-      if (!relationPath) {
-        builder.modify(selectModifier);
-      } else {
-        builder.modifyGraph(relationPath, selectModifier);
-      }
-    }
-  };
-}
-
-function groupNodesByRelationPath(graph, eagerExpr) {
-  const nodesByRelationPath = groupBy(graph.nodes, (node) => node.relationPathKey);
-
-  // Not all relation paths have nodes. Relations with nulls or empty arrays
-  // don't have nodes, but will still need to be fetched. Add these to the
-  // map as empty arrays.
-  forEachPath(eagerExpr.node, (relationPath) => {
-    if (!nodesByRelationPath.has(relationPath)) {
-      nodesByRelationPath.set(relationPath, []);
-    }
-  });
-
-  return nodesByRelationPath;
-}
-
-function createFetchSelectModifier(nodes, graphOptions) {
-  if (graphOptions.isFetchStrategy(FetchStrategy.OnlyIdentifiers)) {
-    return createIdentifierSelector();
-  } else if (graphOptions.isFetchStrategy(FetchStrategy.OnlyNeeded)) {
-    return createInputColumnSelector(nodes);
-  } else {
-    return () => {};
-  }
-}
-
-// Returns a function that only selects the id column.
-function createIdentifierSelector() {
-  return (builder) => {
-    builder.select(builder.fullIdColumn());
-  };
-}
-
-// Returns a function that only selects the columns that exist in the input.
-function createInputColumnSelector(nodes) {
-  return (builder) => {
-    const selects = new Map();
-
-    for (const node of nodes) {
-      const databaseJson = node.obj.$toDatabaseJson(builder);
-      const declaredColumns = getDeclaredColumns(node.modelClass);
-
-      for (const key of Object.keys(databaseJson)) {
-        // Select the json column of field expressions like `'meta:a'`:
-        const column = getFieldExpressionColumn(key, declaredColumns) ?? key;
-
-        if (!shouldSelectColumn(column, selects, node)) {
-          continue;
-        }
-
-        const selection =
-          createManyToManyExtraSelectionIfNeeded(builder, column, node) ||
-          createSelection(builder, column, node);
-
-        selects.set(column, selection);
-      }
-    }
-
-    const selectArr = Array.from(selects.values());
-    const idColumns = asArray(builder.fullIdColumn());
-
-    for (const idColumn of idColumns) {
-      if (!selectArr.includes(idColumn)) {
-        // Always select the identifers.
-        selectArr.push(idColumn);
-      }
-    }
-
-    builder.select(selectArr);
-  };
-}
-
-function shouldSelectColumn(column, selects, node) {
-  const modelClass = node.modelClass;
-
-  return (
-    !selects.has(column) &&
-    column !== modelClass.propertyNameToColumnName(modelClass.dbRefProp) &&
-    column !== modelClass.propertyNameToColumnName(modelClass.uidRefProp) &&
-    column !== modelClass.propertyNameToColumnName(modelClass.uidProp) &&
-    column !== modelClass.propertyNameToColumnName(modelClass.graphUnrelateProp) &&
-    column !== modelClass.propertyNameToColumnName(modelClass.graphDeleteProp)
-  );
-}
-
-function createManyToManyExtraSelectionIfNeeded(builder, column, node) {
-  if (node.parentEdge && node.parentEdge.relation.isObjectionManyToManyRelation) {
-    const relation = node.parentEdge.relation;
-    const extra = relation.joinTableExtras.find((extra) => extra.aliasCol === column);
-
-    if (extra) {
-      return `${relation.joinTableAliasFor(builder)}.${extra.joinTableCol} as ${extra.aliasCol}`;
-    }
-  }
-
-  return null;
-}
-
-function createSelection(builder, column, node) {
-  return `${builder.tableRefFor(node.modelClass)}.${column}`;
-}
-
-function childQueryOptions() {
-  return {
-    fork: true,
-    isInternalQuery: true,
-  };
-}
-
-function fetchQueryInternalOptions() {
-  return {
-    keepImplicitJoinProps: true,
-  };
-}
-
-function forEachPath(eagerExprNode, cb, path = []) {
-  for (const relation of eagerExprNode.$childNames) {
-    path.push(relation);
-    cb(path.join('.'));
-    forEachPath(eagerExprNode[relation], cb, path);
-    path.pop();
-  }
-}
-
-module.exports = {
-  GraphFetcher,
-};

package/lib/queryBuilder/graph/GraphNodeDbExistence.js

@@ -1,184 +0,0 @@
-'use strict';
-
-const { GraphData } = require('./GraphData');
-const { GraphAction } = require('./GraphAction');
-const promiseUtils = require('../../utils/promiseUtils');
-
-/**
- * This weird little class is responsible for checking (and maintaining information)
- * whether certain nodes exist in the database.
- *
- * Note that this information is only calculated for nodes for which `insertMissing`
- * option is true.
- */
-class GraphNodeDbExistence {
-  static createEveryNodeExistsExistence() {
-    return new GraphNodeDbExistence(new Map());
-  }
-
-  /**
-   * Goes through the graphs and identifies nodes that may not exist in the db
-   * (nodes that have an id, but are not found in `currentGraph`) and
-   * creates an instance of GraphNodeDbExistence that can be used to
-   * synchronously check if a node exist in the database.
-   */
-  static async create({ builder, graph, graphOptions, currentGraph }) {
-    if (graphOptions.isInsertOnly()) {
-      // With insertGraph, we never want to do anything but inserts.
-      return GraphNodeDbExistence.createEveryNodeExistsExistence();
-    }
-
-    const graphData = new GraphData({
-      graph,
-      graphOptions,
-      currentGraph,
-      // We don't yet have an instance of GraphNodeDbExistence since we are
-      // creating one. We can (and should) safely use an instance that
-      // assumes that all nodes exist in the db for the purposes of this
-      // method.
-      nodeDbExistence: GraphNodeDbExistence.createEveryNodeExistsExistence(),
-    });
-
-    const { mayNotExist, mayNotExistNodes } = createMayNotExistMap(graphData);
-
-    if (mayNotExist.size == 0) {
-      // Early exit if we found no items for which we should check their
-      // existence in the db.
-      return GraphNodeDbExistence.createEveryNodeExistsExistence();
-    }
-
-    const dontExist = await createDontExistMap({ builder, mayNotExist, mayNotExistNodes });
-
-    return new GraphNodeDbExistence(dontExist);
-  }
-
-  constructor(dontExist) {
-    this.dontExist = dontExist;
-  }
-
-  doesNodeExistInDb(node) {
-    const idMap = this.dontExist.get(node.modelClass);
-
-    if (!idMap) {
-      return true;
-    }
-
-    return !idMap.has(node.obj.$idKey());
-  }
-}
-
-function createMayNotExistMap(graphData) {
-  const { graph, currentGraph, graphOptions } = graphData;
-
-  const mayNotExist = new Map();
-  const mayNotExistNodes = [];
-
-  for (const node of graph.nodes) {
-    if (
-      // As an optimization, only consider nodes for which `insertMissing` is true.
-      // We only need the information for those nodes.
-      graphOptions.shouldInsertMissing(node) &&
-      // Only consider nodes that will be related. We don't consider nodes that
-      // would get inserted with an id. Those will still result in a unique
-      // constraint error.
-      graphOptions.shouldRelate(node, graphData) &&
-      // Relate nodes may not have an id if they are `#ref` nodes. Only consider
-      // nodes that have an id so that we can check the existence.
-      node.hasId &&
-      // We can ignore nodes if they are found anywhere in the graph. `shouldRelate`
-      // only checks if the node is found in the same relation.
-      !hasNodeById(currentGraph, node)
-    ) {
-      if (!mayNotExist.has(node.modelClass)) {
-        mayNotExist.set(node.modelClass, new Map());
-      }
-
-      mayNotExist.get(node.modelClass).set(node.obj.$idKey(), node.obj.$id());
-      mayNotExistNodes.push(node);
-    }
-  }
-
-  return {
-    mayNotExist,
-    mayNotExistNodes,
-  };
-}
-
-function hasNodeById(currentGraph, nodeToFind) {
-  const { modelClass } = nodeToFind;
-
-  const tableToFind = modelClass.getTableName();
-  const idProps = modelClass.getIdPropertyArray();
-
-  return currentGraph.nodes.some((node) => {
-    return (
-      node.modelClass.getTableName() === tableToFind &&
-      idProps.every((idProp) => node.obj[idProp] === nodeToFind.obj[idProp])
-    );
-  });
-}
-
-async function createDontExistMap({ builder, mayNotExist, mayNotExistNodes }) {
-  const dontExist = cloneExistenceMap(mayNotExist);
-  const existenceCheckQueries = createExistenceCheckQueries({ builder, mayNotExist });
-
-  const results = await promiseUtils.map(existenceCheckQueries, (builder) => builder.execute(), {
-    concurrency: GraphAction.getConcurrency(builder, mayNotExistNodes),
-  });
-
-  // Remove all items from the mayNotExist map that we have just proven to exist
-  // by executing the existenceCheckQueries.
-  for (const modelResult of results) {
-    for (const item of modelResult) {
-      const modelClass = item.constructor;
-      const idMap = dontExist.get(modelClass);
-      // Exist, remove from the map.
-      idMap.delete(item.$idKey());
-    }
-  }
-
-  // Now only items that don't exist in the db are left in this map.
-  return dontExist;
-}
-
-function createExistenceCheckQueries({ builder, mayNotExist }) {
-  const builders = [];
-
-  for (const [modelClass, idMap] of mayNotExist.entries()) {
-    const ids = Array.from(idMap.values());
-
-    // Create one query per model class (table) to fetch the identifiers
-    // of the nodes that may not exist. These queries should be super fast
-    // since they come straight from the index.
-    builders.push(
-      modelClass
-        .query()
-        .childQueryOf(builder, childQueryOptions())
-        .findByIds(ids)
-        .select(modelClass.getIdColumnArray()),
-    );
-  }
-
-  return builders;
-}
-
-function childQueryOptions() {
-  return {
-    fork: true,
-    isInternalQuery: true,
-  };
-}
-
-function cloneExistenceMap(exixtenseMap) {
-  const clone = new Map(exixtenseMap);
-
-  for (const modelClass of clone.keys()) {
-    clone.set(modelClass, new Map(clone.get(modelClass)));
-  }
-
-  return clone;
-}
-
-module.exports = {
-  GraphNodeDbExistence,
-};

package/lib/queryBuilder/graph/GraphOperation.js

@@ -1,27 +0,0 @@
-'use strict';
-
-class GraphOperation {
-  constructor(graphData) {
-    this.graphData = graphData;
-  }
-
-  get graph() {
-    return this.graphData.graph;
-  }
-
-  get currentGraph() {
-    return this.graphData.currentGraph;
-  }
-
-  get graphOptions() {
-    return this.graphData.graphOptions;
-  }
-
-  createActions() {
-    return [];
-  }
-}
-
-module.exports = {
-  GraphOperation,
-};

package/lib/queryBuilder/graph/delete/GraphDelete.js

@@ -1,73 +0,0 @@
-'use strict';
-
-const { GraphOperation } = require('../GraphOperation');
-const { GraphDeleteAction } = require('./GraphDeleteAction');
-const { getPropertyTypes } = require('../../../model/modelJsonAttributes');
-
-class GraphDelete extends GraphOperation {
-  // The owner of a BelongsToOneRelation row references it until `GraphPatch`
-  // points the owner to a new row or to null. These rows are deleted
-  // afterwards by `GraphDereferencedBelongsToOneDelete`, all others before.
-  get deletesDereferencedRows() {
-    return false;
-  }
-
-  createActions() {
-    return [
-      new GraphDeleteAction(this.graphData, {
-        nodes: this.currentGraph.nodes.filter(
-          (currentNode) =>
-            this.graphOptions.shouldDeleteOrUnrelate(currentNode, this.graphData) &&
-            isDereferencedBelongsToOneNode(currentNode, this.graphData) ===
-              this.deletesDereferencedRows,
-        ),
-        areReferenced: !this.deletesDereferencedRows,
-      }),
-    ];
-  }
-}
-
-class GraphDereferencedBelongsToOneDelete extends GraphDelete {
-  get deletesDereferencedRows() {
-    return true;
-  }
-}
-
-function isDereferencedBelongsToOneNode(currentNode, graphData) {
-  const { graph, graphOptions } = graphData;
-  const relation = currentNode.parentEdge?.relation;
-  const parentNode = graph.nodeForNode(currentNode.parentNode);
-
-  if (relation?.isObjectionBelongsToOneRelation && parentNode) {
-    const node = graph.nodeForNode(currentNode);
-    const isReplaced = parentNode.edges.some(
-      (edge) =>
-        edge.relation === relation &&
-        edge.isOwnerNode(parentNode) &&
-        !graphOptions.shouldIgnore(edge.relatedNode, graphData),
-    );
-    const isRemoved =
-      parentNode.obj[relation.name] === null || (!!node && node.toBeUnrelatedOrDeleted);
-
-    // Removing the row sets the owner's foreign key to null, but only where
-    // its schema allows it. Otherwise we delete the row first and leave the
-    // owner's reference to the database, as the column may be `NOT NULL`.
-    return (
-      isReplaced ||
-      (isRemoved &&
-        relation.ownerProp.props.every((prop) => isNullable(relation.ownerModelClass, prop)))
-    );
-  } else {
-    return false;
-  }
-}
-
-function isNullable(modelClass, prop) {
-  const schema = modelClass.getJsonSchema()?.properties?.[prop];
-  return !!schema && (schema.nullable === true || getPropertyTypes(schema).includes('null'));
-}
-
-module.exports = {
-  GraphDelete,
-  GraphDereferencedBelongsToOneDelete,
-};

package/lib/queryBuilder/graph/delete/GraphDeleteAction.js

@@ -1,88 +0,0 @@
-'use strict';
-
-const { GraphAction } = require('../GraphAction');
-const { groupBy } = require('../../../utils/objectUtils');
-const promiseUtils = require('../../../utils/promiseUtils');
-
-class GraphDeleteAction extends GraphAction {
-  constructor(graphData, { nodes, areReferenced = true }) {
-    super(graphData);
-    // Nodes to delete.
-    this.nodes = nodes;
-    // Whether the parents still reference the nodes. Rows of
-    // BelongsToOneRelations can be deleted after their owners were patched to
-    // reference new rows or null, so they can't be found through the relation.
-    this.areReferenced = areReferenced;
-  }
-
-  run(builder) {
-    const nodesTodelete = this._filterOutBelongsToOneRelationUnrelates(this.nodes);
-    const builders = this._createDeleteBuilders(builder, nodesTodelete);
-
-    return promiseUtils.map(builders, (builder) => builder.execute(), {
-      concurrency: this._getConcurrency(builder, nodesTodelete),
-    });
-  }
-
-  _filterOutBelongsToOneRelationUnrelates(nodes) {
-    // `BelongsToOneRelation` unrelate is handled by `GraphPatch` because
-    // unrelating a `BelongsToOneRelation` is just a matter of updating
-    // one field of the parent node.
-    return nodes.filter((node) => {
-      return !(
-        this.graphOptions.shouldUnrelate(node, this.graphData) &&
-        node.parentEdge.relation.isObjectionBelongsToOneRelation
-      );
-    });
-  }
-
-  _createDeleteBuilders(parentBuilder, nodesTodelete) {
-    const nodesByRelation = groupBy(nodesTodelete, getRelation);
-    const builders = [];
-
-    nodesByRelation.forEach((nodes, relation) => {
-      const nodesByParent = groupBy(nodes, getParent);
-
-      nodesByParent.forEach((nodes, parentNode) => {
-        // Nodes of the same relation and parent can still require different
-        // operations when they are marked with `#unrelate` or `#delete`.
-        const nodesByShouldUnrelate = groupBy(nodes, (node) =>
-          this.graphOptions.shouldUnrelate(node, this.graphData),
-        );
-
-        nodesByShouldUnrelate.forEach((nodes, shouldUnrelate) => {
-          const builder = (
-            this.areReferenced
-              ? parentNode.obj.$relatedQuery(relation.name)
-              : relation.relatedModelClass.query()
-          ).childQueryOf(parentBuilder);
-
-          if (!this.areReferenced || !relation.isObjectionBelongsToOneRelation) {
-            // This is useless in case of a referenced BelongsToOneRelation.
-            builder.findByIds(nodes.map((node) => node.obj.$id()));
-          }
-
-          for (const node of nodes) {
-            node.userData.deleted = true;
-          }
-
-          builders.push(shouldUnrelate ? builder.unrelate() : builder.delete());
-        });
-      });
-    });
-
-    return builders;
-  }
-}
-
-function getRelation(node) {
-  return node.parentEdge.relation;
-}
-
-function getParent(node) {
-  return node.parentNode;
-}
-
-module.exports = {
-  GraphDeleteAction,
-};

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

@@ -1,58 +0,0 @@
-'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, which are copied from the related nodes
- * and patched in with one 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, relatedNode } of edges) {
-      const { ownerProp, relatedProp } = relation;
-
-      ownerProp.forEach((i) => {
-        const value = relatedProp.getProp(relatedNode.obj, i);
-        ownerProp.setProp(ownerNode.obj, i, value);
-        ownerProp.patch(patch, i, value);
-      });
-    }
-
-    return modelClass
-      .query()
-      .childQueryOf(builder)
-      .patch(patch)
-      .whereInComposite(ownerIdProp.refs(builder), [ownerIdProp.getProps(ownerNode.obj)]);
-  }
-}
-
-module.exports = {
-  DeferredRelationGraphInsertAction,
-};