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

package/lib/queryBuilder/graph/GraphUpsert.js

@@ -0,0 +1,231 @@
+'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,15 @@
+'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,56 @@
+'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,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);
+            }
+        }
+        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,
+};

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

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