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

package/lib/queryBuilder/QueryBuilderContext.js

@@ -1,6 +1,8 @@
-'use strict';
-const { QueryBuilderContextBase } = require('./QueryBuilderContextBase');
-class QueryBuilderContext extends QueryBuilderContextBase {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilderContext = void 0;
+const QueryBuilderContextBase_1 = require("./QueryBuilderContextBase");
+class QueryBuilderContext extends QueryBuilderContextBase_1.QueryBuilderContextBase {
     constructor(builder) {
         super(builder);
         this.runBefore = [];
@@ -15,6 +17,4 @@ class QueryBuilderContext extends QueryBuilderContextBase {
         return ctx;
     }
 }
-module.exports = {
-    QueryBuilderContext,
-};
+exports.QueryBuilderContext = QueryBuilderContext;

package/lib/queryBuilder/QueryBuilderContextBase.js

@@ -1,15 +1,21 @@
-'use strict';
-const { InternalOptions } = require('./InternalOptions');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilderContextBase = void 0;
+const InternalOptions_1 = require("./InternalOptions");
 class QueryBuilderContextBase {
     constructor(builder) {
-        this.userContext = builder ? new builder.constructor.QueryBuilderUserContext(builder) : null;
-        this.options = builder ? new this.constructor.InternalOptions() : null;
+        // `userContext` and `options` are only null in the copy that `clone()`
+        // creates, which assigns them right away.
+        this.userContext = (builder
+            ? new builder.constructor.QueryBuilderUserContext(builder)
+            : null);
+        this.options = (builder ? new this.constructor.InternalOptions() : null);
         this.knex = null;
         this.aliasMap = null;
         this.tableMap = null;
     }
     static get InternalOptions() {
-        return InternalOptions;
+        return InternalOptions_1.InternalOptions;
     }
     clone() {
         const ctx = new this.constructor();
@@ -21,6 +27,4 @@ class QueryBuilderContextBase {
         return ctx;
     }
 }
-module.exports = {
-    QueryBuilderContextBase,
-};
+exports.QueryBuilderContextBase = QueryBuilderContextBase;

package/lib/queryBuilder/QueryBuilderOperationSupport.js

@@ -1,9 +1,11 @@
-'use strict';
-const { isString, isFunction, isRegExp, mergeMaps, last } = require('../utils/objectUtils');
-const { QueryBuilderContextBase } = require('./QueryBuilderContextBase');
-const { QueryBuilderUserContext } = require('./QueryBuilderUserContext');
-const { deprecate } = require('../utils/deprecate');
-const { effectiveWhereScope, createWhereGrouping } = require('./whereScopes');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilderOperationSupport = void 0;
+const objectUtils_1 = require("../utils/objectUtils");
+const QueryBuilderContextBase_1 = require("./QueryBuilderContextBase");
+const QueryBuilderUserContext_1 = require("./QueryBuilderUserContext");
+const deprecate_1 = require("../utils/deprecate");
+const whereScopes_1 = require("./whereScopes");
 const AllSelector = () => true;
 const SelectSelector = /^(select|columns|column|distinct|count|countDistinct|min|max|sum|sumDistinct|avg|avgDistinct)$/;
 const WhereSelector = /^(where|orWhere|andWhere|find\w+)/;
@@ -31,10 +33,10 @@ class QueryBuilderOperationSupport {
         return AllSelector;
     }
     static get QueryBuilderContext() {
-        return QueryBuilderContextBase;
+        return QueryBuilderContextBase_1.QueryBuilderContextBase;
     }
     static get QueryBuilderUserContext() {
-        return QueryBuilderUserContext;
+        return QueryBuilderUserContext_1.QueryBuilderUserContext;
     }
     static get SelectSelector() {
         return SelectSelector;
@@ -107,7 +109,7 @@ class QueryBuilderOperationSupport {
         const tableName = getTableName(modelClassOrTableName);
         const ctx = this.internalContext();
         const tableMap = ctx.tableMap;
-        if (isString(newTableName)) {
+        if ((0, objectUtils_1.isString)(newTableName)) {
             ctx.tableMap = tableMap || new Map();
             ctx.tableMap.set(tableName, newTableName);
             return this;
@@ -120,7 +122,7 @@ class QueryBuilderOperationSupport {
         const tableName = getTableName(modelClassOrTableName);
         const ctx = this.internalContext();
         const aliasMap = ctx.aliasMap;
-        if (isString(alias)) {
+        if ((0, objectUtils_1.isString)(alias)) {
             ctx.aliasMap = aliasMap || new Map();
             ctx.aliasMap.set(tableName, alias);
             return this;
@@ -157,8 +159,8 @@ class QueryBuilderOperationSupport {
             if (this._isPartialQuery) {
                 // Merge alias and table name maps for "partial" subqueries.
                 const ctx = this.internalContext();
-                ctx.aliasMap = mergeMaps(query.internalContext().aliasMap, ctx.aliasMap);
-                ctx.tableMap = mergeMaps(query.internalContext().tableMap, ctx.tableMap);
+                ctx.aliasMap = (0, objectUtils_1.mergeMaps)(query.internalContext().aliasMap, ctx.aliasMap);
+                ctx.tableMap = (0, objectUtils_1.mergeMaps)(query.internalContext().tableMap, ctx.tableMap);
             }
             this._parentQuery = query;
             if (this.unsafeKnex() === null) {
@@ -205,6 +207,7 @@ class QueryBuilderOperationSupport {
         const operationsToReplace = [];
         const operationsToRemove = [];
         findQuery.forEachOperation((op) => op.hasToFindOperation(), (op) => {
+            // Only `QueryBuilder`s are turned into find queries.
             const findOp = op.toFindOperation(findQuery);
             if (!findOp) {
                 operationsToRemove.push(op);
@@ -242,7 +245,7 @@ class QueryBuilderOperationSupport {
         for (const op of operationsToAdd) {
             const opClone = op.clone();
             // The scope may come from a parent operation that is not copied.
-            opClone.whereScope = effectiveWhereScope(op);
+            opClone.whereScope = (0, whereScopes_1.effectiveWhereScope)(op);
             // We may be moving nested operations to the root. Clear
             // any links to the parent operations.
             opClone.parentOperation = null;
@@ -283,6 +286,7 @@ class QueryBuilderOperationSupport {
         }, false);
         return every;
     }
+    // Returns whatever the hook returns.
     callOperationMethod(operation, hookName, args) {
         try {
             operation.removeChildOperationsByHookName(hookName);
@@ -296,6 +300,7 @@ class QueryBuilderOperationSupport {
             this._activeOperations.pop();
         }
     }
+    // Returns whatever the hook returns.
     async callAsyncOperationMethod(operation, hookName, args) {
         operation.removeChildOperationsByHookName(hookName);
         this._activeOperations.push({
@@ -323,7 +328,7 @@ class QueryBuilderOperationSupport {
                 operation.whereScope = this._whereScope;
             }
             if (this._activeOperations.length) {
-                const { operation: parentOperation, hookName } = last(this._activeOperations);
+                const { operation: parentOperation, hookName } = (0, objectUtils_1.last)(this._activeOperations);
                 parentOperation.addChildOperation(hookName, operation);
             }
             else {
@@ -382,7 +387,7 @@ class QueryBuilderOperationSupport {
         });
     }
     executeOnBuildKnex(knexBuilder) {
-        const whereGrouping = createWhereGrouping(this);
+        const whereGrouping = (0, whereScopes_1.createWhereGrouping)(this);
         this.forEachOperation(true, (op) => {
             if (whereGrouping !== null && whereGrouping.isGrouped(op)) {
                 knexBuilder = whereGrouping.build(op, knexBuilder);
@@ -403,11 +408,12 @@ class QueryBuilderOperationSupport {
         return this.toString();
     }
     skipUndefined() {
-        deprecate('skipUndefined() is deprecated and will be removed in objection 4.0');
+        (0, deprecate_1.deprecate)('skipUndefined() is deprecated and will be removed in objection 4.0');
         this.internalOptions().skipUndefined = true;
         return this;
     }
 }
+exports.QueryBuilderOperationSupport = QueryBuilderOperationSupport;
 // Operation selectors are `true` (every operation), a regex or a string that
 // is matched against the operation name, an operation class, or a predicate.
 // Queries walk their operations many times, so the selector is classified
@@ -422,17 +428,18 @@ function selectorKind(operationSelector) {
     if (operationSelector === true) {
         return SELECT_ALL;
     }
-    else if (isRegExp(operationSelector)) {
+    else if ((0, objectUtils_1.isRegExp)(operationSelector)) {
         return SELECT_REGEX;
     }
-    else if (isString(operationSelector)) {
+    else if ((0, objectUtils_1.isString)(operationSelector)) {
         return SELECT_NAME;
     }
-    else if (isFunction(operationSelector) &&
-        operationSelector.isObjectionQueryBuilderOperationClass) {
+    else if ((0, objectUtils_1.isFunction)(operationSelector) &&
+        operationSelector
+            .isObjectionQueryBuilderOperationClass) {
         return SELECT_CLASS;
     }
-    else if (isFunction(operationSelector)) {
+    else if ((0, objectUtils_1.isFunction)(operationSelector)) {
         return SELECT_PREDICATE;
     }
     else {
@@ -444,6 +451,7 @@ function matchesSelector(op, kind, operationSelector) {
         case SELECT_ALL:
             return true;
         case SELECT_REGEX:
+            // A null name is tested as 'null', as `test()` converts it to a string.
             return operationSelector.test(op.name);
         case SELECT_NAME:
             return op.name === operationSelector;
@@ -472,13 +480,10 @@ function visitOperations(operations, kind, operationSelector, callback, match) {
     return true;
 }
 function getTableName(modelClassOrTableName) {
-    if (isString(modelClassOrTableName)) {
+    if ((0, objectUtils_1.isString)(modelClassOrTableName)) {
         return modelClassOrTableName;
     }
     else {
         return modelClassOrTableName.getTableName();
     }
 }
-module.exports = {
-    QueryBuilderOperationSupport,
-};

package/lib/queryBuilder/QueryBuilderUserContext.js

@@ -1,4 +1,6 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilderUserContext = void 0;
 const SYMBOL_BUILDER = Symbol();
 class QueryBuilderUserContext {
     constructor(builder) {
@@ -20,6 +22,4 @@ class QueryBuilderUserContext {
         return ctx;
     }
 }
-module.exports = {
-    QueryBuilderUserContext,
-};
+exports.QueryBuilderUserContext = QueryBuilderUserContext;

package/lib/queryBuilder/RawBuilder.js

@@ -1,7 +1,11 @@
-'use strict';
-const { isPlainObject } = require('../utils/objectUtils');
-const { buildArg } = require('../utils/buildUtils');
-const { addExpressionMethods } = require('./expressions');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawBuilder = void 0;
+exports.normalizeRawArgs = normalizeRawArgs;
+exports.raw = raw;
+const objectUtils_1 = require("../utils/objectUtils");
+const buildUtils_1 = require("../utils/buildUtils");
+const expressions_1 = require("./expressions");
 class RawBuilder {
     constructor(sql, args) {
         this._sql = `${sql}`;
@@ -18,7 +22,7 @@ class RawBuilder {
     toKnexRaw(builder) {
         let args = null;
         let sql = this._sql;
-        if (this._args.length === 1 && isPlainObject(this._args[0])) {
+        if (this._args.length === 1 && (0, objectUtils_1.isPlainObject)(this._args[0])) {
             args = buildObject(this._args[0], builder);
             if (this._as) {
                 args.__alias__ = this._as;
@@ -35,6 +39,7 @@ class RawBuilder {
         return builder.knex().raw(sql, args);
     }
 }
+exports.RawBuilder = RawBuilder;
 Object.defineProperties(RawBuilder.prototype, {
     isObjectionRawBuilder: {
         enumerable: false,
@@ -42,13 +47,15 @@ Object.defineProperties(RawBuilder.prototype, {
         value: true,
     },
 });
-addExpressionMethods(RawBuilder.prototype);
+(0, expressions_1.addExpressionMethods)(RawBuilder.prototype);
+// `buildArg()` turns objection builders into knex ones. Everything else is a
+// value that knex binds as it is.
 function buildArray(arr, builder) {
-    return arr.map((it) => buildArg(it, builder));
+    return arr.map((it) => (0, buildUtils_1.buildArg)(it, builder));
 }
 function buildObject(obj, builder) {
     return Object.keys(obj).reduce((args, key) => {
-        args[key] = buildArg(obj[key], builder);
+        args[key] = (0, buildUtils_1.buildArg)(obj[key], builder);
         return args;
     }, {});
 }
@@ -71,8 +78,3 @@ function raw(...argsIn) {
     const { sql, args } = normalizeRawArgs(argsIn);
     return new RawBuilder(sql, args);
 }
-module.exports = {
-    RawBuilder,
-    normalizeRawArgs,
-    raw,
-};

package/lib/queryBuilder/ReferenceBuilder.js

@@ -1,10 +1,12 @@
-'use strict';
-const { parseFieldExpression } = require('../utils/parseFieldExpression');
-const { isObject } = require('../utils/objectUtils');
-const { isMySql, isMariaDb } = require('../utils/knexUtils');
-const { toPgJsonPathLiteral, getJsonDialect } = require('../utils/postgresJsonPath');
-const { toMySqlJsonPath, toMySqlCastType, isBooleanType, toJsonSql, } = require('../utils/mysqlJsonPath');
-const { addExpressionMethods } = require('./expressions');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ref = exports.ReferenceBuilder = void 0;
+const parseFieldExpression_1 = require("../utils/parseFieldExpression");
+const objectUtils_1 = require("../utils/objectUtils");
+const knexUtils_1 = require("../utils/knexUtils");
+const postgresJsonPath_1 = require("../utils/postgresJsonPath");
+const mysqlJsonPath_1 = require("../utils/mysqlJsonPath");
+const expressions_1 = require("./expressions");
 class ReferenceBuilder {
     constructor(expr) {
         this._expr = expr;
@@ -22,6 +24,8 @@ class ReferenceBuilder {
             this._parseExpression(expr);
         }
     }
+    // `_expr`, `_parsedExpr` and `_column` are only null inside `clone()`, which
+    // sets them right after creating the clone.
     get parsedExpr() {
         return this._parsedExpr;
     }
@@ -132,13 +136,13 @@ class ReferenceBuilder {
         return builder.knex().raw(...this._createRawArgs(builder));
     }
     _parseExpression(expr) {
-        this._parsedExpr = parseFieldExpression(expr);
+        this._parsedExpr = (0, parseFieldExpression_1.parseFieldExpression)(expr);
         this._column = this._parsedExpr.column;
         this._table = this._parsedExpr.table;
     }
     _createRawArgs(builder) {
         const knex = builder.unsafeKnex();
-        const mysql = isMySql(knex);
+        const mysql = (0, knexUtils_1.isMySql)(knex);
         const bindings = [];
         let sql = this._createReferenceSql(builder, bindings);
         sql = this._maybeCast(sql, mysql, knex);
@@ -152,20 +156,20 @@ class ReferenceBuilder {
         if (access.length === 0) {
             return '??';
         }
-        if (getJsonDialect(builder.unsafeKnex(), this._expr) === 'mysql') {
-            bindings.push(toMySqlJsonPath(access));
+        if ((0, postgresJsonPath_1.getJsonDialect)(builder.unsafeKnex(), this._expr) === 'mysql') {
+            bindings.push((0, mysqlJsonPath_1.toMySqlJsonPath)(access));
             // Casts need the unquoted value: `abc` instead of the JSON string `"abc"`.
             if (this._cast) {
                 return 'JSON_UNQUOTE(JSON_EXTRACT(??, ?))';
             }
             // MariaDB's JSON_EXTRACT() returns the JSON with spaces, so it would never
             // be equal to a value like `val({ a: 1 })`, which is compact.
-            return isMariaDb(builder.unsafeKnex())
+            return (0, knexUtils_1.isMariaDb)(builder.unsafeKnex())
                 ? 'JSON_COMPACT(JSON_EXTRACT(??, ?))'
                 : 'JSON_EXTRACT(??, ?)';
         }
         const extractor = this._cast ? '#>>' : '#>';
-        return `??${extractor}${toPgJsonPathLiteral(access)}`;
+        return `??${extractor}${(0, postgresJsonPath_1.toPgJsonPathLiteral)(access)}`;
     }
     _maybeCast(sql, mysql, knex) {
         if (!this._cast) {
@@ -176,17 +180,17 @@ class ReferenceBuilder {
         }
         const isJsonField = this._parsedExpr.access.length > 0;
         // MySQL can't cast to a boolean.
-        if (isBooleanType(this._cast)) {
+        if ((0, mysqlJsonPath_1.isBooleanType)(this._cast)) {
             return isJsonField ? `(${sql} IN ('true', '1'))` : `(${sql} <> 0)`;
         }
-        const type = toMySqlCastType(this._cast);
+        const type = (0, mysqlJsonPath_1.toMySqlCastType)(this._cast);
         // `JSON_UNQUOTE()` already returns text. Casting it would change its collation
         // from the case sensitive one `->>` also uses.
         if (isJsonField && type === 'CHAR') {
             return sql;
         }
         if (type === 'JSON') {
-            return toJsonSql(sql, knex);
+            return (0, mysqlJsonPath_1.toJsonSql)(sql, knex);
         }
         return `CAST(${sql} AS ${type})`;
     }
@@ -195,7 +199,7 @@ class ReferenceBuilder {
             return sql;
         }
         else if (mysql) {
-            return toJsonSql(sql, knex);
+            return (0, mysqlJsonPath_1.toJsonSql)(sql, knex);
         }
         else {
             return `to_jsonb(${sql})`;
@@ -224,6 +228,7 @@ class ReferenceBuilder {
         }
     }
 }
+exports.ReferenceBuilder = ReferenceBuilder;
 Object.defineProperties(ReferenceBuilder.prototype, {
     isObjectionReferenceBuilder: {
         enumerable: false,
@@ -231,16 +236,13 @@ Object.defineProperties(ReferenceBuilder.prototype, {
         value: true,
     },
 });
-addExpressionMethods(ReferenceBuilder.prototype);
+(0, expressions_1.addExpressionMethods)(ReferenceBuilder.prototype);
 const ref = (reference) => {
-    if (isObject(reference) && reference.isObjectionReferenceBuilder) {
+    if ((0, objectUtils_1.isObject)(reference) && reference.isObjectionReferenceBuilder) {
         return reference;
     }
     else {
         return new ReferenceBuilder(reference);
     }
 };
-module.exports = {
-    ReferenceBuilder,
-    ref,
-};
+exports.ref = ref;

package/lib/queryBuilder/RelationExpression.js

@@ -1,15 +1,21 @@
-'use strict';
-const parser = require('./parsers/relationExpressionParser');
-const { isObject, isNumber, isString, union } = require('../utils/objectUtils');
-const { RelationDoesNotExistError } = require('../model/RelationDoesNotExistError');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuplicateRelationError = exports.RelationExpressionParseError = exports.RelationExpression = void 0;
+// A named import: `import * as` of a JavaScript module wraps it in an object
+// of getters (tsc's __importStar), which is slow to call through.
+const relationExpressionParser_1 = require("./parsers/relationExpressionParser");
+const objectUtils_1 = require("../utils/objectUtils");
+const RelationDoesNotExistError_1 = require("../model/RelationDoesNotExistError");
 class RelationExpressionParseError extends Error {
 }
+exports.RelationExpressionParseError = RelationExpressionParseError;
 class DuplicateRelationError extends RelationExpressionParseError {
     constructor(relationName) {
         super();
         this.relationName = relationName;
     }
 }
+exports.DuplicateRelationError = DuplicateRelationError;
 class RelationExpression {
     constructor(node = newNode(), recursionDepth = 0) {
         this.node = node;
@@ -18,7 +24,7 @@ class RelationExpression {
     // Create a relation expression from a string, a pojo or another
     // RelationExpression instance.
     static create(expr) {
-        if (isObject(expr)) {
+        if ((0, objectUtils_1.isObject)(expr)) {
             if (expr.isObjectionRelationExpression) {
                 return expr;
             }
@@ -26,7 +32,7 @@ class RelationExpression {
                 return new RelationExpression(normalizeNode(expr));
             }
         }
-        else if (isString(expr)) {
+        else if ((0, objectUtils_1.isString)(expr)) {
             if (expr.trim().length === 0) {
                 return new RelationExpression();
             }
@@ -58,7 +64,7 @@ class RelationExpression {
         }
     }
     get maxRecursionDepth() {
-        if (isNumber(this.node.$recursive)) {
+        if ((0, objectUtils_1.isNumber)(this.node.$recursive)) {
             return this.node.$recursive;
         }
         else {
@@ -143,7 +149,7 @@ class RelationExpression {
                 const node = this.node[childName];
                 const relation = modelClass.getRelationUnsafe(node.$relation);
                 if (!relation) {
-                    throw new RelationDoesNotExistError(node.$relation);
+                    throw new RelationDoesNotExistError_1.RelationDoesNotExistError(node.$relation);
                 }
                 const childExpr = new RelationExpression(node);
                 cb(childExpr, relation);
@@ -156,6 +162,7 @@ class RelationExpression {
     clone() {
         return new RelationExpression(cloneNode(this.node), this.recursionDepth);
     }
+    // `null` for an empty expression.
     toString() {
         return toString(this.node);
     }
@@ -166,6 +173,7 @@ class RelationExpression {
         return this.toPojo();
     }
 }
+exports.RelationExpression = RelationExpression;
 const parseCache = new Map();
 function parse(str) {
     const cachedNode = parseCache.get(str);
@@ -173,7 +181,7 @@ function parse(str) {
         return cloneNode(cachedNode);
     }
     else {
-        const node = parser.parse(str);
+        const node = (0, relationExpressionParser_1.parse)(str);
         parseCache.set(str, cloneNode(node));
         return node;
     }
@@ -194,10 +202,12 @@ function getChildNames(node) {
 }
 function toString(node) {
     const childNames = node.$childNames;
-    let childExpr = childNames.map((childName) => node[childName]).map(toString);
+    let childExpr = childNames
+        .map((childName) => node[childName])
+        .map(toString);
     let str = node.$relation;
     if (node.$recursive) {
-        if (isNumber(node.$recursive)) {
+        if ((0, objectUtils_1.isNumber)(node.$recursive)) {
             str += '.^' + node.$recursive;
         }
         else {
@@ -277,8 +287,10 @@ function normalizeNode(node = null, name = null, allRecusive = false) {
         $childNames: normalizeChildNames(node),
     };
     for (const childName of normalized.$childNames) {
+        // `node` isn't null here, since a null node has no child names.
         const childNode = node[childName];
-        if (isObject(childNode) || childNode === true) {
+        if ((0, objectUtils_1.isObject)(childNode) || childNode === true) {
+            // `true` is a node without any properties, like `{}`.
             normalized[childName] = normalizeNode(childNode, childName);
         }
     }
@@ -312,6 +324,7 @@ function findExpressionsAtPath(target, path, results) {
     }
     else {
         for (const childName of path.node.$childNames) {
+            // Not null, since `childName` is a child of `path`.
             const pathChild = path.childExpression(childName);
             const targetChild = target.childExpression(childName);
             if (targetChild) {
@@ -325,13 +338,13 @@ function mergeNodes(node1, node2) {
     const node = {
         $name: node1.$name,
         $relation: node1.$relation,
-        $modify: union(node1.$modify, node2.$modify),
+        $modify: (0, objectUtils_1.union)(node1.$modify, node2.$modify),
         $recursive: mergeRecursion(node1.$recursive, node2.$recursive),
         $allRecursive: node1.$allRecursive || node2.$allRecursive,
         $childNames: null,
     };
     if (!node.$recursive && !node.$allRecursive) {
-        node.$childNames = union(node1.$childNames, node2.$childNames);
+        node.$childNames = (0, objectUtils_1.union)(node1.$childNames, node2.$childNames);
         for (const childName of node.$childNames) {
             const child1 = node1[childName];
             const child2 = node2[childName];
@@ -346,13 +359,14 @@ function mergeNodes(node1, node2) {
     else {
         node.$childNames = [];
     }
+    // `$childNames` was set above.
     return node;
 }
 function mergeRecursion(rec1, rec2) {
     if (rec1 === true || rec2 === true) {
         return true;
     }
-    else if (isNumber(rec1) && isNumber(rec2)) {
+    else if ((0, objectUtils_1.isNumber)(rec1) && (0, objectUtils_1.isNumber)(rec2)) {
         return Math.max(rec1, rec2);
     }
     else {
@@ -366,8 +380,3 @@ Object.defineProperties(RelationExpression.prototype, {
         value: true,
     },
 });
-module.exports = {
-    RelationExpression,
-    RelationExpressionParseError,
-    DuplicateRelationError,
-};

package/lib/queryBuilder/StaticHookArguments.js

@@ -1,5 +1,9 @@
-'use strict';
-const { asArray } = require('../utils/objectUtils');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticHookArguments = void 0;
+exports.markDefaultStaticHook = markDefaultStaticHook;
+exports.hasStaticHook = hasStaticHook;
+const objectUtils_1 = require("../utils/objectUtils");
 const BUILDER_SYMBOL = Symbol();
 // The static hooks of `Model`, which do nothing. Queries skip creating the
 // arguments and calling the hook when a model class hasn't overridden it.
@@ -19,7 +23,7 @@ class StaticHookArguments {
             value: builder,
         });
         Object.defineProperty(this, 'result', {
-            value: asArray(result),
+            value: (0, objectUtils_1.asArray)(result),
         });
     }
     static create(args) {
@@ -27,7 +31,7 @@ class StaticHookArguments {
     }
     get asFindQuery() {
         return () => {
-            return this[BUILDER_SYMBOL].toFindQuery().clearWithGraphFetched().runAfter(asArray);
+            return this[BUILDER_SYMBOL].toFindQuery().clearWithGraphFetched().runAfter(objectUtils_1.asArray);
         };
     }
     get context() {
@@ -57,7 +61,7 @@ class StaticHookArguments {
     get items() {
         const op = this[BUILDER_SYMBOL].findOperation(hasItems);
         if (op) {
-            return asArray(getItems(op));
+            return (0, objectUtils_1.asArray)(getItems(op));
         }
         else {
             return [];
@@ -66,7 +70,7 @@ class StaticHookArguments {
     get inputItems() {
         const op = this[BUILDER_SYMBOL].findOperation(hasInputItems);
         if (op) {
-            return asArray(getInputItems(op));
+            return (0, objectUtils_1.asArray)(getInputItems(op));
         }
         else {
             return [];
@@ -91,6 +95,7 @@ class StaticHookArguments {
         };
     }
 }
+exports.StaticHookArguments = StaticHookArguments;
 function getRelation(op) {
     return op.relation;
 }
@@ -115,8 +120,3 @@ function getInputItems(op) {
 function hasInputItems(op) {
     return !!getInputItems(op);
 }
-module.exports = {
-    StaticHookArguments,
-    markDefaultStaticHook,
-    hasStaticHook,
-};