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

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;

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

@@ -1,17 +1,52 @@
-'use strict';
-const jsonApi = 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.WhereJsonNotObjectOperation = void 0;
+const jsonApi = __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");
 // `whereJsonNotArray` and `whereJsonNotObject`.
-class WhereJsonNotObjectOperation extends ObjectionToKnexConvertingOperation {
+class WhereJsonNotObjectOperation 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 fieldExpression = this.getKnexArgs(builder)[0];
         if (dialect === 'mysql') {
             const [rawSql, bindings] = mysqlJsonApi.whereJsonNotContains(fieldExpression, this.opt.compareValue);
-            const sql = jsonCastsForDialect(rawSql, builder.unsafeKnex());
+            const sql = (0, mysqlJsonPath_1.jsonCastsForDialect)(rawSql, builder.unsafeKnex());
             return this.opt.bool === 'or'
                 ? knexBuilder.orWhereRaw(sql, bindings)
                 : knexBuilder.whereRaw(sql, bindings);
@@ -32,6 +67,4 @@ class WhereJsonNotObjectOperation extends ObjectionToKnexConvertingOperation {
         return knexBuilder;
     }
 }
-module.exports = {
-    WhereJsonNotObjectOperation,
-};
+exports.WhereJsonNotObjectOperation = WhereJsonNotObjectOperation;

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

@@ -1,20 +1,55 @@
-'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.WhereJsonOperation = 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");
 // `whereJsonSupersetOf`, `whereJsonSubsetOf` and their variants.
-class WhereJsonOperation extends ObjectionToKnexConvertingOperation {
+class WhereJsonOperation 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);
         const jsonApi = dialect === 'mysql'
             ? mysqlJsonApi.whereJsonContains
             : postgresJsonApi.whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams;
         const rawArgs = jsonApi(args[0], this.opt.operator, args[1], this.opt.prefix);
         if (dialect === 'mysql') {
-            rawArgs[0] = jsonCastsForDialect(rawArgs[0], builder.unsafeKnex());
+            rawArgs[0] = (0, mysqlJsonPath_1.jsonCastsForDialect)(rawArgs[0], builder.unsafeKnex());
         }
         if (this.opt.bool === 'or') {
             knexBuilder = knexBuilder.orWhereRaw.apply(knexBuilder, rawArgs);
@@ -25,6 +60,4 @@ class WhereJsonOperation extends ObjectionToKnexConvertingOperation {
         return knexBuilder;
     }
 }
-module.exports = {
-    WhereJsonOperation,
-};
+exports.WhereJsonOperation = WhereJsonOperation;