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

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

@@ -1,24 +1,59 @@
-'use strict';
-const mysqlJsonApi = require('./mysqlJsonApi');
-const { getJsonDialect } = require('../../../utils/postgresJsonPath');
-const { getMariaDbVersion } = require('../../../utils/knexUtils');
-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.WhereJsonOverlapsOperation = void 0;
+const mysqlJsonApi = __importStar(require("./mysqlJsonApi"));
+const postgresJsonPath_1 = require("../../../utils/postgresJsonPath");
+const knexUtils_1 = require("../../../utils/knexUtils");
+const mysqlJsonPath_1 = require("../../../utils/mysqlJsonPath");
+const ObjectionToKnexConvertingOperation_1 = require("../ObjectionToKnexConvertingOperation");
 // `whereJsonOverlaps` and its variants. Postgres has no operator for this.
-class WhereJsonOverlapsOperation extends ObjectionToKnexConvertingOperation {
+class WhereJsonOverlapsOperation extends ObjectionToKnexConvertingOperation_1.ObjectionToKnexConvertingOperation {
     onBuildKnex(knexBuilder, builder) {
         const knex = builder.unsafeKnex();
-        if (knex && getJsonDialect(knex, this.name) !== 'mysql') {
+        if (knex && (0, postgresJsonPath_1.getJsonDialect)(knex, this.name) !== 'mysql') {
             throw new Error(`${this.name} is only supported on mysql.`);
         }
-        const mariaDbVersion = knex && getMariaDbVersion(knex);
+        const mariaDbVersion = knex && (0, knexUtils_1.getMariaDbVersion)(knex);
         if (mariaDbVersion &&
             (mariaDbVersion[0] < 10 || (mariaDbVersion[0] === 10 && mariaDbVersion[1] < 9))) {
             throw new Error(`${this.name} needs MariaDB 10.9 or newer, which has JSON_OVERLAPS().`);
         }
         const args = this.getKnexArgs(builder);
         const [rawSql, bindings] = mysqlJsonApi.whereJsonOverlaps(args[0], args[1], this.opt.prefix);
-        const sql = jsonCastsForDialect(rawSql, knex);
+        const sql = (0, mysqlJsonPath_1.jsonCastsForDialect)(rawSql, knex);
         if (this.opt.bool === 'or') {
             knexBuilder = knexBuilder.orWhereRaw(sql, bindings);
         }
@@ -28,6 +63,4 @@ class WhereJsonOverlapsOperation extends ObjectionToKnexConvertingOperation {
         return knexBuilder;
     }
 }
-module.exports = {
-    WhereJsonOverlapsOperation,
-};
+exports.WhereJsonOverlapsOperation = WhereJsonOverlapsOperation;

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

@@ -1,14 +1,13 @@
-'use strict';
-const { parseFieldExpression } = require('../../../utils/parseFieldExpression');
-const { asArray, isObject, isPlainObject, isString } = require('../../../utils/objectUtils');
-const { toMySqlJsonPath } = require('../../../utils/mysqlJsonPath');
-const { isMariaDb } = require('../../../utils/knexUtils');
-// The MySQL versions of the `whereJson*` methods. They mirror the postgres
-// operators (`@>`, `<@`, `?|`, `?&`) so that the methods find the same rows on
-// both databases.
-//
-// The parts of the queries are `{ sql, bindings, type }` objects. `type` is
-// `'object'` or `'nonObject'` when the JSON type of the part is known.
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.whereJsonContains = whereJsonContains;
+exports.whereJsonNotContains = whereJsonNotContains;
+exports.whereJsonHas = whereJsonHas;
+exports.whereJsonOverlaps = whereJsonOverlaps;
+const parseFieldExpression_1 = require("../../../utils/parseFieldExpression");
+const objectUtils_1 = require("../../../utils/objectUtils");
+const mysqlJsonPath_1 = require("../../../utils/mysqlJsonPath");
+const knexUtils_1 = require("../../../utils/knexUtils");
 // Joins sql parts: sql`JSON_CONTAINS(${target}, ${candidate})`.
 function sql(strings, ...parts) {
     let text = strings[0];
@@ -24,14 +23,14 @@ function literal(text) {
 }
 // A field expression like `Table.column:a.b[0]`.
 function field(expression) {
-    const parsed = parseFieldExpression(expression);
+    const parsed = (0, parseFieldExpression_1.parseFieldExpression)(expression);
     if (parsed.access.length === 0) {
         return { sql: '??', bindings: [parsed.columnName] };
     }
     else {
         return {
             sql: 'JSON_EXTRACT(??, ?)',
-            bindings: [parsed.columnName, toMySqlJsonPath(parsed.access)],
+            bindings: [parsed.columnName, (0, mysqlJsonPath_1.toMySqlJsonPath)(parsed.access)],
         };
     }
 }
@@ -39,15 +38,15 @@ function jsonValue(value) {
     return {
         sql: 'CAST(? AS JSON)',
         bindings: [JSON.stringify(value)],
-        type: isPlainObject(value) ? 'object' : 'nonObject',
+        type: (0, objectUtils_1.isPlainObject)(value) ? 'object' : 'nonObject',
     };
 }
 // The right hand side of the methods: a field expression or a JSON value.
 function fieldOrValue(value) {
-    if (isString(value)) {
+    if ((0, objectUtils_1.isString)(value)) {
         return field(value);
     }
-    else if (isObject(value)) {
+    else if ((0, objectUtils_1.isObject)(value)) {
         return jsonValue(value);
     }
     else {
@@ -95,12 +94,14 @@ function whereJsonNotContains(fieldExpression, compareValue) {
 // `whereJsonHasAny` (`?|`) and `whereJsonHasAll` (`?&`). Like on postgres, the keys
 // are looked for in the keys of objects, in the string items of arrays and in
 // strings.
-function whereJsonHas(fieldExpression, operator, keys, knex = null) {
+function whereJsonHas(fieldExpression, operator, 
+// A key or an array of keys, made an array below.
+keys, knex = null) {
     const left = field(fieldExpression);
     const all = operator === '?&';
-    keys = asArray(keys);
+    keys = (0, objectUtils_1.asArray)(keys);
     for (const key of keys) {
-        if (!isString(key)) {
+        if (!(0, objectUtils_1.isString)(key)) {
             throw new Error('All keys to find must be strings.');
         }
     }
@@ -109,7 +110,7 @@ function whereJsonHas(fieldExpression, operator, keys, knex = null) {
     }
     const paths = {
         sql: keys.map(() => '?').join(', '),
-        bindings: keys.map((key) => toMySqlJsonPath([{ type: 'object', ref: key }])),
+        bindings: keys.map((key) => (0, mysqlJsonPath_1.toMySqlJsonPath)([{ type: 'object', ref: key }])),
     };
     const keysJson = jsonValue(keys);
     const stringChecks = keys.map((key) => ({
@@ -125,7 +126,7 @@ function whereJsonHas(fieldExpression, operator, keys, knex = null) {
     if (all) {
         arrayCheck = sql `JSON_CONTAINS(${left}, ${keysJson})`;
     }
-    else if (knex && isMariaDb(knex)) {
+    else if (knex && (0, knexUtils_1.isMariaDb)(knex)) {
         // MariaDB has JSON_OVERLAPS() only since 10.9.
         const containsChecks = keys.map((key) => ({
             sql: `JSON_CONTAINS(${left.sql}, ?)`,
@@ -147,9 +148,3 @@ function whereJsonOverlaps(fieldExpression, jsonObjectOrFieldExpression, prefix)
     const overlaps = sql `JSON_OVERLAPS(${field(fieldExpression)}, ${fieldOrValue(jsonObjectOrFieldExpression)})`;
     return toRawArgs(prefix === 'not' ? sql `NOT COALESCE(${overlaps}, FALSE)` : overlaps);
 }
-module.exports = {
-    whereJsonContains,
-    whereJsonNotContains,
-    whereJsonHas,
-    whereJsonOverlaps,
-};

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

@@ -1,7 +1,46 @@
-'use strict';
-const parser = require('../../../utils/parseFieldExpression');
-const { asArray, isObject, isString } = require('../../../utils/objectUtils');
-const { toPgJsonPathLiteral, toPgQuotedColumn } = require('../../../utils/postgresJsonPath');
+"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.parseFieldExpression = parseFieldExpression;
+exports.whereJsonbRefOnLeftJsonbValOrRefOnRight = whereJsonbRefOnLeftJsonbValOrRefOnRight;
+exports.whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams = whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams;
+exports.whereJsonFieldRightStringArrayOnLeftQuery = whereJsonFieldRightStringArrayOnLeftQuery;
+exports.whereJsonFieldQuery = whereJsonFieldQuery;
+const parser = __importStar(require("../../../utils/parseFieldExpression"));
+const objectUtils_1 = require("../../../utils/objectUtils");
+const postgresJsonPath_1 = require("../../../utils/postgresJsonPath");
 /**
  * @typedef {String} FieldExpression
  *
@@ -43,7 +82,7 @@ const { toPgJsonPathLiteral, toPgQuotedColumn } = require('../../../utils/postgr
 function parseFieldExpression(expression, extractAsText) {
     const parsed = parser.parseFieldExpression(expression);
     const extractor = extractAsText ? '#>>' : '#>';
-    return `${toPgQuotedColumn(parsed.columnName)}${extractor}${toPgJsonPathLiteral(parsed.access)}`;
+    return `${(0, postgresJsonPath_1.toPgQuotedColumn)(parsed.columnName)}${extractor}${(0, postgresJsonPath_1.toPgJsonPathLiteral)(parsed.access)}`;
 }
 function whereJsonbRefOnLeftJsonbValOrRefOnRight(builder, fieldExpression, operator, jsonObjectOrFieldExpression, queryPrefix) {
     const queryParams = whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams(fieldExpression, operator, jsonObjectOrFieldExpression, queryPrefix);
@@ -51,7 +90,7 @@ function whereJsonbRefOnLeftJsonbValOrRefOnRight(builder, fieldExpression, opera
 }
 function whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams(fieldExpression, operator, jsonObjectOrFieldExpression, queryPrefix) {
     const fieldReference = parseFieldExpression(fieldExpression);
-    if (isString(jsonObjectOrFieldExpression)) {
+    if ((0, objectUtils_1.isString)(jsonObjectOrFieldExpression)) {
         const rightHandReference = parseFieldExpression(jsonObjectOrFieldExpression);
         const refRefQuery = [
             '(',
@@ -67,7 +106,7 @@ function whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams(fieldExpression,
         }
         return [refRefQuery.join(' ')];
     }
-    else if (isObject(jsonObjectOrFieldExpression)) {
+    else if ((0, objectUtils_1.isObject)(jsonObjectOrFieldExpression)) {
         const refValQuery = ['(', fieldReference, ')::jsonb', operator, '?::jsonb'];
         if (queryPrefix) {
             refValQuery.unshift(queryPrefix);
@@ -76,11 +115,13 @@ function whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams(fieldExpression,
     }
     throw new Error('Invalid right hand expression.');
 }
-function whereJsonFieldRightStringArrayOnLeftQuery(knex, fieldExpression, operator, keys) {
+function whereJsonFieldRightStringArrayOnLeftQuery(knex, fieldExpression, operator, 
+// A key or an array of keys, made an array below.
+keys) {
     const fieldReference = parseFieldExpression(fieldExpression);
-    keys = asArray(keys);
+    keys = (0, objectUtils_1.asArray)(keys);
     const questionMarksArray = keys.map((key) => {
-        if (!isString(key)) {
+        if (!(0, objectUtils_1.isString)(key)) {
             throw new Error('All keys to find must be strings.');
         }
         return '?';
@@ -126,10 +167,3 @@ function normalizeOperator(knex, operator) {
             throw new Error(`unsupported operator "${operator}" in a JSON field query`);
     }
 }
-module.exports = {
-    parseFieldExpression: parseFieldExpression,
-    whereJsonbRefOnLeftJsonbValOrRefOnRight: whereJsonbRefOnLeftJsonbValOrRefOnRight,
-    whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams: whereJsonbRefOnLeftJsonbValOrRefOnRightRawQueryParams,
-    whereJsonFieldRightStringArrayOnLeftQuery: whereJsonFieldRightStringArrayOnLeftQuery,
-    whereJsonFieldQuery: whereJsonFieldQuery,
-};

package/lib/queryBuilder/operations/select/SelectOperation.js

@@ -1,15 +1,17 @@
-'use strict';
-const { flatten } = require('../../../utils/objectUtils');
-const { Selection } = require('./Selection');
-const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectOperation = void 0;
+const objectUtils_1 = require("../../../utils/objectUtils");
+const Selection_1 = require("./Selection");
+const ObjectionToKnexConvertingOperation_1 = require("../ObjectionToKnexConvertingOperation");
 const COUNT_REGEX = /count/i;
-class SelectOperation extends ObjectionToKnexConvertingOperation {
+class SelectOperation extends ObjectionToKnexConvertingOperation_1.ObjectionToKnexConvertingOperation {
     constructor(name, opt) {
         super(name, opt);
         this.selections = [];
     }
     onAdd(builder, args) {
-        const selections = flatten(args);
+        const selections = (0, objectUtils_1.flatten)(args);
         // Don't add an empty selection. Empty list is accepted for `count`, `countDistinct`
         // etc. because knex apparently supports it.
         if (selections.length === 0 && !COUNT_REGEX.test(this.name)) {
@@ -17,7 +19,7 @@ class SelectOperation extends ObjectionToKnexConvertingOperation {
         }
         const ret = super.onAdd(builder, selections);
         for (const selection of selections) {
-            const selectionInstance = Selection.create(selection);
+            const selectionInstance = Selection_1.Selection.create(selection);
             if (selectionInstance) {
                 this.selections.push(selectionInstance);
             }
@@ -28,12 +30,12 @@ class SelectOperation extends ObjectionToKnexConvertingOperation {
         return knexBuilder[this.name].apply(knexBuilder, this.getKnexArgs(builder));
     }
     findSelection(builder, selectionToFind) {
-        const selectionInstanceToFind = Selection.create(selectionToFind);
+        const selectionInstanceToFind = Selection_1.Selection.create(selectionToFind);
         if (!selectionInstanceToFind) {
             return null;
         }
         for (const selection of this.selections) {
-            if (Selection.doesSelect(builder, selection, selectionInstanceToFind)) {
+            if (Selection_1.Selection.doesSelect(builder, selection, selectionInstanceToFind)) {
                 return selection;
             }
         }
@@ -45,6 +47,4 @@ class SelectOperation extends ObjectionToKnexConvertingOperation {
         return clone;
     }
 }
-module.exports = {
-    SelectOperation,
-};
+exports.SelectOperation = SelectOperation;

package/lib/queryBuilder/operations/select/Selection.js

@@ -1,5 +1,7 @@
-'use strict';
-const { isString, isObject } = require('../../../utils/objectUtils');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Selection = void 0;
+const objectUtils_1 = require("../../../utils/objectUtils");
 const ALIAS_REGEX = /\s+as\s+/i;
 class Selection {
     constructor(table, column, alias) {
@@ -11,21 +13,22 @@ class Selection {
         return this.alias || this.column;
     }
     static create(selection) {
-        if (isObject(selection)) {
-            if (selection.isObjectionSelection) {
+        if ((0, objectUtils_1.isObject)(selection)) {
+            const obj = selection;
+            if (obj.isObjectionSelection) {
                 return selection;
             }
-            else if (selection.isObjectionReferenceBuilder) {
+            else if (obj.isObjectionReferenceBuilder) {
                 return createSelectionFromReference(selection);
             }
-            else if (selection.isObjectionRawBuilder) {
+            else if (obj.isObjectionRawBuilder) {
                 return createSelectionFromRaw(selection);
             }
             else {
                 return null;
             }
         }
-        else if (isString(selection)) {
+        else if ((0, objectUtils_1.isString)(selection)) {
             return createSelectionFromString(selection);
         }
         else {
@@ -45,13 +48,16 @@ class Selection {
     static doesSelect(builder, selectionInBuilder, selectionToTest) {
         selectionInBuilder = Selection.create(selectionInBuilder);
         selectionToTest = Selection.create(selectionToTest);
-        if (selectionInBuilder.column === '*') {
-            if (selectionInBuilder.table) {
-                if (selectionToTest.column === '*') {
-                    return selectionToTest.table === selectionInBuilder.table;
+        // Both must be selections. Others throw here.
+        const inBuilder = selectionInBuilder;
+        const toTest = selectionToTest;
+        if (inBuilder.column === '*') {
+            if (inBuilder.table) {
+                if (toTest.column === '*') {
+                    return toTest.table === inBuilder.table;
                 }
                 else {
-                    return (selectionToTest.table === null || selectionToTest.table === selectionInBuilder.table);
+                    return toTest.table === null || toTest.table === inBuilder.table;
                 }
             }
             else {
@@ -59,17 +65,18 @@ class Selection {
             }
         }
         else {
-            const selectionInBuilderTable = selectionInBuilder.table || builder.tableRef();
-            if (selectionToTest.column === '*') {
+            const selectionInBuilderTable = inBuilder.table || builder.tableRef();
+            if (toTest.column === '*') {
                 return false;
             }
             else {
-                return (selectionToTest.column === selectionInBuilder.column &&
-                    (selectionToTest.table === null || selectionToTest.table === selectionInBuilderTable));
+                return (toTest.column === inBuilder.column &&
+                    (toTest.table === null || toTest.table === selectionInBuilderTable));
             }
         }
     }
 }
+exports.Selection = Selection;
 Object.defineProperties(Selection.prototype, {
     isObjectionSelection: {
         enumerable: false,
@@ -107,6 +114,3 @@ function createSelectionFromString(selection) {
     }
     return new Selection(table, column, alias);
 }
-module.exports = {
-    Selection,
-};

package/lib/queryBuilder/operations/types.js

@@ -0,0 +1,8 @@
+"use strict";
+// Internal types for the query builder operations.
+//
+// The model classes are still JavaScript, so these interfaces only describe
+// the parts of them that the operations use. The query builder and the
+// relations are TypeScript, and their types are used here. The public types
+// are the hand-written ones in `typings/`.
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/queryBuilder/operations/whereInComposite/WhereInCompositeMsSqlOperation.js

@@ -1,8 +1,10 @@
-'use strict';
-const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
-const { flatten, zipObject, isString } = require('../../../utils/objectUtils');
-const { getTempColumn } = require('../../../utils/tmpColumnUtils');
-class WhereInCompositeMsSqlOperation extends ObjectionToKnexConvertingOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhereInCompositeMsSqlOperation = void 0;
+const ObjectionToKnexConvertingOperation_1 = require("../ObjectionToKnexConvertingOperation");
+const objectUtils_1 = require("../../../utils/objectUtils");
+const tmpColumnUtils_1 = require("../../../utils/tmpColumnUtils");
+class WhereInCompositeMsSqlOperation extends ObjectionToKnexConvertingOperation_1.ObjectionToKnexConvertingOperation {
     constructor(name, opt) {
         super(name, opt);
         this.prefix = this.opt.prefix || null;
@@ -21,21 +23,22 @@ class WhereInCompositeMsSqlOperation extends ObjectionToKnexConvertingOperation
         }
     }
     buildComposite(knex, knexBuilder, columns, values) {
-        const helperColumns = columns.map((_, index) => getTempColumn(index));
+        const helperColumns = columns.map((_, index) => (0, tmpColumnUtils_1.getTempColumn)(index));
         if (Array.isArray(values)) {
             return this.buildCompositeValue(knex, knexBuilder, columns, helperColumns, values);
         }
         else {
+            // A subquery.
             return this.buildCompositeSubquery(knex, knexBuilder, columns, helperColumns, values.as(knex.raw(`V(${helperColumns.map((_) => '??')})`, helperColumns)));
         }
     }
     buildCompositeValue(knex, knexBuilder, columns, helperColumns, values) {
         return this.buildCompositeSubquery(knex, knexBuilder, columns, helperColumns, knex.raw(`(VALUES ${values
             .map((value) => `(${value.map((_) => '?').join(',')})`)
-            .join(',')}) AS V(${helperColumns.map((_) => '??').join(',')})`, flatten(values).concat(helperColumns)));
+            .join(',')}) AS V(${helperColumns.map((_) => '??').join(',')})`, (0, objectUtils_1.flatten)(values).concat(helperColumns)));
     }
     buildCompositeSubquery(knex, knexBuilder, columns, helperColumns, subQuery) {
-        const wrapperQuery = knex.from(subQuery).where(zipObject(helperColumns, columns.map((column) => knex.raw('??', column))));
+        const wrapperQuery = knex.from(subQuery).where((0, objectUtils_1.zipObject)(helperColumns, columns.map((column) => knex.raw('??', column))));
         if (this.prefix === 'not') {
             return knexBuilder.whereNotExists(wrapperQuery);
         }
@@ -44,7 +47,7 @@ class WhereInCompositeMsSqlOperation extends ObjectionToKnexConvertingOperation
         }
     }
     buildNonComposite(knexBuilder, columns, values) {
-        const col = isString(columns) ? columns : columns[0];
+        const col = (0, objectUtils_1.isString)(columns) ? columns : columns[0];
         if (Array.isArray(values)) {
             values = pickNonNull(values, []);
         }
@@ -67,6 +70,7 @@ class WhereInCompositeMsSqlOperation extends ObjectionToKnexConvertingOperation
         return clone;
     }
 }
+exports.WhereInCompositeMsSqlOperation = WhereInCompositeMsSqlOperation;
 function pickNonNull(values, output) {
     for (let i = 0, l = values.length; i < l; ++i) {
         const val = values[i];
@@ -79,6 +83,3 @@ function pickNonNull(values, output) {
     }
     return output;
 }
-module.exports = {
-    WhereInCompositeMsSqlOperation,
-};

package/lib/queryBuilder/operations/whereInComposite/WhereInCompositeOperation.js

@@ -1,8 +1,10 @@
-'use strict';
-const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
-const { isObject, asSingle } = require('../../../utils/objectUtils');
-const { isKnexQueryBuilder } = require('../../../utils/knexUtils');
-class WhereInCompositeOperation extends ObjectionToKnexConvertingOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhereInCompositeOperation = void 0;
+const ObjectionToKnexConvertingOperation_1 = require("../ObjectionToKnexConvertingOperation");
+const objectUtils_1 = require("../../../utils/objectUtils");
+const knexUtils_1 = require("../../../utils/knexUtils");
+class WhereInCompositeOperation extends ObjectionToKnexConvertingOperation_1.ObjectionToKnexConvertingOperation {
     constructor(name, opt) {
         super(name, opt);
         this.prefix = this.opt.prefix || null;
@@ -22,6 +24,7 @@ class WhereInCompositeOperation extends ObjectionToKnexConvertingOperation {
         return clone;
     }
 }
+exports.WhereInCompositeOperation = WhereInCompositeOperation;
 function buildWhereInArgs(knex, columns, values) {
     if (isCompositeKey(columns)) {
         return buildCompositeArgs(knex, columns, values);
@@ -54,7 +57,7 @@ function buildCompositeSubqueryArgs(knex, columns, subquery) {
         .map((col) => {
         // On older versions of knex, raw doesn't work
         // with `??`. We use `?` for those.
-        if (isObject(col)) {
+        if ((0, objectUtils_1.isObject)(col)) {
             return '?';
         }
         else {
@@ -68,10 +71,10 @@ function buildNonCompositeArgs(columns, values) {
     if (Array.isArray(values)) {
         values = pickNonNull(values, []);
     }
-    else if (!isKnexQueryBuilder(values)) {
+    else if (!(0, knexUtils_1.isKnexQueryBuilder)(values)) {
         values = [values];
     }
-    return [asSingle(columns), values];
+    return [(0, objectUtils_1.asSingle)(columns), values];
 }
 function pickNonNull(values, output) {
     for (let i = 0, l = values.length; i < l; ++i) {
@@ -85,6 +88,3 @@ function pickNonNull(values, output) {
     }
     return output;
 }
-module.exports = {
-    WhereInCompositeOperation,
-};

package/lib/queryBuilder/operations/whereInComposite/WhereInCompositeSqliteOperation.js

@@ -1,8 +1,10 @@
-'use strict';
-const { ObjectionToKnexConvertingOperation } = require('../ObjectionToKnexConvertingOperation');
-const { isKnexQueryBuilder } = require('../../../utils/knexUtils');
-const { asSingle } = require('../../../utils/objectUtils');
-class WhereInCompositeSqliteOperation extends ObjectionToKnexConvertingOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhereInCompositeSqliteOperation = void 0;
+const ObjectionToKnexConvertingOperation_1 = require("../ObjectionToKnexConvertingOperation");
+const knexUtils_1 = require("../../../utils/knexUtils");
+const objectUtils_1 = require("../../../utils/objectUtils");
+class WhereInCompositeSqliteOperation extends ObjectionToKnexConvertingOperation_1.ObjectionToKnexConvertingOperation {
     constructor(name, opt) {
         super(name, opt);
         this.prefix = this.opt.prefix || null;
@@ -32,6 +34,7 @@ class WhereInCompositeSqliteOperation extends ObjectionToKnexConvertingOperation
         return clone;
     }
 }
+exports.WhereInCompositeSqliteOperation = WhereInCompositeSqliteOperation;
 function buildWhereArgs(columns, values) {
     if (isCompositeKey(columns)) {
         return buildCompositeArgs(columns, values);
@@ -70,12 +73,12 @@ function buildNonCompositeArgs(columns, values) {
     if (Array.isArray(values)) {
         values = pickNonNull(values, []);
     }
-    else if (!isKnexQueryBuilder(values)) {
+    else if (!(0, knexUtils_1.isKnexQueryBuilder)(values)) {
         values = [values];
     }
     return {
         method: 'whereIn',
-        args: [asSingle(columns), values],
+        args: [(0, objectUtils_1.asSingle)(columns), values],
     };
 }
 function pickNonNull(values, output) {
@@ -90,6 +93,3 @@ function pickNonNull(values, output) {
     }
     return output;
 }
-module.exports = {
-    WhereInCompositeSqliteOperation,
-};

package/lib/queryBuilder/transformations/CompositeQueryTransformation.js

@@ -1,6 +1,8 @@
-'use strict';
-const { QueryTransformation } = require('./QueryTransformation');
-class CompositeQueryTransformation extends QueryTransformation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeQueryTransformation = void 0;
+const QueryTransformation_1 = require("./QueryTransformation");
+class CompositeQueryTransformation extends QueryTransformation_1.QueryTransformation {
     constructor(transformations) {
         super();
         this.transformations = transformations;
@@ -12,6 +14,4 @@ class CompositeQueryTransformation extends QueryTransformation {
         return item;
     }
 }
-module.exports = {
-    CompositeQueryTransformation,
-};
+exports.CompositeQueryTransformation = CompositeQueryTransformation;

package/lib/queryBuilder/transformations/QueryTransformation.js

@@ -1,9 +1,9 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryTransformation = void 0;
 class QueryTransformation {
     onConvertQueryBuilderBase(item, builder) {
         return item;
     }
 }
-module.exports = {
-    QueryTransformation,
-};
+exports.QueryTransformation = QueryTransformation;