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

package/lib/queryBuilder/FunctionBuilder.js

@@ -1,12 +1,15 @@
-'use strict';
-const { RawBuilder, normalizeRawArgs } = require('./RawBuilder');
-const { ref } = require('./ReferenceBuilder');
-const { expression } = require('./expressions');
-const { asArray, asSingle, isNumber, isObject, isPlainObject } = require('../utils/objectUtils');
-const { getDialect, isMySql, isMariaDb } = require('../utils/knexUtils');
-const { jsonCastsForDialect, JSON_CAST } = require('../utils/mysqlJsonPath');
-const { FUNCTIONS, MARIADB_UNSUPPORTED, buildOrderBy } = require('./functions/mysql');
-class FunctionBuilder extends RawBuilder {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionBuilder = void 0;
+exports.fn = fn;
+const RawBuilder_1 = require("./RawBuilder");
+const ReferenceBuilder_1 = require("./ReferenceBuilder");
+const expressions_1 = require("./expressions");
+const objectUtils_1 = require("../utils/objectUtils");
+const knexUtils_1 = require("../utils/knexUtils");
+const mysqlJsonPath_1 = require("../utils/mysqlJsonPath");
+const mysql_1 = require("./functions/mysql");
+class FunctionBuilder extends RawBuilder_1.RawBuilder {
     constructor(sql, args) {
         super(sql, args);
         // The name of the `fn` helper of a MySQL only function.
@@ -46,16 +49,16 @@ class FunctionBuilder extends RawBuilder {
     }
     toKnexRaw(builder) {
         const knex = builder.unsafeKnex();
-        if (this._mysqlFunction && knex && !isMySql(knex)) {
-            throw new Error(`fn.${this._mysqlFunction}() is a MySQL function and can't be used with ${getDialect(knex)}.`);
+        if (this._mysqlFunction && knex && !(0, knexUtils_1.isMySql)(knex)) {
+            throw new Error(`fn.${this._mysqlFunction}() is a MySQL function and can't be used with ${(0, knexUtils_1.getDialect)(knex)}.`);
         }
         // The SQL of the helpers is created before the database is known.
-        if (knex && isMariaDb(knex) && this._sql.includes(JSON_CAST)) {
+        if (knex && (0, knexUtils_1.isMariaDb)(knex) && this._sql.includes(mysqlJsonPath_1.JSON_CAST)) {
             const copy = Object.assign(Object.create(Object.getPrototypeOf(this)), this);
-            copy._sql = jsonCastsForDialect(this._sql, knex);
+            copy._sql = (0, mysqlJsonPath_1.jsonCastsForDialect)(this._sql, knex);
             return copy.toKnexRaw(builder);
         }
-        if (this._mariaDbError && knex && isMariaDb(knex)) {
+        if (this._mariaDbError && knex && (0, knexUtils_1.isMariaDb)(knex)) {
             throw new Error(this._mariaDbError);
         }
         if (this._windowFunction && !this._over) {
@@ -64,7 +67,7 @@ class FunctionBuilder extends RawBuilder {
         if (this._filters.length === 0 && !this._over) {
             return super.toKnexRaw(builder);
         }
-        return new RawBuilder(...this._buildFilterAndOver()).as(this._as).toKnexRaw(builder);
+        return new RawBuilder_1.RawBuilder(...this._buildFilterAndOver()).as(this._as).toKnexRaw(builder);
     }
     _buildFilterAndOver() {
         let sql = this._sql;
@@ -72,7 +75,7 @@ class FunctionBuilder extends RawBuilder {
         if (this._filters.length !== 0) {
             const condition = this._filters.length === 1
                 ? this._filters[0]
-                : expression(`(${this._filters.map(() => '?').join(' AND ')})`, this._filters);
+                : (0, expressions_1.expression)(`(${this._filters.map(() => '?').join(' AND ')})`, this._filters);
             if (this._aggregated === '*') {
                 sql = sql.replace('*', 'CASE WHEN ? THEN 1 END');
                 args = [condition];
@@ -82,6 +85,7 @@ class FunctionBuilder extends RawBuilder {
                 let i = 0;
                 sql = sql.replace(/\?/g, () => {
                     const arg = args[i++];
+                    // A number: `filter()` needs an aggregate, and '*' is handled above.
                     if (i <= this._aggregated) {
                         filtered.push(condition, arg);
                         return 'CASE WHEN ? THEN ? END';
@@ -102,6 +106,7 @@ class FunctionBuilder extends RawBuilder {
         return [sql, args];
     }
 }
+exports.FunctionBuilder = FunctionBuilder;
 // `fn.case()` is `CASE WHEN condition THEN result ... END` and `fn.case(value)` is
 // `CASE value WHEN other THEN result ... END`.
 class CaseBuilder extends FunctionBuilder {
@@ -146,7 +151,7 @@ class CaseBuilder extends FunctionBuilder {
 class ExcludedBuilder extends FunctionBuilder {
     constructor(column) {
         super('', []);
-        if (isObject(column) && column.isObjectionReferenceBuilder) {
+        if ((0, objectUtils_1.isObject)(column) && column.isObjectionReferenceBuilder) {
             column = column.column;
         }
         if (typeof column !== 'string') {
@@ -155,7 +160,7 @@ class ExcludedBuilder extends FunctionBuilder {
         this._column = column;
     }
     toKnexRaw(builder) {
-        if (isMySql(builder.unsafeKnex())) {
+        if ((0, knexUtils_1.isMySql)(builder.unsafeKnex())) {
             this._sql = 'VALUES(??)';
             this._args = [this._column];
         }
@@ -170,19 +175,19 @@ function buildOver({ partitionBy, orderBy }) {
     const parts = [];
     const args = [];
     if (partitionBy !== undefined) {
-        const columns = asArray(partitionBy).map((it) => (typeof it === 'string' ? ref(it) : it));
+        const columns = (0, objectUtils_1.asArray)(partitionBy).map((it) => typeof it === 'string' ? (0, ReferenceBuilder_1.ref)(it) : it);
         parts.push(`PARTITION BY ${columns.map(() => '?').join(', ')}`);
         args.push(...columns);
     }
     if (orderBy !== undefined) {
-        const [orderBySql, orderByArgs] = buildOrderBy('over()', orderBy);
+        const [orderBySql, orderByArgs] = (0, mysql_1.buildOrderBy)('over()', orderBy);
         parts.push(`ORDER BY ${orderBySql}`);
         args.push(...orderByArgs);
     }
     return [parts.join(' '), args];
 }
 function fn(...argsIn) {
-    const { sql, args } = normalizeRawArgs(argsIn);
+    const { sql, args } = (0, RawBuilder_1.normalizeRawArgs)(argsIn);
     return new FunctionBuilder(`${sql}(${args.map(() => '?').join(', ')})`, args);
 }
 for (const func of ['coalesce', 'concat', 'upper', 'lower']) {
@@ -199,8 +204,10 @@ fn.count = (...args) => {
     return aggregate(fn('COUNT', args), args.length);
 };
 fn.now = (precision) => {
-    precision = parseInt(asSingle(precision), 10);
-    if (isNaN(precision) || !isNumber(precision)) {
+    // `parseInt()` converts a number to a string first.
+    precision = parseInt((0, objectUtils_1.asSingle)(precision), 10);
+    // A number, from `parseInt()`.
+    if (isNaN(precision) || !(0, objectUtils_1.isNumber)(precision)) {
         precision = 6;
     }
     // We need to use a literal precision instead of a binding here
@@ -211,13 +218,14 @@ fn.now = (precision) => {
 };
 fn.case = (...args) => new CaseBuilder(args.length !== 0, args[0]);
 fn.exists = (subquery) => {
-    if (!isObject(subquery) || !subquery.isObjectionQueryBuilderBase) {
+    if (!(0, objectUtils_1.isObject)(subquery) ||
+        !subquery.isObjectionQueryBuilderBase) {
         throw new Error('fn.exists() takes a query.');
     }
     return new FunctionBuilder('(EXISTS ?)', [subquery]);
 };
 fn.excluded = (column) => new ExcludedBuilder(column);
-for (const [name, sql, , , options = {}] of FUNCTIONS) {
+for (const [name, sql, , , options = {}] of mysql_1.FUNCTIONS) {
     // `defineProperty` since `fn.length` is a read-only property of functions.
     Object.defineProperty(fn, name, {
         configurable: true,
@@ -235,7 +243,7 @@ function createMySqlFunction(name, sql, options) {
         if (!options.portable) {
             builder._mysqlFunction = name;
         }
-        const mariaDbReason = MARIADB_UNSUPPORTED[name] && MARIADB_UNSUPPORTED[name](args);
+        const mariaDbReason = mysql_1.MARIADB_UNSUPPORTED[name] && mysql_1.MARIADB_UNSUPPORTED[name](args);
         if (mariaDbReason) {
             builder._mariaDbError = `fn.${name}() ${mariaDbReason}.`;
         }
@@ -276,7 +284,7 @@ function isJsonArg(json, i) {
     }
 }
 function isJsonValue(value) {
-    return Array.isArray(value) || isPlainObject(value);
+    return Array.isArray(value) || (0, objectUtils_1.isPlainObject)(value);
 }
 Object.defineProperties(FunctionBuilder.prototype, {
     isObjectionFunctionBuilder: {
@@ -285,7 +293,3 @@ Object.defineProperties(FunctionBuilder.prototype, {
         value: true,
     },
 });
-module.exports = {
-    FunctionBuilder,
-    fn,
-};

package/lib/queryBuilder/JoinBuilder.js

@@ -1,124 +1,125 @@
-'use strict';
-const { QueryBuilderOperationSupport } = require('./QueryBuilderOperationSupport');
-const { KnexOperation } = require('./operations/KnexOperation');
-const { WhereInOperation } = require('./operations/WhereInOperation');
-const { QueryBuilderOperation } = require('./operations/QueryBuilderOperation');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinBuilder = void 0;
+const QueryBuilderOperationSupport_1 = require("./QueryBuilderOperationSupport");
+const KnexOperation_1 = require("./operations/KnexOperation");
+const WhereInOperation_1 = require("./operations/WhereInOperation");
+const QueryBuilderOperation_1 = require("./operations/QueryBuilderOperation");
 // knex's `join.on(a, b).or.on(c, d)`: `or` makes the next condition an `or`.
-class OrOperation extends QueryBuilderOperation {
+class OrOperation extends QueryBuilderOperation_1.QueryBuilderOperation {
+    // knex's typings don't declare the `or` getter.
     onBuildKnex(knexBuilder) {
         return knexBuilder.or;
     }
 }
-class JoinBuilder extends QueryBuilderOperationSupport {
+class JoinBuilder extends QueryBuilderOperationSupport_1.QueryBuilderOperationSupport {
     get or() {
         return this.addOperation(new OrOperation('or'), []);
     }
     using(...args) {
-        return this.addOperation(new KnexOperation('using'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('using'), args);
     }
     on(...args) {
-        return this.addOperation(new KnexOperation('on'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('on'), args);
     }
     orOn(...args) {
-        return this.addOperation(new KnexOperation('orOn'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('orOn'), args);
     }
     onBetween(...args) {
-        return this.addOperation(new KnexOperation('onBetween'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('onBetween'), args);
     }
     onNotBetween(...args) {
-        return this.addOperation(new KnexOperation('onNotBetween'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('onNotBetween'), args);
     }
     orOnBetween(...args) {
-        return this.addOperation(new KnexOperation('orOnBetween'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('orOnBetween'), args);
     }
     orOnNotBetween(...args) {
-        return this.addOperation(new KnexOperation('orOnNotBetween'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('orOnNotBetween'), args);
     }
     onIn(...args) {
-        return this.addOperation(new WhereInOperation('onIn', { rawMethod: 'on' }), args);
+        return this.addOperation(new WhereInOperation_1.WhereInOperation('onIn', { rawMethod: 'on' }), args);
     }
     onNotIn(...args) {
-        return this.addOperation(new WhereInOperation('onNotIn', { rawMethod: 'on', not: true }), args);
+        return this.addOperation(new WhereInOperation_1.WhereInOperation('onNotIn', { rawMethod: 'on', not: true }), args);
     }
     orOnIn(...args) {
-        return this.addOperation(new WhereInOperation('orOnIn', { rawMethod: 'orOn' }), args);
+        return this.addOperation(new WhereInOperation_1.WhereInOperation('orOnIn', { rawMethod: 'orOn' }), args);
     }
     orOnNotIn(...args) {
-        return this.addOperation(new WhereInOperation('orOnNotIn', { rawMethod: 'orOn', not: true }), args);
+        return this.addOperation(new WhereInOperation_1.WhereInOperation('orOnNotIn', { rawMethod: 'orOn', not: true }), args);
     }
     onNull(...args) {
-        return this.addOperation(new KnexOperation('onNull'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('onNull'), args);
     }
     orOnNull(...args) {
-        return this.addOperation(new KnexOperation('orOnNull'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('orOnNull'), args);
     }
     onNotNull(...args) {
-        return this.addOperation(new KnexOperation('onNotNull'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('onNotNull'), args);
     }
     orOnNotNull(...args) {
-        return this.addOperation(new KnexOperation('orOnNotNull'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('orOnNotNull'), args);
     }
     onExists(...args) {
-        return this.addOperation(new KnexOperation('onExists'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('onExists'), args);
     }
     orOnExists(...args) {
-        return this.addOperation(new KnexOperation('orOnExists'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('orOnExists'), args);
     }
     onNotExists(...args) {
-        return this.addOperation(new KnexOperation('onNotExists'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('onNotExists'), args);
     }
     orOnNotExists(...args) {
-        return this.addOperation(new KnexOperation('orOnNotExists'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('orOnNotExists'), args);
     }
     type(...args) {
-        return this.addOperation(new KnexOperation('type'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('type'), args);
     }
     andOn(...args) {
-        return this.addOperation(new KnexOperation('andOn'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('andOn'), args);
     }
     andOnIn(...args) {
-        return this.addOperation(new WhereInOperation('andOnIn', { rawMethod: 'andOn' }), args);
+        return this.addOperation(new WhereInOperation_1.WhereInOperation('andOnIn', { rawMethod: 'andOn' }), args);
     }
     andOnNotIn(...args) {
-        return this.addOperation(new WhereInOperation('andOnNotIn', { rawMethod: 'andOn', not: true }), args);
+        return this.addOperation(new WhereInOperation_1.WhereInOperation('andOnNotIn', { rawMethod: 'andOn', not: true }), args);
     }
     andOnNull(...args) {
-        return this.addOperation(new KnexOperation('andOnNull'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('andOnNull'), args);
     }
     andOnNotNull(...args) {
-        return this.addOperation(new KnexOperation('andOnNotNull'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('andOnNotNull'), args);
     }
     andOnExists(...args) {
-        return this.addOperation(new KnexOperation('andOnExists'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('andOnExists'), args);
     }
     andOnNotExists(...args) {
-        return this.addOperation(new KnexOperation('andOnNotExists'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('andOnNotExists'), args);
     }
     andOnBetween(...args) {
-        return this.addOperation(new KnexOperation('andOnBetween'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('andOnBetween'), args);
     }
     andOnNotBetween(...args) {
-        return this.addOperation(new KnexOperation('andOnNotBetween'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('andOnNotBetween'), args);
     }
     onJsonPathEquals(...args) {
-        return this.addOperation(new KnexOperation('onJsonPathEquals'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('onJsonPathEquals'), args);
     }
     orOnJsonPathEquals(...args) {
-        return this.addOperation(new KnexOperation('orOnJsonPathEquals'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('orOnJsonPathEquals'), args);
     }
     andOnJsonPathEquals(...args) {
-        return this.addOperation(new KnexOperation('andOnJsonPathEquals'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('andOnJsonPathEquals'), args);
     }
     onVal(...args) {
-        return this.addOperation(new KnexOperation('onVal'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('onVal'), args);
     }
     andOnVal(...args) {
-        return this.addOperation(new KnexOperation('andOnVal'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('andOnVal'), args);
     }
     orOnVal(...args) {
-        return this.addOperation(new KnexOperation('orOnVal'), args);
+        return this.addOperation(new KnexOperation_1.KnexOperation('orOnVal'), args);
     }
 }
-module.exports = {
-    JoinBuilder,
-};
+exports.JoinBuilder = JoinBuilder;

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;