@abedmurrar/objection 4.0.0-alpha.0 → 4.0.0-beta.0

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

@@ -1,145 +1,116 @@
 '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);
-      }
+    constructor(...args) {
+        super(...args);
+        this.dependencies = this._createDependencyMap();
     }
-
-    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);
+    createActions() {
+        return [...this._createNormalActions(), ...this._createJoinRowActions()];
     }
-  }
-
-  _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);
+    _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;
     }
-
-    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);
-      }
+    _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);
+        }
     }
-
-    if (handledNodes.size !== this.graph.nodes.length) {
-      throw new Error('the object graph contains cyclic references');
+    _createReferenceDependency(edge, dependencies) {
+        this._addDependency(edge.ownerNode, edge, dependencies);
     }
-
-    return actions;
-  }
-
-  _isHandled(node, handledNodes) {
-    return handledNodes.has(node);
-  }
-
-  _hasDependencies(node, handledNodes) {
-    if (!this.dependencies.has(node)) {
-      return false;
+    _addDependency(node, edge, dependencies) {
+        let edges = dependencies.get(node);
+        if (!edges) {
+            edges = [];
+            dependencies.set(node, edges);
+        }
+        edges.push(edge);
     }
-
-    for (const edge of this.dependencies.get(node)) {
-      const dependencyNode = edge.getOtherNode(node);
-
-      if (!handledNodes.has(dependencyNode) && !this.currentGraph.nodeForNode(dependencyNode)) {
-        return true;
-      }
+    _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;
     }
-
-    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);
+    _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);
+                }),
+            }),
+        ];
     }
-  }
-
-  _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,
+    GraphInsert,
 };

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

@@ -1,10 +1,8 @@
 '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.
  *
@@ -14,212 +12,172 @@ const promiseUtils = require('../../../utils/promiseUtils');
  * when needed.
  */
 class GraphInsertAction extends GraphAction {
-  constructor(graphData, { nodes, dependencies }) {
-    super(graphData);
-
-    // Nodes to insert.
-    this.nodes = nodes;
-    this.dependencies = dependencies;
-  }
-
-  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);
-      }
+    constructor(graphData, { nodes, dependencies }) {
+        super(graphData);
+        // Nodes to insert.
+        this.nodes = nodes;
+        this.dependencies = dependencies;
     }
-
-    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) {
-          // `node` needs `dependencyNode` to have been inserted (and it has been).
-          const dependencyNode = edge.getOtherNode(node);
-
-          this._resolveDependency(dependencyNode, edge);
-        }
-      }
+    run(builder) {
+        const batches = this._createInsertBatches(builder);
+        const concurrency = this._getConcurrency(builder, this.nodes);
+        return promiseUtils.map(batches, (batch) => this._insertBatch(builder, batch), { concurrency });
     }
-  }
-
-  _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);
+    _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;
     }
-  }
-
-  _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;
+    async _insertBatch(parentBuilder, nodes) {
+        await this._beforeInsert(nodes);
+        await this._insert(parentBuilder, nodes);
+        await this._afterInsert(nodes);
     }
-
-    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;
+    _beforeInsert(nodes) {
+        this._resolveDependencies(nodes);
+        this._omitManyToManyExtraProps(nodes);
+        this._copyRelationPropsFromCurrentIfNeeded(nodes);
+        return Promise.resolve();
     }
-
-    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));
+    _resolveDependencies(nodes) {
+        for (const node of nodes) {
+            const edges = this.dependencies.get(node);
+            if (edges) {
+                for (const edge of edges) {
+                    // `node` needs `dependencyNode` to have been inserted (and it has been).
+                    const dependencyNode = edge.getOtherNode(node);
+                    this._resolveDependency(dependencyNode, edge);
+                }
+            }
+        }
     }
-  }
-
-  _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]);
-      }
+    _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);
+        }
     }
-  }
-
-  _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));
+    _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));
         });
-      }
     }
-  }
-
-  _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];
-      node.obj.$validate(null, { dataPath: node.dataPathKey });
+    _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]);
+            }
+        }
     }
-
-    if (nodes.length === 0) {
-      return;
+    _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));
+                });
+            }
+        }
     }
-
-    for (const node of nodes) {
-      node.userData.inserted = true;
+    _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];
+            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();
+        });
     }
-
-    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());
-        } else {
-          return null;
-        }
-      }),
-    );
-  }
-
-  _afterInsert(nodes) {
-    for (const node of nodes) {
-      for (const refNode of node.referencingNodes) {
-        this._resolveDependency(refNode, refNode.parentEdge);
-      }
+    _runRelationBeforeInsertMethods(parentBuilder, nodes) {
+        return Promise.all(nodes.map((node) => {
+            if (node.parentEdge) {
+                return node.parentEdge.relation.beforeInsert(node.obj, parentBuilder.context());
+            }
+            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;
+    return node.modelClass;
 }
-
 module.exports = {
-  GraphInsertAction,
+    GraphInsertAction,
 };