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

package/lib/queryBuilder/transformations/WrapMysqlModifySubqueryTransformation.js

@@ -1,6 +1,8 @@
-'use strict';
-const { QueryTransformation } = require('./QueryTransformation');
-const { isMySql } = require('../../utils/knexUtils');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrapMysqlModifySubqueryTransformation = void 0;
+const QueryTransformation_1 = require("./QueryTransformation");
+const knexUtils_1 = require("../../utils/knexUtils");
 /**
  * Mysql doesn't allow queries like this:
  *
@@ -13,7 +15,8 @@ const { isMySql } = require('../../utils/knexUtils');
  *
  *   update foo set bar = 1 where id in (select * from (select id from foo))
  */
-class WrapMysqlModifySubqueryTransformation extends QueryTransformation {
+class WrapMysqlModifySubqueryTransformation extends QueryTransformation_1.QueryTransformation {
+    // In a join callback `parentQuery` is a `JoinBuilder`, which the loop below walks past.
     onConvertQueryBuilderBase(query, parentQuery) {
         const knex = parentQuery.unsafeKnex();
         // Cannot detect anything if, for whatever reason, a knex instance
@@ -22,11 +25,12 @@ class WrapMysqlModifySubqueryTransformation extends QueryTransformation {
             return query;
         }
         // This transformation only applies to MySQL.
-        if (!isMySql(knex)) {
+        if (!(0, knexUtils_1.isMySql)(knex)) {
             return query;
         }
         // A subquery in a join callback belongs to the query of the join.
         while (parentQuery && typeof parentQuery.isUpdate !== 'function') {
+            // The loop stops at the first parent query that is a `QueryBuilder`.
             parentQuery = parentQuery.parentQuery();
         }
         // This transformation only applies to update and delete queries.
@@ -42,9 +46,11 @@ class WrapMysqlModifySubqueryTransformation extends QueryTransformation {
         return query.modelClass().query().from(query.as('mysql_subquery_fix'));
     }
 }
+exports.WrapMysqlModifySubqueryTransformation = WrapMysqlModifySubqueryTransformation;
 function hasJoinsToTable(query, tableName) {
     let found = false;
     query.forEachOperation(query.constructor.JoinSelector, (op) => {
+        // The join operations are `KnexOperation`s, which have `args`.
         if (op.args[0] === tableName) {
             found = true;
             return false;
@@ -52,6 +58,3 @@ function hasJoinsToTable(query, tableName) {
     });
     return found;
 }
-module.exports = {
-    WrapMysqlModifySubqueryTransformation,
-};

package/lib/queryBuilder/transformations/index.js

@@ -1,9 +1,9 @@
-'use strict';
-const { CompositeQueryTransformation } = require('./CompositeQueryTransformation');
-const { WrapMysqlModifySubqueryTransformation, } = require('./WrapMysqlModifySubqueryTransformation');
-const transformation = new CompositeQueryTransformation([
-    new WrapMysqlModifySubqueryTransformation(),
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformation = void 0;
+const CompositeQueryTransformation_1 = require("./CompositeQueryTransformation");
+const WrapMysqlModifySubqueryTransformation_1 = require("./WrapMysqlModifySubqueryTransformation");
+const transformation = new CompositeQueryTransformation_1.CompositeQueryTransformation([
+    new WrapMysqlModifySubqueryTransformation_1.WrapMysqlModifySubqueryTransformation(),
 ]);
-module.exports = {
-    transformation,
-};
+exports.transformation = transformation;

package/lib/queryBuilder/whereScopes.js

@@ -1,15 +1,10 @@
-'use strict';
-const { isObject, isFunction } = require('../utils/objectUtils');
-const { isKnexRaw } = require('../utils/knexUtils');
-// Where clauses objection adds on its own, like the owner condition of a relation
-// query or the id condition of `$query()`, are tagged with a "where scope". When
-// a query has where clauses from more than one scope, the clauses of each scope
-// are wrapped in parentheses so that an `orWhere` in one scope can't escape the
-// conditions of the others. Without this, `$relatedQuery('pets').where(a).orWhere(b)`
-// would produce `owner and a or b` and match other owners' pets.
-//
-// The scopes are only used when the knex query is built. The operation tree is
-// never modified.
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withWhereScope = withWhereScope;
+exports.effectiveWhereScope = effectiveWhereScope;
+exports.createWhereGrouping = createWhereGrouping;
+const objectUtils_1 = require("../utils/objectUtils");
+const knexUtils_1 = require("../utils/knexUtils");
 const WhereSelector = /^(where|orWhere|andWhere|find\w+)/;
 // Where operations that only ever produce a single predicate or predicates
 // joined with `and`. A scope that only contains these (and no raw arguments)
@@ -63,6 +58,7 @@ function withWhereScope(builder, callback) {
         builder._whereScope = previous;
     }
 }
+// Returns the where scope token, or null.
 function effectiveWhereScope(op) {
     while (op) {
         if (op.whereScope !== null) {
@@ -139,6 +135,7 @@ function buildOperationTree(builder, op, knexBuilder) {
 }
 function hasWhereAncestor(op) {
     for (let parent = op.parentOperation; parent; parent = parent.parentOperation) {
+        // A null name is tested as 'null', as `test()` converts it to a string.
         if (WhereSelector.test(parent.name)) {
             return true;
         }
@@ -159,13 +156,15 @@ function isAndOnlyTree(op) {
     return andOnly;
 }
 function isAndOnly(op) {
-    return AND_ONLY_OPERATIONS.has(op.name) && !containsRaw(op.args);
+    // The operations that convert their arguments for knex have `args`.
+    return (AND_ONLY_OPERATIONS.has(op.name) && !containsRaw(op.args));
 }
+// `value` is a user value of any shape: operation arguments.
 function containsRaw(value) {
     if (Array.isArray(value)) {
         return value.some(containsRaw);
     }
-    else if (!isObject(value)) {
+    else if (!(0, objectUtils_1.isObject)(value)) {
         return false;
     }
     else if (value.isObjectionReferenceBuilder) {
@@ -177,11 +176,11 @@ function containsRaw(value) {
         // so only their arguments can contain anything.
         return containsRaw(value._args);
     }
-    else if (isKnexRaw(value) || isFunction(value.toKnexRaw)) {
+    else if ((0, knexUtils_1.isKnexRaw)(value) || (0, objectUtils_1.isFunction)(value.toKnexRaw)) {
         // Raw sql (and anything that is converted into it) can contain anything.
         return true;
     }
-    else if (value.isObjectionQueryBuilderBase || isFunction(value.toSQL)) {
+    else if (value.isObjectionQueryBuilderBase || (0, objectUtils_1.isFunction)(value.toSQL)) {
         // Subqueries are always wrapped in parentheses.
         return false;
     }
@@ -192,8 +191,3 @@ function containsRaw(value) {
         return false;
     }
 }
-module.exports = {
-    withWhereScope,
-    effectiveWhereScope,
-    createWhereGrouping,
-};

package/lib/relations/RelationDeleteOperation.js

@@ -5,7 +5,6 @@ const DeleteOperation_1 = require("../queryBuilder/operations/DeleteOperation");
 const RelationFindOperation_1 = require("./RelationFindOperation");
 class RelationDeleteOperation extends DeleteOperation_1.DeleteOperation {
     constructor(name, opt) {
-        // @ts-expect-error The JavaScript QueryBuilderOperation's `name` is inferred as null.
         super(name, opt);
         this.relation = opt.relation;
         this.owner = opt.owner;
@@ -14,7 +13,6 @@ class RelationDeleteOperation extends DeleteOperation_1.DeleteOperation {
         super.onBuild(builder);
         this.relation.findQuery(builder, this.owner);
     }
-    // @ts-expect-error The JavaScript base class's toFindOperation() is inferred to return null.
     toFindOperation() {
         return new RelationFindOperation_1.RelationFindOperation('find', {
             relation: this.relation,

package/lib/relations/RelationFindOperation.js

@@ -4,7 +4,6 @@ exports.RelationFindOperation = void 0;
 const FindOperation_1 = require("../queryBuilder/operations/FindOperation");
 class RelationFindOperation extends FindOperation_1.FindOperation {
     constructor(name, opt) {
-        // @ts-expect-error The JavaScript QueryBuilderOperation's `name` is inferred as null.
         super(name, opt);
         this.relation = opt.relation;
         this.owner = opt.owner;

package/lib/relations/RelationUpdateOperation.js

@@ -13,7 +13,6 @@ class RelationUpdateOperation extends UpdateOperation_1.UpdateOperation {
         super.onBuild(builder);
         this.relation.findQuery(builder, this.owner);
     }
-    // @ts-expect-error The JavaScript base class's toFindOperation() is inferred to return null.
     toFindOperation() {
         return new RelationFindOperation_1.RelationFindOperation('find', {
             relation: this.relation,

package/lib/relations/manyToMany/delete/ManyToManyDeleteOperationBase.js

@@ -4,7 +4,6 @@ exports.ManyToManyDeleteOperationBase = void 0;
 const DeleteOperation_1 = require("../../../queryBuilder/operations/DeleteOperation");
 class ManyToManyDeleteOperationBase extends DeleteOperation_1.DeleteOperation {
     constructor(name, opt) {
-        // @ts-expect-error The JavaScript QueryBuilderOperation's `name` is inferred as null.
         super(name, opt);
         this.relation = opt.relation;
         this.owner = opt.owner;

package/lib/transaction.js

@@ -1,13 +1,48 @@
-'use strict';
-const promiseUtils = require('./utils/promiseUtils');
-const { isFunction } = require('./utils/objectUtils');
-function transaction() {
+"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.transaction = transaction;
+const promiseUtils = __importStar(require("./utils/promiseUtils"));
+const objectUtils_1 = require("./utils/objectUtils");
+function transaction(...transactionArgs) {
     // There must be at least one model class and the callback.
-    if (arguments.length < 2) {
+    if (transactionArgs.length < 2) {
         return Promise.reject(new Error('objection.transaction: provide at least one Model class to bind to the transaction or a knex instance'));
     }
-    let args = Array.from(arguments);
-    if (!isModelClass(args[0]) && isFunction(args[0].transaction)) {
+    let args = Array.from(transactionArgs);
+    if (!isModelClass(args[0]) && (0, objectUtils_1.isFunction)(args[0].transaction)) {
         const knex = args[0];
         args = args.slice(1);
         return knex.transaction.apply(knex, args);
@@ -45,7 +80,7 @@ transaction.start = function (modelClassOrKnex) {
     if (isModelClass(modelClassOrKnex)) {
         knex = modelClassOrKnex.knex();
     }
-    if (!knex || !isFunction(knex.transaction)) {
+    if (!knex || !(0, objectUtils_1.isFunction)(knex.transaction)) {
         return Promise.reject(new Error('objection.transaction.start: first argument must be a model class or a knex instance'));
     }
     return new Promise((resolve, reject) => {
@@ -59,8 +94,5 @@ transaction.start = function (modelClassOrKnex) {
     });
 };
 function isModelClass(maybeModel) {
-    return isFunction(maybeModel) && maybeModel.isObjectionModelClass;
+    return (0, objectUtils_1.isFunction)(maybeModel) && maybeModel.isObjectionModelClass;
 }
-module.exports = {
-    transaction,
-};

package/lib/utils/objectUtils.js

@@ -25,7 +25,12 @@ exports.last = last;
 exports.get = get;
 exports.set = set;
 const cloneDeep_1 = require("./cloneDeep");
-Object.defineProperty(exports, "cloneDeep", { enumerable: true, get: function () { return cloneDeep_1.cloneDeep; } });
+// Re-exporting an imported binding makes tsc define the export as a getter,
+// which puts this module's whole exports object in V8's slow dictionary mode
+// and makes every `objectUtils.x()` call several times slower. A local
+// constant is exported as a plain property instead.
+const cloneDeep = cloneDeep_1.cloneDeep;
+exports.cloneDeep = cloneDeep;
 const SMALL_ARRAY_SIZE = 10;
 function isEmpty(item) {
     if (Array.isArray(item) || Buffer.isBuffer(item)) {

package/lib/utils/parseFieldExpression.js

@@ -1,40 +1,9 @@
 "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;
-const jsonFieldExpressionParser = __importStar(require("../queryBuilder/parsers/jsonFieldExpressionParser"));
+// A named import: `import * as` of a JavaScript module wraps it in an object
+// of getters (tsc's __importStar), which is slow to call through.
+const jsonFieldExpressionParser_1 = require("../queryBuilder/parsers/jsonFieldExpressionParser");
 const cache = new Map();
 function parseFieldExpression(expr) {
     let parsedExpr = cache.get(expr);
@@ -42,7 +11,7 @@ function parseFieldExpression(expr) {
         return parsedExpr;
     }
     else {
-        const parserOutput = jsonFieldExpressionParser.parse(expr);
+        const parserOutput = (0, jsonFieldExpressionParser_1.parse)(expr);
         parsedExpr = preprocessParsedExpression(parserOutput);
         // We don't take a copy of the parsedExpr each time we
         // use if from cache. Instead to make sure it's never

package/lib/utils/promiseUtils/index.js

@@ -1,15 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.try = exports.map = exports.mapAfterAllReturn = exports.afterReturn = exports.after = exports.isPromise = void 0;
-const isPromise_1 = require("./isPromise");
-Object.defineProperty(exports, "isPromise", { enumerable: true, get: function () { return isPromise_1.isPromise; } });
+exports.try = exports.mapAfterAllReturn = exports.map = exports.isPromise = exports.afterReturn = exports.after = void 0;
 const after_1 = require("./after");
-Object.defineProperty(exports, "after", { enumerable: true, get: function () { return after_1.after; } });
 const afterReturn_1 = require("./afterReturn");
-Object.defineProperty(exports, "afterReturn", { enumerable: true, get: function () { return afterReturn_1.afterReturn; } });
-const mapAfterAllReturn_1 = require("./mapAfterAllReturn");
-Object.defineProperty(exports, "mapAfterAllReturn", { enumerable: true, get: function () { return mapAfterAllReturn_1.mapAfterAllReturn; } });
+const isPromise_1 = require("./isPromise");
 const map_1 = require("./map");
-Object.defineProperty(exports, "map", { enumerable: true, get: function () { return map_1.promiseMap; } });
+const mapAfterAllReturn_1 = require("./mapAfterAllReturn");
 const try_1 = require("./try");
-Object.defineProperty(exports, "try", { enumerable: true, get: function () { return try_1.promiseTry; } });
+// Re-exporting imported bindings makes tsc define the exports as getters,
+// which puts this module's exports object in V8's slow dictionary mode and
+// makes every call through it several times slower. Local constants are
+// exported as plain properties instead.
+const isPromise = isPromise_1.isPromise;
+exports.isPromise = isPromise;
+const after = after_1.after;
+exports.after = after;
+const afterReturn = afterReturn_1.afterReturn;
+exports.afterReturn = afterReturn;
+const mapAfterAllReturn = mapAfterAllReturn_1.mapAfterAllReturn;
+exports.mapAfterAllReturn = mapAfterAllReturn;
+const map = map_1.promiseMap;
+exports.map = map;
+const promiseTryExport = try_1.promiseTry;
+exports.try = promiseTryExport;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abedmurrar/objection",
-  "version": "4.0.0-beta.1",
+  "version": "4.0.0-beta.10",
   "description": "An SQL-friendly ORM for Node.js. A fork of objection.js with strict TypeScript types and MySQL support.",
   "main": "lib/objection.js",
   "type": "commonjs",