@abedmurrar/objection 0.0.0-stage → 4.0.0-alpha.0

package/lib/queryBuilder/graph/GraphUpsert.js

@@ -0,0 +1,305 @@
+'use strict';
+
+const { ModelGraph } = require('../../model/graph/ModelGraph');
+const { ModelGraphEdge } = require('../../model/graph/ModelGraphEdge');
+const { createNotModelError } = require('../../model/graph/ModelGraphBuilder');
+const { GraphFetcher } = require('../graph/GraphFetcher');
+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 { ValidationErrorType } = require('../../model/ValidationError');
+const { RelationExpression } = require('../RelationExpression');
+const { GraphNodeDbExistence } = require('./GraphNodeDbExistence');
+const { GraphData } = require('./GraphData');
+const { uniqBy, asArray, isObject } = require('../../utils/objectUtils');
+
+class GraphUpsert {
+  constructor({ rootModelClass, objects, upsertOptions }) {
+    checkCanBeConvertedToModels(rootModelClass, objects);
+
+    this.objects = rootModelClass.ensureModelArray(objects, GraphUpsert.modelOptions);
+    this.isArray = Array.isArray(objects);
+    this.upsertOpt = upsertOptions;
+  }
+
+  static get modelOptions() {
+    return { skipValidation: true };
+  }
+
+  run(builder) {
+    const modelClass = builder.modelClass();
+    const graphOptions = new GraphOptions(this.upsertOpt);
+
+    const graph = ModelGraph.create(modelClass, this.objects);
+    assignDbRefsAsRelateProps(graph);
+
+    return createGraphData(builder, graphOptions, graph)
+      .then(checkForErrors(builder))
+      .then(pruneGraphs())
+      .then(executeOperations(builder))
+      .then(returnResult(this.objects, this.isArray));
+  }
+}
+
+function checkCanBeConvertedToModels(modelClass, objects) {
+  asArray(objects).forEach((obj) => {
+    if (!isObject(obj)) {
+      throw createNotModelError(modelClass, obj);
+    }
+  });
+}
+
+function assignDbRefsAsRelateProps(graph) {
+  for (const node of graph.nodes) {
+    if (!node.parentEdge || !node.parentEdge.relation || !node.isDbReference) {
+      continue;
+    }
+
+    node.parentEdge.relation.setRelateProp(node.obj, asArray(node.dbReference));
+  }
+}
+
+async function createGraphData(builder, graphOptions, graph) {
+  const currentGraph = await fetchCurrentGraph(builder, graphOptions, graph);
+
+  const nodeDbExistence = await GraphNodeDbExistence.create({
+    builder,
+    graph,
+    graphOptions,
+    currentGraph,
+  });
+
+  return new GraphData({ graph, currentGraph, graphOptions, nodeDbExistence });
+}
+
+function fetchCurrentGraph(builder, graphOptions, graph) {
+  if (graphOptions.isInsertOnly()) {
+    return Promise.resolve(ModelGraph.createEmpty());
+  } else {
+    return GraphFetcher.fetchCurrentGraph({ builder, graph, graphOptions });
+  }
+}
+
+// Remove branches from the graph that require no operations. For example
+// we never want to do anything for descendant nodes of a node that is
+// deleted or unrelated. We never delete recursively.
+function pruneGraphs() {
+  return (graphData) => {
+    pruneRelatedBranches(graphData);
+
+    if (!graphData.graphOptions.isInsertOnly()) {
+      pruneDeletedBranches(graphData);
+    }
+
+    return graphData;
+  };
+}
+
+function pruneRelatedBranches(graphData) {
+  const relateNodes = graphData.graph.nodes.filter((node) => {
+    return (
+      !graphData.currentGraph.nodeForNode(node) &&
+      !graphData.graphOptions.shouldInsertIgnoreDisable(node, graphData)
+    );
+  });
+
+  removeBranchesFromGraph(findRoots(relateNodes), graphData.graph);
+}
+
+function pruneDeletedBranches(graphData) {
+  const { graph, currentGraph } = graphData;
+
+  const deleteNodes = currentGraph.nodes.filter((currentNode) => !graph.nodeForNode(currentNode));
+  const roots = findRoots(deleteNodes);
+
+  // Don't delete relations the current graph doesn't even mention.
+  // So if the parent node doesn't even have the relation, it's not
+  // supposed to be deleted.
+  const rootsNotInRelation = roots.filter((deleteRoot) => {
+    if (!deleteRoot.parentNode) {
+      return false;
+    }
+
+    const { relation } = deleteRoot.parentEdge;
+    const parentNode = graph.nodeForNode(deleteRoot.parentNode);
+
+    if (!parentNode) {
+      return false;
+    }
+
+    return parentNode.obj[relation.name] === undefined;
+  });
+
+  removeBranchesFromGraph(roots, currentGraph);
+  removeNodesFromGraph(new Set(rootsNotInRelation), currentGraph);
+}
+
+function findRoots(nodes) {
+  const nodeSet = new Set(nodes);
+
+  return uniqBy(
+    nodes.filter((node) => {
+      let parentNode = node.parentNode;
+
+      while (parentNode) {
+        if (nodeSet.has(parentNode)) {
+          return false;
+        }
+
+        parentNode = parentNode.parentNode;
+      }
+
+      return true;
+    }),
+  );
+}
+
+function removeBranchesFromGraph(branchRoots, graph) {
+  const nodesToRemove = new Set(
+    branchRoots.reduce(
+      (nodesToRemove, node) => [...nodesToRemove, ...node.descendantRelationNodes],
+      [],
+    ),
+  );
+
+  removeNodesFromGraph(nodesToRemove, graph);
+}
+
+function removeNodesFromGraph(nodesToRemove, graph) {
+  const edgesToRemove = new Set();
+
+  for (const node of nodesToRemove) {
+    for (const edge of node.edges) {
+      const otherNode = edge.getOtherNode(node);
+
+      if (!nodesToRemove.has(otherNode)) {
+        otherNode.removeEdge(edge);
+        edgesToRemove.add(edge);
+      }
+    }
+  }
+
+  graph.nodes = graph.nodes.filter((node) => !nodesToRemove.has(node));
+  graph.edges = graph.edges.filter((edge) => !edgesToRemove.has(edge));
+
+  return graph;
+}
+
+function checkForErrors(builder) {
+  return (graphData) => {
+    checkForNotFoundErrors(graphData, builder);
+    checkForUnallowedRelationErrors(graphData, builder);
+    checkForUnallowedReferenceErrors(graphData, builder);
+
+    if (graphData.graphOptions.isInsertOnly()) {
+      checkForHasManyRelateErrors(graphData);
+    }
+
+    return graphData;
+  };
+}
+
+function checkForNotFoundErrors(graphData, builder) {
+  const { graphOptions, currentGraph, graph } = graphData;
+
+  for (const node of graph.nodes) {
+    if (
+      node.obj.$hasId() &&
+      !graphOptions.shouldInsertIgnoreDisable(node, graphData) &&
+      !graphOptions.shouldRelateIgnoreDisable(node, graphData) &&
+      !currentGraph.nodeForNode(node)
+    ) {
+      if (!node.parentNode) {
+        throw node.modelClass.createNotFoundError(builder.context(), {
+          message: `root model (id=${node.obj.$id()}) does not exist. If you want to insert it with an id, use the insertMissing option`,
+          dataPath: node.dataPath,
+        });
+      } else {
+        throw node.modelClass.createNotFoundError(builder.context(), {
+          message: `model (id=${node.obj.$id()}) is not a child of model (id=${node.parentNode.obj.$id()}). If you want to relate it, use the relate option. If you want to insert it with an id, use the insertMissing option`,
+          dataPath: node.dataPath,
+        });
+      }
+    }
+  }
+}
+
+function checkForUnallowedRelationErrors(graphData, builder) {
+  const { graph } = graphData;
+  const allowedExpression = builder.allowedGraphExpression();
+
+  if (allowedExpression) {
+    const rootsObjs = graph.nodes.filter((node) => !node.parentEdge).map((node) => node.obj);
+    const expression = RelationExpression.fromModelGraph(rootsObjs);
+
+    if (!allowedExpression.isSubExpression(expression)) {
+      throw builder.modelClass().createValidationError({
+        type: ValidationErrorType.UnallowedRelation,
+        message: 'trying to upsert an unallowed relation',
+      });
+    }
+  }
+}
+
+function checkForUnallowedReferenceErrors(graphData, builder) {
+  const { graph, graphOptions } = graphData;
+
+  if (graphOptions.allowRefs()) {
+    return;
+  }
+
+  if (graph.edges.some((edge) => edge.type === ModelGraphEdge.Type.Reference)) {
+    throw builder.modelClass().createValidationError({
+      type: ValidationErrorType.InvalidGraph,
+      message:
+        '#ref references are not allowed in a graph by default. see the allowRefs insert/upsert graph option',
+    });
+  }
+}
+
+function checkForHasManyRelateErrors(graphData) {
+  const { graph, graphOptions } = graphData;
+
+  for (const node of graph.nodes) {
+    if (
+      graphOptions.shouldRelate(node, graphData) &&
+      node.parentEdge.relation.isObjectionHasManyRelation
+    ) {
+      throw new Error(
+        'You cannot relate HasManyRelation or HasOneRelation using insertGraph, because those require update operations. Consider using upsertGraph instead.',
+      );
+    }
+  }
+}
+
+function executeOperations(builder) {
+  return (graphData) => {
+    const operations = graphData.graphOptions.isInsertOnly()
+      ? [GraphInsert]
+      : [GraphDelete, GraphInsert, GraphPatch, GraphRecursiveUpsert];
+
+    return operations.reduce((promise, Operation) => {
+      const operation = new Operation(graphData);
+      const actions = operation.createActions();
+
+      return promise.then(() => executeActions(builder, actions));
+    }, Promise.resolve());
+  };
+}
+
+function executeActions(builder, actions) {
+  return actions.reduce(
+    (promise, action) => promise.then(() => action.run(builder)),
+    Promise.resolve(),
+  );
+}
+
+function returnResult(objects, isArray) {
+  return () => (isArray ? objects : objects[0]);
+}
+
+module.exports = {
+  GraphUpsert,
+};

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

@@ -0,0 +1,20 @@
+'use strict';
+
+const { GraphOperation } = require('../GraphOperation');
+const { GraphDeleteAction } = require('./GraphDeleteAction');
+
+class GraphDelete extends GraphOperation {
+  createActions() {
+    return [
+      new GraphDeleteAction(this.graphData, {
+        nodes: this.currentGraph.nodes.filter((currentNode) =>
+          this.graphOptions.shouldDeleteOrUnrelate(currentNode, this.graphData),
+        ),
+      }),
+    ];
+  }
+}
+
+module.exports = {
+  GraphDelete,
+};

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

@@ -0,0 +1,74 @@
+'use strict';
+
+const { GraphAction } = require('../GraphAction');
+const { groupBy } = require('../../../utils/objectUtils');
+const promiseUtils = require('../../../utils/promiseUtils');
+
+class GraphDeleteAction extends GraphAction {
+  constructor(graphData, { nodes }) {
+    super(graphData);
+    // Nodes to delete.
+    this.nodes = nodes;
+  }
+
+  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) => {
+        const shouldUnrelate = this.graphOptions.shouldUnrelate(nodes[0], this.graphData);
+
+        const builder = parentNode.obj.$relatedQuery(relation.name).childQueryOf(parentBuilder);
+
+        if (!relation.isObjectionBelongsToOneRelation) {
+          // This is useless in case of 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/GraphInsert.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const { JoinRowGraphInsertAction } = require('./JoinRowGraphInsertAction');
+const { GraphInsertAction } = require('./GraphInsertAction');
+const { GraphOperation } = require('../GraphOperation');
+const { ModelGraphEdge } = require('../../../model/graph/ModelGraphEdge');
+
+class GraphInsert extends GraphOperation {
+  constructor(...args) {
+    super(...args);
+    this.dependencies = this._createDependencyMap();
+  }
+
+  createActions() {
+    return [...this._createNormalActions(), ...this._createJoinRowActions()];
+  }
+
+  _createDependencyMap() {
+    const dependencies = new Map();
+
+    for (const edge of this.graph.edges) {
+      if (edge.type == ModelGraphEdge.Type.Relation) {
+        this._createRelationDependency(edge, dependencies);
+      } else {
+        this._createReferenceDependency(edge, dependencies);
+      }
+    }
+
+    return dependencies;
+  }
+
+  _createRelationDependency(edge, dependencies) {
+    if (edge.relation.isObjectionHasManyRelation) {
+      // In case of HasManyRelation the related node depends on the owner node
+      // because the related node has the foreign key.
+      this._addDependency(edge.relatedNode, edge, dependencies);
+    } else if (edge.relation.isObjectionBelongsToOneRelation) {
+      // In case of BelongsToOneRelation the owner node depends on the related
+      // node because the owner node has the foreign key.
+      this._addDependency(edge.ownerNode, edge, dependencies);
+    }
+  }
+
+  _createReferenceDependency(edge, dependencies) {
+    this._addDependency(edge.ownerNode, edge, dependencies);
+  }
+
+  _addDependency(node, edge, dependencies) {
+    let edges = dependencies.get(node);
+
+    if (!edges) {
+      edges = [];
+      dependencies.set(node, edges);
+    }
+
+    edges.push(edge);
+  }
+
+  _createNormalActions() {
+    const handledNodes = new Set();
+    const actions = [];
+
+    while (true) {
+      // At this point, don't care if the nodes have already been inserted before
+      // given to this class. `GraphInsertAction` will test that and only insert
+      // new ones. We need to pass all nodes to `GraphInsertActions` so that we
+      // can resolve all dependencies.
+      const nodesToInsert = this.graph.nodes.filter((node) => {
+        return !this._isHandled(node, handledNodes) && !this._hasDependencies(node, handledNodes);
+      });
+
+      if (nodesToInsert.length === 0) {
+        break;
+      }
+
+      actions.push(
+        new GraphInsertAction(this.graphData, {
+          nodes: nodesToInsert,
+          dependencies: this.dependencies,
+        }),
+      );
+
+      for (const node of nodesToInsert) {
+        this._markHandled(node, handledNodes);
+      }
+    }
+
+    if (handledNodes.size !== this.graph.nodes.length) {
+      throw new Error('the object graph contains cyclic references');
+    }
+
+    return actions;
+  }
+
+  _isHandled(node, handledNodes) {
+    return handledNodes.has(node);
+  }
+
+  _hasDependencies(node, handledNodes) {
+    if (!this.dependencies.has(node)) {
+      return false;
+    }
+
+    for (const edge of this.dependencies.get(node)) {
+      const dependencyNode = edge.getOtherNode(node);
+
+      if (!handledNodes.has(dependencyNode) && !this.currentGraph.nodeForNode(dependencyNode)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  _markHandled(node, handledNodes) {
+    handledNodes.add(node);
+
+    // The referencing nodes are all references that don't
+    // represent any real entity. They are simply intermediate nodes
+    // that depend on this node. Once this node is handled, we can
+    // also mark those nodes as handled as there is nothing to actually
+    // insert.
+    for (const refNode of node.referencingNodes) {
+      this._markHandled(refNode, handledNodes);
+    }
+  }
+
+  _createJoinRowActions() {
+    return [
+      new JoinRowGraphInsertAction(this.graphData, {
+        nodes: this.graph.nodes.filter((node) => {
+          return (
+            this.currentGraph.nodeForNode(node) === null &&
+            node.parentEdge &&
+            node.parentEdge.relation.isObjectionManyToManyRelation
+          );
+        }),
+      }),
+    ];
+  }
+}
+
+module.exports = {
+  GraphInsert,
+};