objection 3.9.0 → 4.0.0-rc.1

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

@@ -1,257 +0,0 @@
-'use strict';
-
-const { JoinRowGraphInsertAction } = require('./JoinRowGraphInsertAction');
-const { DeferredRelationGraphInsertAction } = require('./DeferredRelationGraphInsertAction');
-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();
-    this.deferredEdges = new Set();
-  }
-
-  createActions() {
-    return [
-      ...this._createNormalActions(),
-      ...this._createDeferredRelationActions(),
-      ...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.relatedNode.toBeUnrelatedOrDeleted) {
-      // Models marked with `#unrelate` or `#delete` are never inserted or
-      // related, so their keys must not be copied to the owner (or vice versa).
-      return;
-    }
-
-    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 &&
-      // Ignored models don't replace the current one, so their keys must not
-      // be copied to the owner either.
-      !this.graphOptions.shouldIgnore(edge.relatedNode, this.graphData)
-    ) {
-      // 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) {
-        if (handledNodes.size !== this.graph.nodes.length && this._breakCycle(handledNodes)) {
-          continue;
-        }
-
-        break;
-      }
-
-      actions.push(
-        new GraphInsertAction(this.graphData, {
-          nodes: nodesToInsert,
-          dependencies: this.dependencies,
-          deferredEdges: this.deferredEdges,
-        }),
-      );
-
-      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;
-  }
-
-  // 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;
-  }
-
-  _canDeferEdge(edge, node) {
-    return (
-      edge.type === ModelGraphEdge.Type.Relation &&
-      edge.relation.isObjectionBelongsToOneRelation &&
-      edge.isOwnerNode(node) &&
-      edge.relatedNode.isReference &&
-      // The owner is patched by its id, which models without one don't have (#2305).
-      node.modelClass.getIdColumnArray().length > 0 &&
-      // 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;
-    }
-
-    visitedNodes.add(node);
-
-    for (const edge of this._pendingDependencyEdges(node, handledNodes)) {
-      if (this._isBlockedBy(edge.getOtherNode(node), blockingNode, handledNodes, visitedNodes)) {
-        return true;
-      }
-    }
-
-    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);
-
-    // 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,
-};

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

@@ -1,238 +0,0 @@
-'use strict';
-
-const { GraphAction } = require('../GraphAction');
-const { groupBy, chunk, get, set } = require('../../../utils/objectUtils');
-const { ModelGraphEdge } = require('../../../model/graph/ModelGraphEdge');
-const promiseUtils = require('../../../utils/promiseUtils');
-
-/**
- * Inserts a batch of nodes for a GraphInsert.
- *
- * One of these is created for each batch of nodes that can be inserted at once.
- * However, the nodes can have a different table and not all databases support
- * batch inserts, so this class splits the inserts into further sub batches
- * when needed.
- */
-class GraphInsertAction extends GraphAction {
-  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) {
-    const batches = this._createInsertBatches(builder);
-    const concurrency = this._getConcurrency(builder, this.nodes);
-
-    return promiseUtils.map(batches, (batch) => this._insertBatch(builder, batch), { concurrency });
-  }
-
-  _createInsertBatches(builder) {
-    const batches = [];
-    const batchSize = this._getBatchSize(builder);
-    const nodesByModelClass = groupBy(this.nodes, getModelClass);
-
-    for (const nodes of nodesByModelClass.values()) {
-      for (const nodeBatch of chunk(nodes, batchSize)) {
-        batches.push(nodeBatch);
-      }
-    }
-
-    return batches;
-  }
-
-  async _insertBatch(parentBuilder, nodes) {
-    await this._beforeInsert(nodes);
-    await this._insert(parentBuilder, nodes);
-    await this._afterInsert(nodes);
-  }
-
-  _beforeInsert(nodes) {
-    this._resolveDependencies(nodes);
-    this._omitManyToManyExtraProps(nodes);
-    this._copyRelationPropsFromCurrentIfNeeded(nodes);
-
-    return Promise.resolve();
-  }
-
-  _resolveDependencies(nodes) {
-    for (const node of nodes) {
-      const edges = this.dependencies.get(node);
-
-      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);
-
-          this._resolveDependency(dependencyNode, edge);
-        }
-      }
-    }
-  }
-
-  _resolveDependency(dependencyNode, edge) {
-    if (edge.type === ModelGraphEdge.Type.Relation && !edge.relation.joinTable) {
-      this._resolveRelationDependency(dependencyNode, edge);
-    } else if (edge.refType === ModelGraphEdge.ReferenceType.Property) {
-      this._resolvePropertyReferenceNode(dependencyNode, edge);
-    }
-  }
-
-  _resolveRelationDependency(dependencyNode, edge) {
-    const dependentNode = edge.getOtherNode(dependencyNode);
-
-    let sourceProp;
-    let targetProp;
-
-    if (edge.isOwnerNode(dependencyNode)) {
-      sourceProp = edge.relation.ownerProp;
-      targetProp = edge.relation.relatedProp;
-    } else {
-      targetProp = edge.relation.ownerProp;
-      sourceProp = edge.relation.relatedProp;
-    }
-
-    this._resolveReferences(dependencyNode);
-
-    targetProp.forEach((i) => {
-      targetProp.setProp(dependentNode.obj, i, sourceProp.getProp(dependencyNode.obj, i));
-    });
-  }
-
-  _resolvePropertyReferenceNode(dependencyNode, edge) {
-    const dependentNode = edge.getOtherNode(dependencyNode);
-
-    let sourcePath;
-    let targetPath;
-
-    if (edge.isOwnerNode(dependencyNode)) {
-      sourcePath = edge.refOwnerDataPath;
-      targetPath = edge.refRelatedDataPath;
-    } else {
-      targetPath = edge.refOwnerDataPath;
-      sourcePath = edge.refRelatedDataPath;
-    }
-
-    const sourceValue = get(dependencyNode.obj, sourcePath);
-    const targetValue = get(dependentNode.obj, targetPath);
-
-    if (targetValue === edge.refMatch) {
-      set(dependentNode.obj, targetPath, sourceValue);
-    } else {
-      set(dependentNode.obj, targetPath, targetValue.replace(edge.refMatch, sourceValue));
-    }
-  }
-
-  _omitManyToManyExtraProps(nodes) {
-    for (const node of nodes) {
-      if (
-        node.parentEdge &&
-        node.parentEdge.type === ModelGraphEdge.Type.Relation &&
-        node.parentEdge.relation.joinTableExtras.length > 0
-      ) {
-        node.parentEdge.relation.omitExtraProps([node.obj]);
-      }
-    }
-  }
-
-  _copyRelationPropsFromCurrentIfNeeded(nodes) {
-    for (const node of nodes) {
-      const currentNode = this.currentGraph.nodeForNode(node);
-
-      if (!currentNode) {
-        continue;
-      }
-
-      for (const edge of node.edges) {
-        if (edge.type !== ModelGraphEdge.Type.Relation) {
-          continue;
-        }
-
-        const prop = edge.isOwnerNode(node) ? edge.relation.ownerProp : edge.relation.relatedProp;
-
-        prop.forEach((i) => {
-          const value = prop.getProp(node.obj, i);
-
-          if (value !== undefined) {
-            return;
-          }
-
-          prop.setProp(node.obj, i, prop.getProp(currentNode.obj, i));
-        });
-      }
-    }
-  }
-
-  _insert(parentBuilder, nodes) {
-    const [{ modelClass }] = nodes;
-
-    nodes = nodes.filter((node) => {
-      return this.graphOptions.shouldInsert(node, this.graphData);
-    });
-
-    for (const node of nodes) {
-      delete node.obj[modelClass.uidProp];
-      delete node.obj[modelClass.graphUnrelateProp];
-      delete node.obj[modelClass.graphDeleteProp];
-      node.obj.$validate(null, { dataPath: node.dataPathKey });
-    }
-
-    if (nodes.length === 0) {
-      return;
-    }
-
-    for (const node of nodes) {
-      node.userData.inserted = true;
-    }
-
-    return this._runRelationBeforeInsertMethods(parentBuilder, nodes).then(() => {
-      return modelClass
-        .query()
-        .insert(nodes.map((node) => node.obj))
-        .childQueryOf(parentBuilder)
-        .copyFrom(parentBuilder, GraphAction.ReturningAllSelector)
-        .execute();
-    });
-  }
-
-  _runRelationBeforeInsertMethods(parentBuilder, nodes) {
-    return Promise.all(
-      nodes.map((node) => {
-        if (node.parentEdge) {
-          return node.parentEdge.relation.beforeInsert(
-            node.obj,
-            parentBuilder.context(),
-            node.parentNode.obj,
-          );
-        } else {
-          return null;
-        }
-      }),
-    );
-  }
-
-  _afterInsert(nodes) {
-    for (const node of nodes) {
-      for (const refNode of node.referencingNodes) {
-        this._resolveDependency(refNode, refNode.parentEdge);
-      }
-    }
-  }
-}
-
-function getModelClass(node) {
-  return node.modelClass;
-}
-
-module.exports = {
-  GraphInsertAction,
-};

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

@@ -1,92 +0,0 @@
-'use strict';
-
-const { GraphAction } = require('../GraphAction');
-const { groupBy, chunk } = require('../../../utils/objectUtils');
-const promiseUtils = require('../../../utils/promiseUtils');
-
-class JoinRowGraphInsertAction extends GraphAction {
-  constructor(graphData, { nodes }) {
-    super(graphData);
-    this.nodes = nodes;
-  }
-
-  run(builder) {
-    const batches = this._createInsertBatches(builder);
-    const concurrency = this._getConcurrency(builder, this.nodes);
-
-    return promiseUtils.map(batches, (batch) => this._insertBatch(builder, batch), { concurrency });
-  }
-
-  _createInsertBatches(builder) {
-    const batches = [];
-    const batchSize = this._getBatchSize(builder);
-    const nodesByModel = groupBy(this.nodes, (node) => getJoinTableModel(builder, node));
-
-    for (const [joinTableModelClass, nodes] of nodesByModel.entries()) {
-      for (const nodeBatch of chunk(nodes, batchSize)) {
-        batches.push(this._createBatch(joinTableModelClass, nodeBatch));
-      }
-    }
-
-    return batches;
-  }
-
-  _createBatch(joinTableModelClass, nodes) {
-    return nodes
-      .filter((node) => {
-        return this.graphOptions.shouldRelate(node, this.graphData) || node.userData.inserted;
-      })
-      .map((node) => ({
-        node,
-        joinTableModelClass,
-        joinTableObj: this._createJoinTableObj(joinTableModelClass, node),
-      }));
-  }
-
-  _createJoinTableObj(joinTableModelClass, node) {
-    const { parentEdge, parentNode } = node;
-    const { relation } = parentEdge;
-
-    this._resolveReferences(node);
-
-    return joinTableModelClass.fromJson(
-      relation.createJoinModel(relation.ownerProp.getProps(parentNode.obj), node.obj),
-    );
-  }
-
-  _insertBatch(parentBuilder, batch) {
-    return this._beforeInsert(parentBuilder, batch).then(() => this._insert(parentBuilder, batch));
-  }
-
-  _beforeInsert(parentBuilder, batch) {
-    return Promise.all(
-      batch.map(({ node, joinTableObj }) => {
-        if (node.parentEdge) {
-          return node.parentEdge.relation.joinTableBeforeInsert(
-            joinTableObj,
-            parentBuilder.context(),
-          );
-        } else {
-          return null;
-        }
-      }),
-    );
-  }
-
-  _insert(parentBuilder, batch) {
-    if (batch.length > 0) {
-      return batch[0].joinTableModelClass
-        .query()
-        .childQueryOf(parentBuilder)
-        .insert(batch.map((it) => it.joinTableObj));
-    }
-  }
-}
-
-function getJoinTableModel(builder, node) {
-  return node.parentEdge.relation.getJoinModelClass(builder.unsafeKnex());
-}
-
-module.exports = {
-  JoinRowGraphInsertAction,
-};

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

@@ -1,20 +0,0 @@
-'use strict';
-
-const { GraphOperation } = require('../GraphOperation');
-const { GraphPatchAction } = require('./GraphPatchAction');
-
-class GraphPatch extends GraphOperation {
-  createActions() {
-    return [
-      new GraphPatchAction(this.graphData, {
-        nodes: this.graph.nodes.filter((node) =>
-          this.graphOptions.shouldPatchOrUpdateIgnoreDisable(node, this.graphData),
-        ),
-      }),
-    ];
-  }
-}
-
-module.exports = {
-  GraphPatch,
-};