@abedmurrar/objection 4.0.0-beta.4 → 4.0.0-beta.6

package/lib/queryBuilder/graph/GraphUpsert.js

@@ -1,20 +1,22 @@
-'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');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphUpsert = void 0;
+const ModelGraph_1 = require("../../model/graph/ModelGraph");
+const ModelGraphEdge_1 = require("../../model/graph/ModelGraphEdge");
+const ModelGraphBuilder_1 = require("../../model/graph/ModelGraphBuilder");
+const GraphFetcher_1 = require("../graph/GraphFetcher");
+const GraphInsert_1 = require("./insert/GraphInsert");
+const GraphPatch_1 = require("./patch/GraphPatch");
+const GraphDelete_1 = require("./delete/GraphDelete");
+const GraphRecursiveUpsert_1 = require("./recursiveUpsert/GraphRecursiveUpsert");
+const GraphOptions_1 = require("./GraphOptions");
+const ValidationError_1 = require("../../model/ValidationError");
+const RelationExpression_1 = require("../RelationExpression");
+const GraphNodeDbExistence_1 = require("./GraphNodeDbExistence");
+const GraphData_1 = require("./GraphData");
+const objectUtils_1 = require("../../utils/objectUtils");
 class GraphUpsert {
-    constructor({ rootModelClass, objects, upsertOptions }) {
+    constructor({ rootModelClass, objects, upsertOptions, }) {
         checkCanBeConvertedToModels(rootModelClass, objects);
         this.objects = rootModelClass.ensureModelArray(objects, GraphUpsert.modelOptions);
         this.isArray = Array.isArray(objects);
@@ -25,8 +27,8 @@ class GraphUpsert {
     }
     run(builder) {
         const modelClass = builder.modelClass();
-        const graphOptions = new GraphOptions(this.upsertOpt);
-        const graph = ModelGraph.create(modelClass, this.objects);
+        const graphOptions = new GraphOptions_1.GraphOptions(this.upsertOpt);
+        const graph = ModelGraph_1.ModelGraph.create(modelClass, this.objects);
         assignDbRefsAsRelateProps(graph);
         return createGraphData(builder, graphOptions, graph)
             .then(checkForErrors(builder))
@@ -35,10 +37,11 @@ class GraphUpsert {
             .then(returnResult(this.objects, this.isArray));
     }
 }
+exports.GraphUpsert = GraphUpsert;
 function checkCanBeConvertedToModels(modelClass, objects) {
-    asArray(objects).forEach((obj) => {
-        if (!isObject(obj)) {
-            throw createNotModelError(modelClass, obj);
+    (0, objectUtils_1.asArray)(objects).forEach((obj) => {
+        if (!(0, objectUtils_1.isObject)(obj)) {
+            throw (0, ModelGraphBuilder_1.createNotModelError)(modelClass, obj);
         }
     });
 }
@@ -47,25 +50,25 @@ function assignDbRefsAsRelateProps(graph) {
         if (!node.parentEdge || !node.parentEdge.relation || !node.isDbReference) {
             continue;
         }
-        node.parentEdge.relation.setRelateProp(node.obj, asArray(node.dbReference));
+        node.parentEdge.relation.setRelateProp(node.obj, (0, objectUtils_1.asArray)(node.dbReference));
     }
 }
 async function createGraphData(builder, graphOptions, graph) {
     const currentGraph = await fetchCurrentGraph(builder, graphOptions, graph);
-    const nodeDbExistence = await GraphNodeDbExistence.create({
+    const nodeDbExistence = await GraphNodeDbExistence_1.GraphNodeDbExistence.create({
         builder,
         graph,
         graphOptions,
         currentGraph,
     });
-    return new GraphData({ graph, currentGraph, graphOptions, nodeDbExistence });
+    return new GraphData_1.GraphData({ graph, currentGraph, graphOptions, nodeDbExistence });
 }
 function fetchCurrentGraph(builder, graphOptions, graph) {
     if (graphOptions.isInsertOnly()) {
-        return Promise.resolve(ModelGraph.createEmpty());
+        return Promise.resolve(ModelGraph_1.ModelGraph.createEmpty());
     }
     else {
-        return GraphFetcher.fetchCurrentGraph({ builder, graph, graphOptions });
+        return GraphFetcher_1.GraphFetcher.fetchCurrentGraph({ builder, graph, graphOptions });
     }
 }
 // Remove branches from the graph that require no operations. For example
@@ -110,7 +113,7 @@ function pruneDeletedBranches(graphData) {
 }
 function findRoots(nodes) {
     const nodeSet = new Set(nodes);
-    return uniqBy(nodes.filter((node) => {
+    return (0, objectUtils_1.uniqBy)(nodes.filter((node) => {
         let parentNode = node.parentNode;
         while (parentNode) {
             if (nodeSet.has(parentNode)) {
@@ -178,10 +181,10 @@ function checkForUnallowedRelationErrors(graphData, builder) {
     const allowedExpression = builder.allowedGraphExpression();
     if (allowedExpression) {
         const rootsObjs = graph.nodes.filter((node) => !node.parentEdge).map((node) => node.obj);
-        const expression = RelationExpression.fromModelGraph(rootsObjs);
+        const expression = RelationExpression_1.RelationExpression.fromModelGraph(rootsObjs);
         if (!allowedExpression.isSubExpression(expression)) {
             throw builder.modelClass().createValidationError({
-                type: ValidationErrorType.UnallowedRelation,
+                type: ValidationError_1.ValidationErrorType.UnallowedRelation,
                 message: 'trying to upsert an unallowed relation',
             });
         }
@@ -192,9 +195,9 @@ function checkForUnallowedReferenceErrors(graphData, builder) {
     if (graphOptions.allowRefs()) {
         return;
     }
-    if (graph.edges.some((edge) => edge.type === ModelGraphEdge.Type.Reference)) {
+    if (graph.edges.some((edge) => edge.type === ModelGraphEdge_1.ModelGraphEdge.Type.Reference)) {
         throw builder.modelClass().createValidationError({
-            type: ValidationErrorType.InvalidGraph,
+            type: ValidationError_1.ValidationErrorType.InvalidGraph,
             message: '#ref references are not allowed in a graph by default. see the allowRefs insert/upsert graph option',
         });
     }
@@ -211,8 +214,8 @@ function checkForHasManyRelateErrors(graphData) {
 function executeOperations(builder) {
     return (graphData) => {
         const operations = graphData.graphOptions.isInsertOnly()
-            ? [GraphInsert]
-            : [GraphDelete, GraphInsert, GraphPatch, GraphRecursiveUpsert];
+            ? [GraphInsert_1.GraphInsert]
+            : [GraphDelete_1.GraphDelete, GraphInsert_1.GraphInsert, GraphPatch_1.GraphPatch, GraphRecursiveUpsert_1.GraphRecursiveUpsert];
         return operations.reduce((promise, Operation) => {
             const operation = new Operation(graphData);
             const actions = operation.createActions();
@@ -226,6 +229,3 @@ function executeActions(builder, actions) {
 function returnResult(objects, isArray) {
     return () => (isArray ? objects : objects[0]);
 }
-module.exports = {
-    GraphUpsert,
-};

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

@@ -1,15 +1,15 @@
-'use strict';
-const { GraphOperation } = require('../GraphOperation');
-const { GraphDeleteAction } = require('./GraphDeleteAction');
-class GraphDelete extends GraphOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphDelete = void 0;
+const GraphOperation_1 = require("../GraphOperation");
+const GraphDeleteAction_1 = require("./GraphDeleteAction");
+class GraphDelete extends GraphOperation_1.GraphOperation {
     createActions() {
         return [
-            new GraphDeleteAction(this.graphData, {
+            new GraphDeleteAction_1.GraphDeleteAction(this.graphData, {
                 nodes: this.currentGraph.nodes.filter((currentNode) => this.graphOptions.shouldDeleteOrUnrelate(currentNode, this.graphData)),
             }),
         ];
     }
 }
-module.exports = {
-    GraphDelete,
-};
+exports.GraphDelete = GraphDelete;

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

@@ -1,8 +1,43 @@
-'use strict';
-const { GraphAction } = require('../GraphAction');
-const { groupBy } = require('../../../utils/objectUtils');
-const promiseUtils = require('../../../utils/promiseUtils');
-class GraphDeleteAction extends GraphAction {
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphDeleteAction = void 0;
+const GraphAction_1 = require("../GraphAction");
+const objectUtils_1 = require("../../../utils/objectUtils");
+const promiseUtils = __importStar(require("../../../utils/promiseUtils"));
+class GraphDeleteAction extends GraphAction_1.GraphAction {
     constructor(graphData, { nodes }) {
         super(graphData);
         // Nodes to delete.
@@ -25,13 +60,15 @@ class GraphDeleteAction extends GraphAction {
         });
     }
     _createDeleteBuilders(parentBuilder, nodesTodelete) {
-        const nodesByRelation = groupBy(nodesTodelete, getRelation);
+        const nodesByRelation = (0, objectUtils_1.groupBy)(nodesTodelete, getRelation);
         const builders = [];
         nodesByRelation.forEach((nodes, relation) => {
-            const nodesByParent = groupBy(nodes, getParent);
+            const nodesByParent = (0, objectUtils_1.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);
+                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()));
@@ -45,12 +82,10 @@ class GraphDeleteAction extends GraphAction {
         return builders;
     }
 }
+exports.GraphDeleteAction = GraphDeleteAction;
 function getRelation(node) {
     return node.parentEdge.relation;
 }
 function getParent(node) {
     return node.parentNode;
 }
-module.exports = {
-    GraphDeleteAction,
-};

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

@@ -1,9 +1,11 @@
-'use strict';
-const { JoinRowGraphInsertAction } = require('./JoinRowGraphInsertAction');
-const { GraphInsertAction } = require('./GraphInsertAction');
-const { GraphOperation } = require('../GraphOperation');
-const { ModelGraphEdge } = require('../../../model/graph/ModelGraphEdge');
-class GraphInsert extends GraphOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphInsert = void 0;
+const JoinRowGraphInsertAction_1 = require("./JoinRowGraphInsertAction");
+const GraphInsertAction_1 = require("./GraphInsertAction");
+const GraphOperation_1 = require("../GraphOperation");
+const ModelGraphEdge_1 = require("../../../model/graph/ModelGraphEdge");
+class GraphInsert extends GraphOperation_1.GraphOperation {
     constructor(...args) {
         super(...args);
         this.dependencies = this._createDependencyMap();
@@ -14,7 +16,7 @@ class GraphInsert extends GraphOperation {
     _createDependencyMap() {
         const dependencies = new Map();
         for (const edge of this.graph.edges) {
-            if (edge.type == ModelGraphEdge.Type.Relation) {
+            if (edge.type == ModelGraphEdge_1.ModelGraphEdge.Type.Relation) {
                 this._createRelationDependency(edge, dependencies);
             }
             else {
@@ -60,7 +62,7 @@ class GraphInsert extends GraphOperation {
             if (nodesToInsert.length === 0) {
                 break;
             }
-            actions.push(new GraphInsertAction(this.graphData, {
+            actions.push(new GraphInsertAction_1.GraphInsertAction(this.graphData, {
                 nodes: nodesToInsert,
                 dependencies: this.dependencies,
             }));
@@ -101,7 +103,7 @@ class GraphInsert extends GraphOperation {
     }
     _createJoinRowActions() {
         return [
-            new JoinRowGraphInsertAction(this.graphData, {
+            new JoinRowGraphInsertAction_1.JoinRowGraphInsertAction(this.graphData, {
                 nodes: this.graph.nodes.filter((node) => {
                     return (this.currentGraph.nodeForNode(node) === null &&
                         node.parentEdge &&
@@ -111,6 +113,4 @@ class GraphInsert extends GraphOperation {
         ];
     }
 }
-module.exports = {
-    GraphInsert,
-};
+exports.GraphInsert = GraphInsert;

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

@@ -1,8 +1,43 @@
-'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');
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphInsertAction = void 0;
+const GraphAction_1 = require("../GraphAction");
+const objectUtils_1 = require("../../../utils/objectUtils");
+const ModelGraphEdge_1 = require("../../../model/graph/ModelGraphEdge");
+const promiseUtils = __importStar(require("../../../utils/promiseUtils"));
 /**
  * Inserts a batch of nodes for a GraphInsert.
  *
@@ -11,7 +46,7 @@ const promiseUtils = require('../../../utils/promiseUtils');
  * batch inserts, so this class splits the inserts into further sub batches
  * when needed.
  */
-class GraphInsertAction extends GraphAction {
+class GraphInsertAction extends GraphAction_1.GraphAction {
     constructor(graphData, { nodes, dependencies }) {
         super(graphData);
         // Nodes to insert.
@@ -21,14 +56,16 @@ class GraphInsertAction extends GraphAction {
     run(builder) {
         const batches = this._createInsertBatches(builder);
         const concurrency = this._getConcurrency(builder, this.nodes);
-        return promiseUtils.map(batches, (batch) => this._insertBatch(builder, batch), { concurrency });
+        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);
+        const nodesByModelClass = (0, objectUtils_1.groupBy)(this.nodes, getModelClass);
         for (const nodes of nodesByModelClass.values()) {
-            for (const nodeBatch of chunk(nodes, batchSize)) {
+            for (const nodeBatch of (0, objectUtils_1.chunk)(nodes, batchSize)) {
                 batches.push(nodeBatch);
             }
         }
@@ -58,10 +95,10 @@ class GraphInsertAction extends GraphAction {
         }
     }
     _resolveDependency(dependencyNode, edge) {
-        if (edge.type === ModelGraphEdge.Type.Relation && !edge.relation.joinTable) {
+        if (edge.type === ModelGraphEdge_1.ModelGraphEdge.Type.Relation && !edge.relation.joinTable) {
             this._resolveRelationDependency(dependencyNode, edge);
         }
-        else if (edge.refType === ModelGraphEdge.ReferenceType.Property) {
+        else if (edge.refType === ModelGraphEdge_1.ModelGraphEdge.ReferenceType.Property) {
             this._resolvePropertyReferenceNode(dependencyNode, edge);
         }
     }
@@ -84,6 +121,7 @@ class GraphInsertAction extends GraphAction {
     }
     _resolvePropertyReferenceNode(dependencyNode, edge) {
         const dependentNode = edge.getOtherNode(dependencyNode);
+        // A property reference edge has the paths.
         let sourcePath;
         let targetPath;
         if (edge.isOwnerNode(dependencyNode)) {
@@ -94,20 +132,22 @@ class GraphInsertAction extends GraphAction {
             targetPath = edge.refOwnerDataPath;
             sourcePath = edge.refRelatedDataPath;
         }
-        const sourceValue = get(dependencyNode.obj, sourcePath);
-        const targetValue = get(dependentNode.obj, targetPath);
+        const sourceValue = (0, objectUtils_1.get)(dependencyNode.obj, sourcePath);
+        const targetValue = (0, objectUtils_1.get)(dependentNode.obj, targetPath);
         if (targetValue === edge.refMatch) {
-            set(dependentNode.obj, targetPath, sourceValue);
+            (0, objectUtils_1.set)(dependentNode.obj, targetPath, sourceValue);
         }
         else {
-            set(dependentNode.obj, targetPath, targetValue.replace(edge.refMatch, sourceValue));
+            // The reference is a part of a string: `replace()` converts the value to a string.
+            (0, objectUtils_1.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.type === ModelGraphEdge_1.ModelGraphEdge.Type.Relation &&
                 node.parentEdge.relation.joinTableExtras.length > 0) {
+                // Only many to many relations have join table extras.
                 node.parentEdge.relation.omitExtraProps([node.obj]);
             }
         }
@@ -119,7 +159,7 @@ class GraphInsertAction extends GraphAction {
                 continue;
             }
             for (const edge of node.edges) {
-                if (edge.type !== ModelGraphEdge.Type.Relation) {
+                if (edge.type !== ModelGraphEdge_1.ModelGraphEdge.Type.Relation) {
                     continue;
                 }
                 const prop = edge.isOwnerNode(node) ? edge.relation.ownerProp : edge.relation.relatedProp;
@@ -153,7 +193,7 @@ class GraphInsertAction extends GraphAction {
                 .query()
                 .insert(nodes.map((node) => node.obj))
                 .childQueryOf(parentBuilder)
-                .copyFrom(parentBuilder, GraphAction.ReturningAllSelector)
+                .copyFrom(parentBuilder, GraphAction_1.GraphAction.ReturningAllSelector)
                 .execute();
         });
     }
@@ -175,9 +215,7 @@ class GraphInsertAction extends GraphAction {
         }
     }
 }
+exports.GraphInsertAction = GraphInsertAction;
 function getModelClass(node) {
     return node.modelClass;
 }
-module.exports = {
-    GraphInsertAction,
-};

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

@@ -1,8 +1,43 @@
-'use strict';
-const { GraphAction } = require('../GraphAction');
-const { groupBy, chunk } = require('../../../utils/objectUtils');
-const promiseUtils = require('../../../utils/promiseUtils');
-class JoinRowGraphInsertAction extends GraphAction {
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinRowGraphInsertAction = void 0;
+const GraphAction_1 = require("../GraphAction");
+const objectUtils_1 = require("../../../utils/objectUtils");
+const promiseUtils = __importStar(require("../../../utils/promiseUtils"));
+class JoinRowGraphInsertAction extends GraphAction_1.GraphAction {
     constructor(graphData, { nodes }) {
         super(graphData);
         this.nodes = nodes;
@@ -10,14 +45,16 @@ class JoinRowGraphInsertAction extends GraphAction {
     run(builder) {
         const batches = this._createInsertBatches(builder);
         const concurrency = this._getConcurrency(builder, this.nodes);
-        return promiseUtils.map(batches, (batch) => this._insertBatch(builder, batch), { concurrency });
+        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));
+        const nodesByModel = (0, objectUtils_1.groupBy)(this.nodes, (node) => getJoinTableModel(builder, node));
         for (const [joinTableModelClass, nodes] of nodesByModel.entries()) {
-            for (const nodeBatch of chunk(nodes, batchSize)) {
+            for (const nodeBatch of (0, objectUtils_1.chunk)(nodes, batchSize)) {
                 batches.push(this._createBatch(joinTableModelClass, nodeBatch));
             }
         }
@@ -36,6 +73,7 @@ class JoinRowGraphInsertAction extends GraphAction {
     }
     _createJoinTableObj(joinTableModelClass, node) {
         const { parentEdge, parentNode } = node;
+        // The nodes of this action are in many to many relations.
         const { relation } = parentEdge;
         this._resolveReferences(node);
         return joinTableModelClass.fromJson(relation.createJoinModel(relation.ownerProp.getProps(parentNode.obj), node.obj));
@@ -62,9 +100,9 @@ class JoinRowGraphInsertAction extends GraphAction {
         }
     }
 }
+exports.JoinRowGraphInsertAction = JoinRowGraphInsertAction;
 function getJoinTableModel(builder, node) {
+    // A many to many relation always has a join model class. `getJoinModelClass()`
+    // also gets the missing knex as null if the builder has none.
     return node.parentEdge.relation.getJoinModelClass(builder.unsafeKnex());
 }
-module.exports = {
-    JoinRowGraphInsertAction,
-};

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

@@ -1,15 +1,15 @@
-'use strict';
-const { GraphOperation } = require('../GraphOperation');
-const { GraphPatchAction } = require('./GraphPatchAction');
-class GraphPatch extends GraphOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphPatch = void 0;
+const GraphOperation_1 = require("../GraphOperation");
+const GraphPatchAction_1 = require("./GraphPatchAction");
+class GraphPatch extends GraphOperation_1.GraphOperation {
     createActions() {
         return [
-            new GraphPatchAction(this.graphData, {
+            new GraphPatchAction_1.GraphPatchAction(this.graphData, {
                 nodes: this.graph.nodes.filter((node) => this.graphOptions.shouldPatchOrUpdateIgnoreDisable(node, this.graphData)),
             }),
         ];
     }
 }
-module.exports = {
-    GraphPatch,
-};
+exports.GraphPatch = GraphPatch;