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

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

@@ -0,0 +1,225 @@
+'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 }) {
+    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);
+      }
+    }
+
+    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);
+        }
+      }
+    }
+  }
+
+  _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];
+      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());
+        } 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

@@ -0,0 +1,92 @@
+'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

@@ -0,0 +1,20 @@
+'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,
+};

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

@@ -0,0 +1,258 @@
+'use strict';
+
+const { getModel } = require('../../../model/getModel');
+const { GraphAction } = require('../GraphAction');
+const { isInternalProp } = require('../../../utils/internalPropUtils');
+const { difference, isObject, jsonEquals } = require('../../../utils/objectUtils');
+const promiseUtils = require('../../../utils/promiseUtils');
+
+class GraphPatchAction extends GraphAction {
+  constructor(graphData, { nodes }) {
+    super(graphData);
+    // Nodes to patch.
+    this.nodes = nodes;
+  }
+
+  run(builder) {
+    return promiseUtils.map(this.nodes, (node) => this._runForNode(builder, node), {
+      concurrency: this._getConcurrency(builder, this.nodes),
+    });
+  }
+
+  _runForNode(builder, node) {
+    const shouldPatch = this.graphOptions.shouldPatch(node, this.graphData);
+    const shouldUpdate = this.graphOptions.shouldUpdate(node, this.graphData);
+
+    // BelongsToOneRelation inserts and relates change the parent object's
+    // properties. That's why we handle them here.
+    const changedPropsBecauseOfBelongsToOneInsert = this._handleBelongsToOneInserts(node);
+
+    // BelongsToOneRelation deletes and unrelates change the parent object's
+    // properties. That's why we handle them here.
+    const changePropsBecauseOfBelongsToOneDelete = this._handleBelongsToOneDeletes(node);
+
+    const handleUpdate = () => {
+      const { changedProps, unchangedProps } = this._findChanges(node);
+      const allProps = [...changedProps, ...unchangedProps];
+
+      const propsToUpdate = difference(
+        shouldPatch || shouldUpdate
+          ? changedProps
+          : [...changedPropsBecauseOfBelongsToOneInsert, ...changePropsBecauseOfBelongsToOneDelete],
+
+        // Remove id properties from the props to update. With upsertGraph
+        // it never makes sense to change the id.
+        node.modelClass.getIdPropertyArray(),
+      );
+
+      const update = propsToUpdate.length > 0;
+      if (update) {
+        // Don't update the fields that we know not to change.
+        node.obj.$omitFromDatabaseJson(difference(allProps, propsToUpdate));
+        node.userData.updated = true;
+      }
+
+      return update;
+    };
+
+    const Model = getModel();
+    // See if the model defines a beforeUpdate or $beforeUpdate hook. If it does
+    // not, we can check for updated properties now and drop out immediately if
+    // there is nothing to update. Otherwise, we need to wait for the hook to be
+    // called before calling handleUpdate, but only if the node contains changes
+    // that aren't id properties (relates). See issues #2233, #2605.
+    const hasBeforeUpdate =
+      node.obj.constructor.beforeUpdate !== Model.beforeUpdate ||
+      node.obj.$beforeUpdate !== Model.prototype.$beforeUpdate;
+
+    if (
+      (hasBeforeUpdate && !this._hasNonIdPropertyChanges(node)) ||
+      (!hasBeforeUpdate && !handleUpdate())
+    ) {
+      return null;
+    }
+
+    delete node.obj[node.modelClass.uidProp];
+    delete node.obj[node.modelClass.uidRefProp];
+    delete node.obj[node.modelClass.dbRefProp];
+
+    node.obj.$validate(null, {
+      dataPath: node.dataPathKey,
+      patch: shouldPatch || (!shouldPatch && !shouldUpdate),
+    });
+
+    const updateBuilder = this._createBuilder(node)
+      .childQueryOf(builder, childQueryOptions())
+      .copyFrom(builder, GraphAction.ReturningAllSelector);
+
+    if (hasBeforeUpdate) {
+      updateBuilder.internalContext().runBefore.push((result, builder) => {
+        // Call handleUpdate in the runBefore hook which runs after the
+        // $beforeUpdate hook, allowing it to modify the object before the
+        // updated properties are determined. See issue #2233.
+        if (hasBeforeUpdate && !handleUpdate()) {
+          builder.internalOptions().returnImmediatelyValue = null;
+        }
+        return result;
+      });
+    }
+
+    if (shouldPatch) {
+      updateBuilder.patch(node.obj);
+    } else {
+      updateBuilder.update(node.obj);
+    }
+
+    return updateBuilder.execute().then((result) => {
+      if (isObject(result) && result.$isObjectionModel) {
+        // Handle returning('*').
+        node.obj.$set(result);
+      }
+
+      return result;
+    });
+  }
+
+  _handleBelongsToOneInserts(node) {
+    const currentNode = this.currentGraph.nodeForNode(node);
+    const updatedProps = [];
+
+    for (const edge of node.edges) {
+      if (
+        edge.isOwnerNode(node) &&
+        edge.relation &&
+        edge.relation.isObjectionBelongsToOneRelation &&
+        edge.relation.relatedProp.hasProps(edge.relatedNode.obj)
+      ) {
+        const { relation } = edge;
+
+        relation.ownerProp.forEach((i) => {
+          const currentValue = currentNode && relation.ownerProp.getProp(currentNode.obj, i);
+          const relatedValue = relation.relatedProp.getProp(edge.relatedNode.obj, i);
+
+          if (currentValue != relatedValue) {
+            relation.ownerProp.setProp(node.obj, i, relatedValue);
+            updatedProps.push(relation.ownerProp.props[i]);
+          }
+        });
+      }
+    }
+
+    return updatedProps;
+  }
+
+  _handleBelongsToOneDeletes(node) {
+    const currentNode = this.currentGraph.nodeForNode(node);
+    const updatedProps = [];
+
+    if (!currentNode) {
+      return updatedProps;
+    }
+
+    for (const edge of currentNode.edges) {
+      if (
+        edge.isOwnerNode(currentNode) &&
+        edge.relation.isObjectionBelongsToOneRelation &&
+        node.obj[edge.relation.name] === null &&
+        this.graphOptions.shouldDeleteOrUnrelate(edge.relatedNode, this.graphData)
+      ) {
+        const { relation } = edge;
+
+        relation.ownerProp.forEach((i) => {
+          const currentValue = relation.ownerProp.getProp(currentNode.obj, i);
+
+          if (currentValue != null) {
+            relation.ownerProp.setProp(node.obj, i, null);
+            updatedProps.push(relation.ownerProp.props[i]);
+          }
+        });
+      }
+    }
+
+    return updatedProps;
+  }
+
+  _findChanges(node) {
+    const obj = node.obj;
+    const currentNode = this.currentGraph.nodeForNode(node);
+    const currentObj = (currentNode && currentNode.obj) || {};
+    const relationNames = node.modelClass.getRelationNames();
+
+    const unchangedProps = [];
+    const changedProps = [];
+
+    for (const prop of Object.keys(obj)) {
+      if (isInternalProp(prop) || relationNames.includes(prop)) {
+        continue;
+      }
+
+      const value = obj[prop];
+      const currentValue = currentObj[prop];
+
+      // If the current object doesn't have the property, we have to assume
+      // it changes (we cannot know if it will). If the object does have the
+      // property, we test non-strict equality. See issue #732.
+      if (currentValue === undefined || !nonStrictEquals(currentValue, value)) {
+        changedProps.push(prop);
+      } else {
+        unchangedProps.push(prop);
+      }
+    }
+
+    // We cannot know if the query properties cause changes to the values.
+    // We must assume that they do.
+    if (obj.$$queryProps) {
+      changedProps.push(...Object.keys(obj.$$queryProps));
+    }
+
+    return {
+      changedProps,
+      unchangedProps,
+    };
+  }
+
+  _hasNonIdPropertyChanges(node) {
+    const idProps = node.modelClass.getIdPropertyArray();
+    return this._findChanges(node).changedProps.some((prop) => !idProps.includes(prop));
+  }
+
+  _createBuilder(node) {
+    if (node.parentEdge && !node.parentEdge.relation.isObjectionHasManyRelation) {
+      return this._createRelatedBuilder(node);
+    } else {
+      return this._createRootBuilder(node);
+    }
+  }
+
+  _createRelatedBuilder(node) {
+    return node.parentNode.obj
+      .$relatedQuery(node.parentEdge.relation.name)
+      .findById(node.obj.$id());
+  }
+
+  _createRootBuilder(node) {
+    const currentNode = this.currentGraph.nodeForNode(node);
+    const currentObj = currentNode && currentNode.obj;
+
+    return currentObj ? currentObj.$query() : node.obj.$query();
+  }
+}
+
+function childQueryOptions() {
+  return {
+    fork: true,
+    isInternalQuery: true,
+  };
+}
+
+function nonStrictEquals(val1, val2) {
+  if (val1 == val2) {
+    return true;
+  }
+
+  return jsonEquals(val1, val2);
+}
+
+module.exports = {
+  GraphPatchAction,
+};

package/lib/queryBuilder/graph/recursiveUpsert/GraphRecursiveUpsert.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const { GraphOperation } = require('../GraphOperation');
+const { GraphRecursiveUpsertAction } = require('./GraphRecursiveUpsertAction');
+
+class GraphRecursiveUpsert extends GraphOperation {
+  createActions() {
+    return [
+      new GraphRecursiveUpsertAction(this.graphData, {
+        nodes: this.graph.nodes.filter((node) => {
+          const shouldRelate = this.graphOptions.shouldRelate(node, this.graphData);
+          return shouldRelate && hasRelations(node.obj);
+        }),
+      }),
+    ];
+  }
+}
+
+function hasRelations(obj) {
+  for (const relationName of obj.constructor.getRelationNames()) {
+    if (obj[relationName] !== undefined) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+module.exports = {
+  GraphRecursiveUpsert,
+};