@abedmurrar/objection 4.0.0-beta.1 → 4.0.0-beta.11

package/lib/queryBuilder/ValueBuilder.js

@@ -1,15 +1,18 @@
-'use strict';
-const { asArray, isObject } = require('../utils/objectUtils');
-const { buildArg } = require('../utils/buildUtils');
-const { isMySql } = require('../utils/knexUtils');
-const { toMySqlCastType, isBooleanType, toJsonSql } = require('../utils/mysqlJsonPath');
-const { addExpressionMethods } = require('./expressions');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueBuilder = void 0;
+exports.val = val;
+const objectUtils_1 = require("../utils/objectUtils");
+const buildUtils_1 = require("../utils/buildUtils");
+const knexUtils_1 = require("../utils/knexUtils");
+const mysqlJsonPath_1 = require("../utils/mysqlJsonPath");
+const expressions_1 = require("./expressions");
 class ValueBuilder {
     constructor(value) {
         this._value = value;
         this._cast = null;
         // Cast objects and arrays to json by default.
-        this._toJson = isObject(value);
+        this._toJson = (0, objectUtils_1.isObject)(value);
         this._toArray = false;
         this._alias = null;
     }
@@ -67,29 +70,30 @@ class ValueBuilder {
             sql = '?';
         }
         else if (this._toArray) {
-            const values = asArray(this._value);
-            bindings.push(...values.map((it) => buildArg(it, builder)));
+            const values = (0, objectUtils_1.asArray)(this._value);
+            bindings.push(...values.map((it) => (0, buildUtils_1.buildArg)(it, builder)));
             sql = `ARRAY[${values.map(() => '?').join(', ')}]`;
         }
         else {
+            // A value of the user, which knex binds as it is.
             bindings.push(this._value);
             sql = '?';
         }
         const knex = builder.unsafeKnex();
-        const mysql = isMySql(knex);
+        const mysql = (0, knexUtils_1.isMySql)(knex);
         if (this._toJson && !this._cast && mysql) {
             // MySQL compares strings and JSON values as strings, so `{}` is never
             // equal to a JSON column without the cast. Postgres casts it implicitly.
-            sql = toJsonSql(sql, knex);
+            sql = (0, mysqlJsonPath_1.toJsonSql)(sql, knex);
         }
         else if (this._cast && mysql) {
-            const type = toMySqlCastType(this._cast);
+            const type = (0, mysqlJsonPath_1.toMySqlCastType)(this._cast);
             // MySQL can't cast to a boolean.
-            if (isBooleanType(this._cast)) {
+            if ((0, mysqlJsonPath_1.isBooleanType)(this._cast)) {
                 sql = `(${sql} <> 0)`;
             }
             else if (type === 'JSON') {
-                sql = toJsonSql(sql, knex);
+                sql = (0, mysqlJsonPath_1.toJsonSql)(sql, knex);
             }
             else {
                 sql = `CAST(${sql} AS ${type})`;
@@ -105,11 +109,8 @@ class ValueBuilder {
         return [sql, bindings];
     }
 }
-addExpressionMethods(ValueBuilder.prototype);
+exports.ValueBuilder = ValueBuilder;
+(0, expressions_1.addExpressionMethods)(ValueBuilder.prototype);
 function val(val) {
     return new ValueBuilder(val);
 }
-module.exports = {
-    ValueBuilder,
-    val,
-};

package/lib/queryBuilder/expressions.js

@@ -1,16 +1,8 @@
-'use strict';
-const { isObject } = require('../utils/objectUtils');
-// Comparison, logic and arithmetic methods for `ref()`, `val()`, `fn()` and
-// `raw()`, so that expressions can be written without raw sql:
-//
-//   Person.ref('age').gte(18).as('isAdult')
-//   Pet.ref('order').plus(1)
-//   Person.ref('firstName').isNotBlank().or(Person.ref('lastName').isNotBlank())
-//
-// Every method returns a new `FunctionBuilder`. The sql is wrapped in parentheses,
-// so expressions can be nested without thinking about operator precedence. The
-// arguments are bindings like the arguments of `fn()`: strings are values and
-// columns are passed with `ref()` or `Model.ref()`.
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addExpressionMethods = addExpressionMethods;
+exports.expression = expression;
+const objectUtils_1 = require("../utils/objectUtils");
 const COMPARISONS = {
     eq: '=',
     ne: '<>',
@@ -98,7 +90,9 @@ function createLogic(first, rest, operator) {
     return expression(`(${conditions.map(() => '?').join(` ${operator} `)})`, conditions);
 }
 function isSubquery(value) {
-    return (isObject(value) && (value.isObjectionQueryBuilderBase || typeof value.toSQL === 'function'));
+    return ((0, objectUtils_1.isObject)(value) &&
+        (value.isObjectionQueryBuilderBase ||
+            typeof value.toSQL === 'function'));
 }
 function expression(sql, args) {
     // Required here because `FunctionBuilder` itself gets these methods.
@@ -115,7 +109,3 @@ function addExpressionMethods(prototype) {
         });
     }
 }
-module.exports = {
-    addExpressionMethods,
-    expression,
-};

package/lib/queryBuilder/functions/mysql.js

@@ -1,35 +1,8 @@
-'use strict';
-const { ref } = require('../ReferenceBuilder');
-// The MySQL 8.4 built-in functions, as `fn.*` helpers.
-//
-// Each entry is `[name, sql, params, result, options]`:
-//
-//   name     the name of the helper: `fn.dateFormat()`
-//   sql      the name of the SQL function: `DATE_FORMAT`
-//   params   the parameters, as TypeScript
-//   result   the type of the result, as TypeScript
-//   options  `json`: the arguments that are JSON documents. Objects and arrays
-//                    passed to them are cast to JSON. An array of indexes,
-//                    'all', or 'even' (0, 2, 4, ...) / 'odd' (1, 3, 5, ...).
-//            `portable`: the function works the same on postgres, so it
-//                    isn't limited to MySQL.
-//            `build`: a function that builds the sql for functions with
-//                    keywords in their syntax, like `TIMESTAMPDIFF(DAY, ?, ?)`.
-//            `aggregate`: the function is an aggregate that `filter()` works
-//                    with. `true` when every argument is aggregated, or a
-//                    function that returns how many of the first arguments are.
-//            `window`: the function is a window function, which needs `over()`.
-//
-// The arguments are bindings, so strings are values. Columns are passed with
-// `ref()` or `Model.ref()`.
-//
-// The typings in `typings/objection/index.d.ts` are generated from this list
-// with `node scripts/generate-fn-typings.js`.
-//
-// Not included: spatial functions, operators, `CASE`, `JSON_TABLE()`, internal functions and functions
-// that are deprecated (`JSON_MERGE()`, `FOUND_ROWS()`, `VALUES()`,
-// `MASTER_POS_WAIT()`) or that need a component (`VALIDATE_PASSWORD_STRENGTH()`).
-// `fn('NAME', ...args)` calls any function.
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIMESTAMP_UNITS = exports.INTERVAL_UNITS = exports.MARIADB_UNSUPPORTED = exports.FUNCTIONS = void 0;
+exports.buildOrderBy = buildOrderBy;
+const ReferenceBuilder_1 = require("../ReferenceBuilder");
 const STR = 'string | null';
 const NUM = 'number | null';
 const DEC = 'FnNumeric | null';
@@ -66,7 +39,9 @@ const INTERVAL_UNITS = [
     'DAY_HOUR',
     'YEAR_MONTH',
 ];
+exports.INTERVAL_UNITS = INTERVAL_UNITS;
 const TIMESTAMP_UNITS = INTERVAL_UNITS.slice(0, 9);
+exports.TIMESTAMP_UNITS = TIMESTAMP_UNITS;
 const CAST_TYPE = /^((BINARY|CHAR|NCHAR)(\(\d+\))?( CHARACTER SET \w+)?|DATE|(DATETIME|TIME)(\(\d\))?|DECIMAL(\(\d+(, ?\d+)?\))?|DOUBLE|FLOAT(\(\d+\))?|JSON|REAL|(SIGNED|UNSIGNED)( INTEGER)?|YEAR)$/i;
 const CHARSET = /^\w+$/;
 const MATCH_MODES = {
@@ -540,6 +515,7 @@ const FUNCTIONS = [
         { json: [0, 1], build: buildMemberOf },
     ],
 ];
+exports.FUNCTIONS = FUNCTIONS;
 // Builders for the functions with keywords in their syntax. They return
 // `[sql, args]`. Keywords are checked against lists, since they can't be bindings.
 function buildDateAdd(name, sql, [date, amount, unit]) {
@@ -592,6 +568,7 @@ function buildTrim(name, sql, [str, options = {}]) {
     }
 }
 function buildChar(name, sql, [codes, options = {}]) {
+    // `codes`, `columns` and `exprs` below are arrays after the first line.
     codes = Array.isArray(codes) ? codes : [codes];
     const placeholders = codes.map(() => '?').join(', ');
     if (options.using === undefined) {
@@ -612,7 +589,10 @@ function buildMatch(name, sql, [columns, search, options = {}]) {
         }
         mode = ` ${mode}`;
     }
-    return [`MATCH(${columns.map(() => '?').join(', ')}) AGAINST(?${mode})`, [...columns, search]];
+    return [
+        `MATCH(${columns.map(() => '?').join(', ')}) AGAINST(?${mode})`,
+        [...columns, search],
+    ];
 }
 function buildCountDistinct(name, sql, exprs) {
     return [`COUNT(DISTINCT ${exprs.map(() => '?').join(', ')})`, exprs];
@@ -653,7 +633,7 @@ function buildOrderBy(name, orderBy) {
     return [sql, args];
 }
 function toColumn(column) {
-    return typeof column === 'string' ? ref(column) : column;
+    return typeof column === 'string' ? (0, ReferenceBuilder_1.ref)(column) : column;
 }
 function buildNtile(name, sql, [buckets]) {
     return [`NTILE(${integer(name, 'buckets', buckets, 1)})`, []];
@@ -751,12 +731,8 @@ const MARIADB_UNSUPPORTED = {
     regexpInstr: MAX_ARGS(2),
     regexpSubstr: MAX_ARGS(2),
     regexpReplace: MAX_ARGS(3),
-    jsonValue: (args) => args[2] && args[2].returning !== undefined ? "can't use the returning option on MariaDB" : null,
-};
-module.exports = {
-    FUNCTIONS,
-    MARIADB_UNSUPPORTED,
-    buildOrderBy,
-    INTERVAL_UNITS,
-    TIMESTAMP_UNITS,
+    jsonValue: (args) => args[2] && args[2].returning !== undefined
+        ? "can't use the returning option on MariaDB"
+        : null,
 };
+exports.MARIADB_UNSUPPORTED = MARIADB_UNSUPPORTED;

package/lib/queryBuilder/graph/GraphAction.js

@@ -1,5 +1,7 @@
-'use strict';
-const { isPostgres } = require('../../utils/knexUtils');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphAction = void 0;
+const knexUtils_1 = require("../../utils/knexUtils");
 const POSTGRES_MAX_INSERT_BATCH_SIZE = 100;
 const MAX_CONCURRENCY = 100;
 class GraphAction {
@@ -9,7 +11,7 @@ class GraphAction {
     static get ReturningAllSelector() {
         return (op) => {
             // Only select `returning('*')` operation.
-            return op.name === 'returning' && op.args.includes('*');
+            return (op.name === 'returning' && op.args.includes('*'));
         };
     }
     static getConcurrency(builder, nodes) {
@@ -33,7 +35,7 @@ class GraphAction {
         return GraphAction.getConcurrency(builder, nodes);
     }
     _getBatchSize(builder) {
-        return isPostgres(builder.unsafeKnex()) ? POSTGRES_MAX_INSERT_BATCH_SIZE : 1;
+        return (0, knexUtils_1.isPostgres)(builder.unsafeKnex()) ? POSTGRES_MAX_INSERT_BATCH_SIZE : 1;
     }
     _resolveReferences(node) {
         if (node.isReference) {
@@ -49,6 +51,4 @@ class GraphAction {
         }
     }
 }
-module.exports = {
-    GraphAction,
-};
+exports.GraphAction = GraphAction;

package/lib/queryBuilder/graph/GraphData.js

@@ -1,4 +1,6 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphData = void 0;
 class GraphData {
     constructor({ graph, currentGraph, graphOptions, nodeDbExistence }) {
         this.graph = graph;
@@ -7,6 +9,4 @@ class GraphData {
         this.nodeDbExistence = nodeDbExistence;
     }
 }
-module.exports = {
-    GraphData,
-};
+exports.GraphData = GraphData;

package/lib/queryBuilder/graph/GraphFetcher.js

@@ -1,21 +1,23 @@
-'use strict';
-const { asArray, groupBy } = require('../../utils/objectUtils');
-const { ModelGraph } = require('../../model/graph/ModelGraph');
-const { FetchStrategy } = require('./GraphOptions');
-const { RelationExpression } = require('../RelationExpression');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphFetcher = void 0;
+const objectUtils_1 = require("../../utils/objectUtils");
+const ModelGraph_1 = require("../../model/graph/ModelGraph");
+const GraphOptions_1 = require("./GraphOptions");
+const RelationExpression_1 = require("../RelationExpression");
 class GraphFetcher {
     /**
      * Given a graph and options, fetches the current state of that graph
      * from the database and returns it as a ModelGraph instance.
      */
-    static async fetchCurrentGraph({ builder, graph, graphOptions }) {
+    static async fetchCurrentGraph({ builder, graph, graphOptions, }) {
         const { rootObjects } = graph;
         const rootIds = getRootIds(rootObjects);
         const modelClass = builder.modelClass();
         if (rootIds.length === 0) {
-            return Promise.resolve(ModelGraph.create(modelClass, []));
+            return Promise.resolve(ModelGraph_1.ModelGraph.create(modelClass, []));
         }
-        const eagerExpr = RelationExpression.fromModelGraph(rootObjects);
+        const eagerExpr = RelationExpression_1.RelationExpression.fromModelGraph(rootObjects);
         const models = await modelClass
             .query()
             .childQueryOf(builder, childQueryOptions())
@@ -24,11 +26,12 @@ class GraphFetcher {
             .findByIds(rootIds)
             .withGraphFetched(eagerExpr)
             .internalOptions(fetchQueryInternalOptions());
-        return ModelGraph.create(modelClass, models);
+        return ModelGraph_1.ModelGraph.create(modelClass, models);
     }
 }
+exports.GraphFetcher = GraphFetcher;
 function getRootIds(rootObjects) {
-    return asArray(rootObjects)
+    return (0, objectUtils_1.asArray)(rootObjects)
         .filter((it) => it.$hasId())
         .map((root) => root.$id());
 }
@@ -57,7 +60,7 @@ function buildFetchQuerySelects(graph, graphOptions, eagerExpr) {
     };
 }
 function groupNodesByRelationPath(graph, eagerExpr) {
-    const nodesByRelationPath = groupBy(graph.nodes, (node) => node.relationPathKey);
+    const nodesByRelationPath = (0, objectUtils_1.groupBy)(graph.nodes, (node) => node.relationPathKey);
     // Not all relation paths have nodes. Relations with nulls or empty arrays
     // don't have nodes, but will still need to be fetched. Add these to the
     // map as empty arrays.
@@ -69,10 +72,10 @@ function groupNodesByRelationPath(graph, eagerExpr) {
     return nodesByRelationPath;
 }
 function createFetchSelectModifier(nodes, graphOptions) {
-    if (graphOptions.isFetchStrategy(FetchStrategy.OnlyIdentifiers)) {
+    if (graphOptions.isFetchStrategy(GraphOptions_1.FetchStrategy.OnlyIdentifiers)) {
         return createIdentifierSelector();
     }
-    else if (graphOptions.isFetchStrategy(FetchStrategy.OnlyNeeded)) {
+    else if (graphOptions.isFetchStrategy(GraphOptions_1.FetchStrategy.OnlyNeeded)) {
         return createInputColumnSelector(nodes);
     }
     else {
@@ -101,7 +104,7 @@ function createInputColumnSelector(nodes) {
             }
         }
         const selectArr = Array.from(selects.values());
-        const idColumns = asArray(builder.fullIdColumn());
+        const idColumns = (0, objectUtils_1.asArray)(builder.fullIdColumn());
         for (const idColumn of idColumns) {
             if (!selectArr.includes(idColumn)) {
                 // Always select the identifers.
@@ -142,6 +145,7 @@ function fetchQueryInternalOptions() {
         keepImplicitJoinProps: true,
     };
 }
+// `eagerExprNode` is a relation expression node: `$childNames` and a property per child.
 function forEachPath(eagerExprNode, cb, path = []) {
     for (const relation of eagerExprNode.$childNames) {
         path.push(relation);
@@ -150,6 +154,3 @@ function forEachPath(eagerExprNode, cb, path = []) {
         path.pop();
     }
 }
-module.exports = {
-    GraphFetcher,
-};

package/lib/queryBuilder/graph/GraphNodeDbExistence.js

@@ -1,7 +1,42 @@
-'use strict';
-const { GraphData } = require('./GraphData');
-const { GraphAction } = require('./GraphAction');
-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.GraphNodeDbExistence = void 0;
+const GraphData_1 = require("./GraphData");
+const GraphAction_1 = require("./GraphAction");
+const promiseUtils = __importStar(require("../../utils/promiseUtils"));
 /**
  * This weird little class is responsible for checking (and maintaining information)
  * whether certain nodes exist in the database.
@@ -19,12 +54,12 @@ class GraphNodeDbExistence {
      * creates an instance of GraphNodeDbExistence that can be used to
      * synchronously check if a node exist in the database.
      */
-    static async create({ builder, graph, graphOptions, currentGraph }) {
+    static async create({ builder, graph, graphOptions, currentGraph, }) {
         if (graphOptions.isInsertOnly()) {
             // With insertGraph, we never want to do anything but inserts.
             return GraphNodeDbExistence.createEveryNodeExistsExistence();
         }
-        const graphData = new GraphData({
+        const graphData = new GraphData_1.GraphData({
             graph,
             graphOptions,
             currentGraph,
@@ -54,6 +89,7 @@ class GraphNodeDbExistence {
         return !idMap.has(node.obj.$idKey());
     }
 }
+exports.GraphNodeDbExistence = GraphNodeDbExistence;
 function createMayNotExistMap(graphData) {
     const { graph, currentGraph, graphOptions } = graphData;
     const mayNotExist = new Map();
@@ -94,11 +130,11 @@ function hasNodeById(currentGraph, nodeToFind) {
             idProps.every((idProp) => node.obj[idProp] === nodeToFind.obj[idProp]));
     });
 }
-async function createDontExistMap({ builder, mayNotExist, mayNotExistNodes }) {
+async function createDontExistMap({ builder, mayNotExist, mayNotExistNodes, }) {
     const dontExist = cloneExistenceMap(mayNotExist);
     const existenceCheckQueries = createExistenceCheckQueries({ builder, mayNotExist });
     const results = await promiseUtils.map(existenceCheckQueries, (builder) => builder.execute(), {
-        concurrency: GraphAction.getConcurrency(builder, mayNotExistNodes),
+        concurrency: GraphAction_1.GraphAction.getConcurrency(builder, mayNotExistNodes),
     });
     // Remove all items from the mayNotExist map that we have just proven to exist
     // by executing the existenceCheckQueries.
@@ -113,7 +149,7 @@ async function createDontExistMap({ builder, mayNotExist, mayNotExistNodes }) {
     // Now only items that don't exist in the db are left in this map.
     return dontExist;
 }
-function createExistenceCheckQueries({ builder, mayNotExist }) {
+function createExistenceCheckQueries({ builder, mayNotExist, }) {
     const builders = [];
     for (const [modelClass, idMap] of mayNotExist.entries()) {
         const ids = Array.from(idMap.values());
@@ -141,6 +177,3 @@ function cloneExistenceMap(exixtenseMap) {
     }
     return clone;
 }
-module.exports = {
-    GraphNodeDbExistence,
-};

package/lib/queryBuilder/graph/GraphOperation.js

@@ -1,4 +1,6 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphOperation = void 0;
 class GraphOperation {
     constructor(graphData) {
         this.graphData = graphData;
@@ -16,6 +18,4 @@ class GraphOperation {
         return [];
     }
 }
-module.exports = {
-    GraphOperation,
-};
+exports.GraphOperation = GraphOperation;

package/lib/queryBuilder/graph/GraphOptions.js

@@ -1,4 +1,6 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchStrategy = exports.GraphOptions = void 0;
 const NO_RELATE = 'noRelate';
 const NO_UNRELATE = 'noUnrelate';
 const NO_INSERT = 'noInsert';
@@ -15,6 +17,7 @@ const FetchStrategy = {
     Everything: 'Everything',
     OnlyNeeded: 'OnlyNeeded',
 };
+exports.FetchStrategy = FetchStrategy;
 class GraphOptions {
     constructor(options) {
         if (options instanceof GraphOptions) {
@@ -147,6 +150,7 @@ class GraphOptions {
         }
     }
 }
+exports.GraphOptions = GraphOptions;
 function getCurrentNode(node, graphData) {
     if (!graphData || !node) {
         return null;
@@ -159,7 +163,3 @@ function getNode(currentNode, graph) {
     }
     return graph.nodeForNode(currentNode);
 }
-module.exports = {
-    GraphOptions,
-    FetchStrategy,
-};

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,
-};