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

package/lib/queryBuilder/operations/UpdateOperation.js

@@ -1,12 +1,15 @@
-'use strict';
-const { ref } = require('../../queryBuilder/ReferenceBuilder');
-const { isEmpty } = require('../../utils/objectUtils');
-const { isKnexRaw, isKnexQueryBuilder } = require('../../utils/knexUtils');
-const { toPgJsonPathLiteral, getJsonDialect } = require('../../utils/postgresJsonPath');
-const { toMySqlJsonPath, toJsonSql } = require('../../utils/mysqlJsonPath');
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-const { StaticHookArguments, hasStaticHook } = require('../StaticHookArguments');
-class UpdateOperation extends QueryBuilderOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateOperation = void 0;
+exports.convertFieldExpressionsToRaw = convertFieldExpressionsToRaw;
+const ReferenceBuilder_1 = require("../../queryBuilder/ReferenceBuilder");
+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 QueryBuilderOperation_1 = require("./QueryBuilderOperation");
+const StaticHookArguments_1 = require("../StaticHookArguments");
+class UpdateOperation extends QueryBuilderOperation_1.QueryBuilderOperation {
     constructor(name, opt) {
         super(name, opt);
         this.model = null;
@@ -24,7 +27,7 @@ class UpdateOperation extends QueryBuilderOperation {
     }
     onBefore3(builder) {
         const row = this.model.$toDatabaseJson(builder);
-        if (isEmpty(row)) {
+        if ((0, objectUtils_1.isEmpty)(row)) {
             // Resolve the query if there is nothing to update.
             builder.resolve(0);
         }
@@ -46,6 +49,7 @@ class UpdateOperation extends QueryBuilderOperation {
         return clone;
     }
 }
+exports.UpdateOperation = UpdateOperation;
 async function callBeforeUpdate(builder, model, modelOptions) {
     await callInstanceBeforeUpdate(builder, model, modelOptions);
     return callStaticBeforeUpdate(builder);
@@ -54,10 +58,10 @@ function callInstanceBeforeUpdate(builder, model, modelOptions) {
     return model.$beforeUpdate(modelOptions, builder.context());
 }
 function callStaticBeforeUpdate(builder) {
-    if (!hasStaticHook(builder.modelClass(), 'beforeUpdate')) {
+    if (!(0, StaticHookArguments_1.hasStaticHook)(builder.modelClass(), 'beforeUpdate')) {
         return undefined;
     }
-    const args = StaticHookArguments.create({ builder });
+    const args = StaticHookArguments_1.StaticHookArguments.create({ builder });
     return builder.modelClass().beforeUpdate(args);
 }
 async function callAfterUpdate(builder, model, modelOptions, result) {
@@ -68,10 +72,10 @@ function callInstanceAfterUpdate(builder, model, modelOptions) {
     return model.$afterUpdate(modelOptions, builder.context());
 }
 async function callStaticAfterUpdate(builder, result) {
-    if (!hasStaticHook(builder.modelClass(), 'afterUpdate')) {
+    if (!(0, StaticHookArguments_1.hasStaticHook)(builder.modelClass(), 'afterUpdate')) {
         return result;
     }
-    const args = StaticHookArguments.create({ builder, result });
+    const args = StaticHookArguments_1.StaticHookArguments.create({ builder, result });
     const maybeResult = await builder.modelClass().afterUpdate(args);
     if (maybeResult === undefined) {
         return result;
@@ -91,22 +95,22 @@ function convertFieldExpressionsToRaw(builder, model, json) {
             // on postgres and to
             // `col` : raw("JSON_SET(COALESCE(`col`, JSON_OBJECT()), '$.\"attr\"', JSON_EXTRACT(`other`, '$.\"lol\"'))")
             // on mysql. A NULL column is treated as an empty object (or array).
-            const parsed = ref(key);
+            const parsed = (0, ReferenceBuilder_1.ref)(key);
             const access = parsed.parsedExpr.access;
-            const isSqlValue = isKnexQueryBuilder(val) || isKnexRaw(val);
+            const isSqlValue = (0, knexUtils_1.isKnexQueryBuilder)(val) || (0, knexUtils_1.isKnexRaw)(val);
             // When the column is set by an earlier key, that expression is used instead.
             const target = convertedJson[parsed.column] || parsed.column;
             const isFirstSet = !convertedJson[parsed.column];
             if (!isSqlValue) {
                 val = JSON.stringify(val);
             }
-            if (getJsonDialect(knex, key) === 'mysql') {
+            if ((0, postgresJsonPath_1.getJsonDialect)(knex, key) === 'mysql') {
                 const empty = access[0].type === 'array' ? 'JSON_ARRAY()' : 'JSON_OBJECT()';
                 const column = isFirstSet ? `COALESCE(??, ${empty})` : '??';
-                const value = isSqlValue ? '?' : toJsonSql('?', knex);
+                const value = isSqlValue ? '?' : (0, mysqlJsonPath_1.toJsonSql)('?', knex);
                 convertedJson[parsed.column] = knex.raw(`JSON_SET(${column}, ?, ${value})`, [
                     target,
-                    toMySqlJsonPath(access),
+                    (0, mysqlJsonPath_1.toMySqlJsonPath)(access),
                     val,
                 ]);
             }
@@ -114,7 +118,7 @@ function convertFieldExpressionsToRaw(builder, model, json) {
                 const empty = access[0].type === 'array' ? `'[]'::jsonb` : `'{}'::jsonb`;
                 const column = isFirstSet ? `COALESCE(??, ${empty})` : '??';
                 const value = isSqlValue ? 'to_jsonb(?)' : '?';
-                convertedJson[parsed.column] = knex.raw(`jsonb_set(${column}, ${toPgJsonPathLiteral(access)}, ${value}, true)`, [target, val]);
+                convertedJson[parsed.column] = knex.raw(`jsonb_set(${column}, ${(0, postgresJsonPath_1.toPgJsonPathLiteral)(access)}, ${value}, true)`, [target, val]);
             }
             delete model[key];
         }
@@ -124,7 +128,3 @@ function convertFieldExpressionsToRaw(builder, model, json) {
     }
     return convertedJson;
 }
-module.exports = {
-    UpdateOperation,
-    convertFieldExpressionsToRaw,
-};

package/lib/queryBuilder/operations/UpsertGraphAndFetchOperation.js

@@ -1,11 +1,13 @@
-'use strict';
-const { DelegateOperation } = require('./DelegateOperation');
-const { UpsertGraphOperation } = require('./UpsertGraphOperation');
-const { RelationExpression } = require('../RelationExpression');
-class UpsertGraphAndFetchOperation extends DelegateOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpsertGraphAndFetchOperation = void 0;
+const DelegateOperation_1 = require("./DelegateOperation");
+const UpsertGraphOperation_1 = require("./UpsertGraphOperation");
+const RelationExpression_1 = require("../RelationExpression");
+class UpsertGraphAndFetchOperation extends DelegateOperation_1.DelegateOperation {
     constructor(name, opt) {
         super(name, opt);
-        if (!this.delegate.is(UpsertGraphOperation)) {
+        if (!this.delegate.is(UpsertGraphOperation_1.UpsertGraphOperation)) {
             throw new Error('Invalid delegate');
         }
     }
@@ -19,7 +21,7 @@ class UpsertGraphAndFetchOperation extends DelegateOperation {
         if (this.models.length === 0) {
             return this.isArray ? [] : null;
         }
-        const eager = RelationExpression.fromModelGraph(this.models);
+        const eager = RelationExpression_1.RelationExpression.fromModelGraph(this.models);
         const modelClass = this.models[0].constructor;
         const ids = this.models.map((model) => model.$id());
         const models = await modelClass
@@ -30,6 +32,4 @@ class UpsertGraphAndFetchOperation extends DelegateOperation {
         return this.isArray ? models : models[0] || null;
     }
 }
-module.exports = {
-    UpsertGraphAndFetchOperation,
-};
+exports.UpsertGraphAndFetchOperation = UpsertGraphAndFetchOperation;

package/lib/queryBuilder/operations/UpsertGraphOperation.js

@@ -1,8 +1,10 @@
-'use strict';
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-const { GraphUpsert } = require('../graph/GraphUpsert');
-const { RelationFindOperation } = require('../../relations/RelationFindOperation');
-class UpsertGraphOperation extends QueryBuilderOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpsertGraphOperation = void 0;
+const QueryBuilderOperation_1 = require("./QueryBuilderOperation");
+const GraphUpsert_1 = require("../graph/GraphUpsert");
+const RelationFindOperation_1 = require("../../relations/RelationFindOperation");
+class UpsertGraphOperation extends QueryBuilderOperation_1.QueryBuilderOperation {
     constructor(name, opt) {
         super(name, Object.assign({}, opt, {
             upsertOptions: {},
@@ -18,7 +20,7 @@ class UpsertGraphOperation extends QueryBuilderOperation {
     }
     onAdd(builder, args) {
         const [objects] = args;
-        this.upsert = new GraphUpsert({
+        this.upsert = new GraphUpsert_1.GraphUpsert({
             objects,
             rootModelClass: builder.modelClass(),
             upsertOptions: this.upsertOptions,
@@ -39,9 +41,7 @@ class UpsertGraphOperation extends QueryBuilderOperation {
         return clone;
     }
 }
+exports.UpsertGraphOperation = UpsertGraphOperation;
 function hasOtherSqlModifyingQueryBuilderCalls(builder) {
-    return builder.has(/where/) || builder.has(RelationFindOperation);
+    return builder.has(/where/) || builder.has(RelationFindOperation_1.RelationFindOperation);
 }
-module.exports = {
-    UpsertGraphOperation,
-};

package/lib/queryBuilder/operations/WhereCompositeOperation.js

@@ -1,7 +1,9 @@
-'use strict';
-const { ObjectionToKnexConvertingOperation } = require('./ObjectionToKnexConvertingOperation');
-const { asSingle } = require('../../utils/objectUtils');
-class WhereCompositeOperation extends ObjectionToKnexConvertingOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhereCompositeOperation = void 0;
+const ObjectionToKnexConvertingOperation_1 = require("./ObjectionToKnexConvertingOperation");
+const objectUtils_1 = require("../../utils/objectUtils");
+class WhereCompositeOperation extends ObjectionToKnexConvertingOperation_1.ObjectionToKnexConvertingOperation {
     onBuildKnex(knexBuilder, builder) {
         const args = this.getKnexArgs(builder);
         if (args.length === 2) {
@@ -14,6 +16,7 @@ class WhereCompositeOperation extends ObjectionToKnexConvertingOperation {
         return knexBuilder.where(...buildWhereArgs(...args));
     }
 }
+exports.WhereCompositeOperation = WhereCompositeOperation;
 function buildWhereArgs(cols, op, values) {
     if (isNormalWhere(cols, values)) {
         return buildNormalWhereArgs(cols, op, values);
@@ -29,7 +32,7 @@ function isNormalWhere(cols, values) {
     return ((!Array.isArray(cols) || cols.length === 1) && (!Array.isArray(values) || values.length === 1));
 }
 function buildNormalWhereArgs(cols, op, values) {
-    return [asSingle(cols), op, asSingle(values)];
+    return [(0, objectUtils_1.asSingle)(cols), op, (0, objectUtils_1.asSingle)(values)];
 }
 function isCompositeWhere(cols, values) {
     return Array.isArray(cols) && Array.isArray(values) && cols.length === values.length;
@@ -43,6 +46,3 @@ function buildCompositeWhereArgs(cols, op, values) {
         },
     ];
 }
-module.exports = {
-    WhereCompositeOperation,
-};

package/lib/queryBuilder/operations/WhereInOperation.js

@@ -1,13 +1,15 @@
-'use strict';
-const { ObjectionToKnexConvertingOperation } = require('./ObjectionToKnexConvertingOperation');
-const { isKnexRaw } = require('../../utils/knexUtils');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhereInOperation = void 0;
+const ObjectionToKnexConvertingOperation_1 = require("./ObjectionToKnexConvertingOperation");
+const knexUtils_1 = require("../../utils/knexUtils");
 // `onIn`, `onNotIn` etc. of join callbacks. knex compiles the values before the
 // column, so the bindings of a raw column (like `ref('data:a').castInt()` on
 // MySQL or `fn.lower(ref('a'))`) end up after the values and the query uses the
 // wrong bindings. In that case the condition is built as raw sql with the
 // bindings in the right order. knex 3.2 fixed this for `whereIn` but not for
 // `onIn`.
-class WhereInOperation extends ObjectionToKnexConvertingOperation {
+class WhereInOperation extends ObjectionToKnexConvertingOperation_1.ObjectionToKnexConvertingOperation {
     onBuildKnex(knexBuilder, builder) {
         const args = this.getKnexArgs(builder);
         const [column, values] = args;
@@ -22,7 +24,7 @@ class WhereInOperation extends ObjectionToKnexConvertingOperation {
             sql = `? ${not}in (${values.map(() => '?').join(', ')})`;
             bindings = [column, ...values];
         }
-        else if (isKnexRaw(values)) {
+        else if ((0, knexUtils_1.isKnexRaw)(values)) {
             // knex doesn't wrap raw bindings in parentheses.
             sql = `? ${not}in (?)`;
             bindings = [column, values];
@@ -35,12 +37,12 @@ class WhereInOperation extends ObjectionToKnexConvertingOperation {
         return knexBuilder[this.opt.rawMethod](knex.raw(sql, bindings));
     }
 }
+exports.WhereInOperation = WhereInOperation;
+// A knex raw with bindings.
 function hasBindings(column) {
-    return isKnexRaw(column) && Array.isArray(column.bindings) && column.bindings.length > 0;
+    const raw = column;
+    return (0, knexUtils_1.isKnexRaw)(raw) && Array.isArray(raw.bindings) && raw.bindings.length > 0;
 }
 function isEmptyArray(values) {
     return Array.isArray(values) && values.length === 0;
 }
-module.exports = {
-    WhereInOperation,
-};

package/lib/queryBuilder/operations/eager/EagerOperation.js

@@ -1,10 +1,12 @@
-'use strict';
-const { QueryBuilderOperation } = require('../QueryBuilderOperation');
-const { RelationExpression } = require('../../RelationExpression');
-class EagerOperation extends QueryBuilderOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EagerOperation = void 0;
+const QueryBuilderOperation_1 = require("../QueryBuilderOperation");
+const RelationExpression_1 = require("../../RelationExpression");
+class EagerOperation extends QueryBuilderOperation_1.QueryBuilderOperation {
     constructor(name, opt) {
         super(name, opt);
-        this.expression = RelationExpression.create();
+        this.expression = RelationExpression_1.RelationExpression.create();
         this.modifiersAtPath = [];
         this.graphOptions = this.opt.defaultGraphOptions;
     }
@@ -12,7 +14,9 @@ class EagerOperation extends QueryBuilderOperation {
         const expression = this.expression.clone();
         this.modifiersAtPath.forEach((modifier, i) => {
             const modifierName = getModifierName(i);
-            expression.expressionsAtPath(modifier.path).forEach((expr) => {
+            expression
+                .expressionsAtPath(modifier.path)
+                .forEach((expr) => {
                 expr.node.$modify.push(modifierName);
             });
         });
@@ -38,9 +42,7 @@ class EagerOperation extends QueryBuilderOperation {
         return clone;
     }
 }
+exports.EagerOperation = EagerOperation;
 function getModifierName(index) {
     return `_f${index}_`;
 }
-module.exports = {
-    EagerOperation,
-};

package/lib/queryBuilder/operations/eager/JoinEagerOperation.js

@@ -1,28 +1,28 @@
-'use strict';
-const { EagerOperation } = require('./EagerOperation');
-const { RelationJoiner } = require('../../join/RelationJoiner');
-class JoinEagerOperation extends EagerOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinEagerOperation = void 0;
+const EagerOperation_1 = require("./EagerOperation");
+const RelationJoiner_1 = require("../../join/RelationJoiner");
+class JoinEagerOperation extends EagerOperation_1.EagerOperation {
     constructor(name, opt) {
         super(name, opt);
         this.joiner = null;
     }
     onAdd(builder) {
         builder.findOptions({ callAfterFindDeeply: true });
-        this.joiner = new RelationJoiner({
+        this.joiner = new RelationJoiner_1.RelationJoiner({
             modelClass: builder.modelClass(),
         });
         return true;
     }
     onBefore3(builder) {
-        return this.joiner
-            .setExpression(this.buildFinalExpression())
+        return this.joiner.setExpression(this.buildFinalExpression())
             .setModifiers(this.buildFinalModifiers(builder))
             .setOptions(this.graphOptions)
             .fetchColumnInfo(builder);
     }
     onBuild(builder) {
-        this.joiner
-            .setExpression(this.buildFinalExpression())
+        this.joiner.setExpression(this.buildFinalExpression())
             .setModifiers(this.buildFinalModifiers(builder))
             .setOptions(this.graphOptions)
             .build(builder);
@@ -36,6 +36,4 @@ class JoinEagerOperation extends EagerOperation {
         return clone;
     }
 }
-module.exports = {
-    JoinEagerOperation,
-};
+exports.JoinEagerOperation = JoinEagerOperation;

package/lib/queryBuilder/operations/eager/NaiveEagerOperation.js

@@ -1,10 +1,10 @@
-'use strict';
-const { WhereInEagerOperation } = require('./WhereInEagerOperation');
-class NaiveEagerOperation extends WhereInEagerOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NaiveEagerOperation = void 0;
+const WhereInEagerOperation_1 = require("./WhereInEagerOperation");
+class NaiveEagerOperation extends WhereInEagerOperation_1.WhereInEagerOperation {
     batchSize() {
         return 1;
     }
 }
-module.exports = {
-    NaiveEagerOperation,
-};
+exports.NaiveEagerOperation = NaiveEagerOperation;

package/lib/queryBuilder/operations/eager/WhereInEagerOperation.js

@@ -1,14 +1,49 @@
-'use strict';
-const promiseUtils = require('../../../utils/promiseUtils');
-const { EagerOperation } = require('./EagerOperation');
-const { isMsSql, isOracle, isSqlite } = require('../../../utils/knexUtils');
-const { isObject, asArray, flatten, chunk } = require('../../../utils/objectUtils');
-const { ValidationErrorType } = require('../../../model/ValidationError');
-const { createModifier } = require('../../../utils/createModifier');
-const { RelationDoesNotExistError } = require('../../../model/RelationDoesNotExistError');
-const { RelationOwner } = require('../../../relations/RelationOwner');
-const { getReadConcurrency } = require('../../../model/modelConcurrency');
-class WhereInEagerOperation extends EagerOperation {
+"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.WhereInEagerOperation = void 0;
+const promiseUtils = __importStar(require("../../../utils/promiseUtils"));
+const EagerOperation_1 = require("./EagerOperation");
+const knexUtils_1 = require("../../../utils/knexUtils");
+const objectUtils_1 = require("../../../utils/objectUtils");
+const ValidationError_1 = require("../../../model/ValidationError");
+const createModifier_1 = require("../../../utils/createModifier");
+const RelationDoesNotExistError_1 = require("../../../model/RelationDoesNotExistError");
+const RelationOwner_1 = require("../../../relations/RelationOwner");
+const modelConcurrency_1 = require("../../../model/modelConcurrency");
+class WhereInEagerOperation extends EagerOperation_1.EagerOperation {
     constructor(name, opt) {
         super(name, opt);
         this.relationsToFetch = [];
@@ -18,16 +53,16 @@ class WhereInEagerOperation extends EagerOperation {
         if (this.graphOptions.maxBatchSize) {
             return this.graphOptions.maxBatchSize;
         }
-        else if (isMsSql(knex)) {
+        else if ((0, knexUtils_1.isMsSql)(knex)) {
             // On MSSQL the parameter limit is actually 2100, but since I couldn't figure out
             // if the limit is for all parameters in a query or for individual clauses, we set
             // the limit to 2000 to leave 100 parameters for where clauses etc.
             return 2000;
         }
-        else if (isOracle(knex)) {
+        else if ((0, knexUtils_1.isOracle)(knex)) {
             return 1000;
         }
-        else if (isSqlite(knex)) {
+        else if ((0, knexUtils_1.isSqlite)(knex)) {
             // SQLITE_MAX_VARIABLE_NUMBER is 999 by default
             return 999;
         }
@@ -46,17 +81,19 @@ class WhereInEagerOperation extends EagerOperation {
         this.relationsToFetch = relationsToFetch;
         this.omitProps = selectedProps;
     }
+    // `result` is whatever the query returned: models, a model, or something else
+    // like a `count` result.
     async onAfter2(builder, result) {
         const modelClass = builder.resultModelClass();
         if (!result) {
             return result;
         }
-        const models = asArray(result);
+        const models = (0, objectUtils_1.asArray)(result);
         // Check models to be actual objects, to filter out `count` results (#2397).
-        if (!models.length || !isObject(models[0])) {
+        if (!models.length || !(0, objectUtils_1.isObject)(models[0])) {
             return result;
         }
-        await promiseUtils.map(this.relationsToFetch, (it) => this.fetchRelation(builder, models, it.relation, it.childExpression), { concurrency: getReadConcurrency(modelClass, builder.unsafeKnex()) });
+        await promiseUtils.map(this.relationsToFetch, (it) => this.fetchRelation(builder, models, it.relation, it.childExpression), { concurrency: (0, modelConcurrency_1.getReadConcurrency)(modelClass, builder.unsafeKnex()) });
         const intOpt = builder.internalOptions();
         if (!this.omitProps.length || intOpt.keepImplicitJoinProps) {
             return result;
@@ -74,24 +111,25 @@ class WhereInEagerOperation extends EagerOperation {
     async fetchRelation(builder, models, relation, expr) {
         const modelClass = builder.resultModelClass();
         const batchSize = this.batchSize(builder.knex());
-        const modelBatches = chunk(models, batchSize);
+        const modelBatches = (0, objectUtils_1.chunk)(models, batchSize);
         const result = await promiseUtils.map(modelBatches, (batch) => this.fetchRelationBatch(builder, batch, relation, expr), {
-            concurrency: getReadConcurrency(modelClass, builder.unsafeKnex()),
+            concurrency: (0, modelConcurrency_1.getReadConcurrency)(modelClass, builder.unsafeKnex()),
         });
-        return flatten(result);
+        return (0, objectUtils_1.flatten)(result);
     }
     fetchRelationBatch(builder, models, relation, expr) {
         if (this.shouldSkipFetched(models, relation, expr)) {
             return this.createSkippedQuery(builder, models, relation, expr);
         }
         const queryBuilder = this.createRelationQuery(builder, relation, expr);
-        const findOperation = relation.find(queryBuilder, RelationOwner.create(models));
+        // `Relation` types the operations it creates as `RelationOperation`.
+        const findOperation = relation.find(queryBuilder, RelationOwner_1.RelationOwner.create(models));
         findOperation.alwaysReturnArray = true;
         findOperation.assignResultToOwner = true;
         findOperation.relationProperty = expr.node.$name;
         queryBuilder.addOperation(findOperation, []);
         for (const modifierName of expr.node.$modify) {
-            const modifier = createModifier({
+            const modifier = (0, createModifier_1.createModifier)({
                 modifier: modifierName,
                 modelClass: relation.relatedModelClass,
                 modifiers: this.buildFinalModifiers(builder),
@@ -103,7 +141,7 @@ class WhereInEagerOperation extends EagerOperation {
                 const modelClass = builder.modelClass();
                 if (err instanceof modelClass.ModifierNotFoundError) {
                     throw modelClass.createValidationError({
-                        type: ValidationErrorType.RelationExpression,
+                        type: ValidationError_1.ValidationErrorType.RelationExpression,
                         message: `could not find modifier "${modifierName}" for relation "${relation.name}"`,
                     });
                 }
@@ -162,6 +200,7 @@ class WhereInEagerOperation extends EagerOperation {
         return clone;
     }
 }
+exports.WhereInEagerOperation = WhereInEagerOperation;
 function findRelationsToFetch(modelClass, eagerExpression) {
     const relationsToFetch = [];
     try {
@@ -173,9 +212,9 @@ function findRelationsToFetch(modelClass, eagerExpression) {
         });
     }
     catch (err) {
-        if (err instanceof RelationDoesNotExistError) {
+        if (err instanceof RelationDoesNotExistError_1.RelationDoesNotExistError) {
             throw modelClass.createValidationError({
-                type: ValidationErrorType.RelationExpression,
+                type: ValidationError_1.ValidationErrorType.RelationExpression,
                 message: `unknown relation "${err.relationName}" in an eager expression`,
             });
         }
@@ -222,6 +261,3 @@ function getRelatedModels(models, expr) {
     }
     return allRelated;
 }
-module.exports = {
-    WhereInEagerOperation,
-};

package/lib/queryBuilder/operations/jsonApi/WhereJsonHasOperation.js

@@ -1,19 +1,54 @@
-'use strict';
-const postgresJsonApi = require('./postgresJsonApi');
-const mysqlJsonApi = require('./mysqlJsonApi');
-const { getJsonDialect } = require('../../../utils/postgresJsonPath');
-const { jsonCastsForDialect } = require('../../../utils/mysqlJsonPath');
-const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
+"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.WhereJsonHasOperation = void 0;
+const postgresJsonApi = __importStar(require("./postgresJsonApi"));
+const mysqlJsonApi = __importStar(require("./mysqlJsonApi"));
+const postgresJsonPath_1 = require("../../../utils/postgresJsonPath");
+const mysqlJsonPath_1 = require("../../../utils/mysqlJsonPath");
+const ObjectionToKnexConvertingOperation_1 = require("../ObjectionToKnexConvertingOperation");
 // `whereJsonHasAny` and `whereJsonHasAll`.
-class WhereJsonHasOperation extends ObjectionToKnexConvertingOperation {
+class WhereJsonHasOperation extends ObjectionToKnexConvertingOperation_1.ObjectionToKnexConvertingOperation {
     onBuildKnex(knexBuilder, builder) {
-        const dialect = getJsonDialect(builder.unsafeKnex(), this.name);
+        const dialect = (0, postgresJsonPath_1.getJsonDialect)(builder.unsafeKnex(), this.name);
         const args = this.getKnexArgs(builder);
         let [sql, bindings] = dialect === 'mysql'
             ? mysqlJsonApi.whereJsonHas(args[0], this.opt.operator, args[1], builder.unsafeKnex())
             : postgresJsonApi.whereJsonFieldRightStringArrayOnLeftQuery(builder.knex(), args[0], this.opt.operator, args[1]);
         if (dialect === 'mysql') {
-            sql = jsonCastsForDialect(sql, builder.unsafeKnex());
+            sql = (0, mysqlJsonPath_1.jsonCastsForDialect)(sql, builder.unsafeKnex());
         }
         if (this.opt.bool === 'or') {
             knexBuilder = knexBuilder.orWhereRaw(sql, bindings);
@@ -24,6 +59,4 @@ class WhereJsonHasOperation extends ObjectionToKnexConvertingOperation {
         return knexBuilder;
     }
 }
-module.exports = {
-    WhereJsonHasOperation,
-};
+exports.WhereJsonHasOperation = WhereJsonHasOperation;