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

package/lib/queryBuilder/operations/DelegateOperation.js

@@ -1,8 +1,10 @@
-'use strict';
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegateOperation = void 0;
+const QueryBuilderOperation_1 = require("./QueryBuilderOperation");
 // Operation that simply delegates all calls to the operation passed
 // to to the constructor in `opt.delegate`.
-class DelegateOperation extends QueryBuilderOperation {
+class DelegateOperation extends QueryBuilderOperation_1.QueryBuilderOperation {
     constructor(name, opt) {
         super(name, opt);
         this.delegate = opt.delegate;
@@ -96,6 +98,4 @@ class DelegateOperation extends QueryBuilderOperation {
         return clone;
     }
 }
-module.exports = {
-    DelegateOperation,
-};
+exports.DelegateOperation = DelegateOperation;

package/lib/queryBuilder/operations/DeleteOperation.js

@@ -1,7 +1,9 @@
-'use strict';
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-const { StaticHookArguments, hasStaticHook } = require('../StaticHookArguments');
-class DeleteOperation extends QueryBuilderOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteOperation = void 0;
+const QueryBuilderOperation_1 = require("./QueryBuilderOperation");
+const StaticHookArguments_1 = require("../StaticHookArguments");
+class DeleteOperation extends QueryBuilderOperation_1.QueryBuilderOperation {
     async onBefore2(builder, result) {
         await callBeforeDelete(builder);
         return result;
@@ -16,24 +18,25 @@ class DeleteOperation extends QueryBuilderOperation {
         return null;
     }
 }
+exports.DeleteOperation = DeleteOperation;
 function callBeforeDelete(builder) {
     return callStaticBeforeDelete(builder);
 }
 function callStaticBeforeDelete(builder) {
-    if (!hasStaticHook(builder.modelClass(), 'beforeDelete')) {
+    if (!(0, StaticHookArguments_1.hasStaticHook)(builder.modelClass(), 'beforeDelete')) {
         return undefined;
     }
-    const args = StaticHookArguments.create({ builder });
+    const args = StaticHookArguments_1.StaticHookArguments.create({ builder });
     return builder.modelClass().beforeDelete(args);
 }
 function callAfterDelete(builder, result) {
     return callStaticAfterDelete(builder, result);
 }
 async function callStaticAfterDelete(builder, result) {
-    if (!hasStaticHook(builder.modelClass(), 'afterDelete')) {
+    if (!(0, StaticHookArguments_1.hasStaticHook)(builder.modelClass(), 'afterDelete')) {
         return result;
     }
-    const args = StaticHookArguments.create({ builder, result });
+    const args = StaticHookArguments_1.StaticHookArguments.create({ builder, result });
     const maybeResult = await builder.modelClass().afterDelete(args);
     if (maybeResult === undefined) {
         return result;
@@ -42,6 +45,3 @@ async function callStaticAfterDelete(builder, result) {
         return maybeResult;
     }
 }
-module.exports = {
-    DeleteOperation,
-};

package/lib/queryBuilder/operations/FindByIdOperation.js

@@ -1,7 +1,9 @@
-'use strict';
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-const { assertIdNotUndefined } = require('../../utils/assert');
-class FindByIdOperation extends QueryBuilderOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindByIdOperation = void 0;
+const QueryBuilderOperation_1 = require("./QueryBuilderOperation");
+const assert_1 = require("../../utils/assert");
+class FindByIdOperation extends QueryBuilderOperation_1.QueryBuilderOperation {
     constructor(name, opt) {
         super(name, opt);
         this.id = this.opt.id;
@@ -14,7 +16,7 @@ class FindByIdOperation extends QueryBuilderOperation {
     }
     onBuild(builder) {
         if (!builder.internalOptions().skipUndefined) {
-            assertIdNotUndefined(this.id, `undefined was passed to ${this.name}`);
+            (0, assert_1.assertIdNotUndefined)(this.id, `undefined was passed to ${this.name}`);
         }
         builder.whereComposite(builder.fullIdColumn(), this.id);
     }
@@ -24,6 +26,4 @@ class FindByIdOperation extends QueryBuilderOperation {
         return clone;
     }
 }
-module.exports = {
-    FindByIdOperation,
-};
+exports.FindByIdOperation = FindByIdOperation;

package/lib/queryBuilder/operations/FindByIdsOperation.js

@@ -1,6 +1,8 @@
-'use strict';
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-class FindByIdsOperation extends QueryBuilderOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindByIdsOperation = void 0;
+const QueryBuilderOperation_1 = require("./QueryBuilderOperation");
+class FindByIdsOperation extends QueryBuilderOperation_1.QueryBuilderOperation {
     constructor(name, opt) {
         super(name, opt);
         this.ids = null;
@@ -18,6 +20,4 @@ class FindByIdsOperation extends QueryBuilderOperation {
         return clone;
     }
 }
-module.exports = {
-    FindByIdsOperation,
-};
+exports.FindByIdsOperation = FindByIdsOperation;

package/lib/queryBuilder/operations/FindOperation.js

@@ -1,11 +1,13 @@
-'use strict';
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-const { StaticHookArguments, hasStaticHook } = require('../StaticHookArguments');
-const { isPromise, after, afterReturn } = require('../../utils/promiseUtils');
-const { isObject } = require('../../utils/objectUtils');
-class FindOperation extends QueryBuilderOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindOperation = void 0;
+const QueryBuilderOperation_1 = require("./QueryBuilderOperation");
+const StaticHookArguments_1 = require("../StaticHookArguments");
+const promiseUtils_1 = require("../../utils/promiseUtils");
+const objectUtils_1 = require("../../utils/objectUtils");
+class FindOperation extends QueryBuilderOperation_1.QueryBuilderOperation {
     onBefore2(builder, result) {
-        return afterReturn(callStaticBeforeFind(builder), result);
+        return (0, promiseUtils_1.afterReturn)(callStaticBeforeFind(builder), result);
     }
     onAfter3(builder, results) {
         const opt = builder.findOptions();
@@ -17,25 +19,26 @@ class FindOperation extends QueryBuilderOperation {
         }
     }
 }
+exports.FindOperation = FindOperation;
 function callStaticBeforeFind(builder) {
-    if (!hasStaticHook(builder.modelClass(), 'beforeFind')) {
+    if (!(0, StaticHookArguments_1.hasStaticHook)(builder.modelClass(), 'beforeFind')) {
         return undefined;
     }
-    const args = StaticHookArguments.create({ builder });
+    const args = StaticHookArguments_1.StaticHookArguments.create({ builder });
     return builder.modelClass().beforeFind(args);
 }
 function callAfterFind(builder, result) {
     const opt = builder.findOptions();
     const maybePromise = callInstanceAfterFind(builder.context(), result, opt.callAfterFindDeeply);
-    return after(maybePromise, () => callStaticAfterFind(builder, result));
+    return (0, promiseUtils_1.after)(maybePromise, () => callStaticAfterFind(builder, result));
 }
 function callStaticAfterFind(builder, result) {
-    if (!hasStaticHook(builder.modelClass(), 'afterFind')) {
+    if (!(0, StaticHookArguments_1.hasStaticHook)(builder.modelClass(), 'afterFind')) {
         return result;
     }
-    const args = StaticHookArguments.create({ builder, result });
+    const args = StaticHookArguments_1.StaticHookArguments.create({ builder, result });
     const maybePromise = builder.modelClass().afterFind(args);
-    return after(maybePromise, (maybeResult) => {
+    return (0, promiseUtils_1.after)(maybePromise, (maybeResult) => {
         if (maybeResult === undefined) {
             return result;
         }
@@ -58,14 +61,14 @@ function callInstanceAfterFind(ctx, results, deep) {
     }
 }
 function callAfterFindArray(ctx, results, deep) {
-    if (results.length === 0 || !isObject(results[0])) {
+    if (results.length === 0 || !(0, objectUtils_1.isObject)(results[0])) {
         return results;
     }
     const mapped = new Array(results.length);
     let containsPromise = false;
     for (let i = 0, l = results.length; i < l; ++i) {
         mapped[i] = callAfterFindForOne(ctx, results[i], results[i], deep);
-        if (isPromise(mapped[i])) {
+        if ((0, promiseUtils_1.isPromise)(mapped[i])) {
             containsPromise = true;
         }
     }
@@ -77,7 +80,7 @@ function callAfterFindArray(ctx, results, deep) {
     }
 }
 function callAfterFindForOne(ctx, model, result, deep) {
-    if (!isObject(model) || !model.$isObjectionModel) {
+    if (!(0, objectUtils_1.isObject)(model) || !model.$isObjectionModel) {
         return result;
     }
     if (deep) {
@@ -104,7 +107,7 @@ function callAfterFindForRelations(ctx, model, results) {
         const value = model[key];
         if (isRelation(value)) {
             const maybePromise = callInstanceAfterFind(ctx, value, true);
-            if (isPromise(maybePromise)) {
+            if ((0, promiseUtils_1.isPromise)(maybePromise)) {
                 containsPromise = true;
             }
             results.push(maybePromise);
@@ -113,17 +116,17 @@ function callAfterFindForRelations(ctx, model, results) {
     return containsPromise;
 }
 function isRelation(value) {
-    return ((isObject(value) && value.$isObjectionModel) ||
+    return (((0, objectUtils_1.isObject)(value) && value.$isObjectionModel) ||
         (isNonEmptyObjectArray(value) && value[0].$isObjectionModel));
 }
 function isNonEmptyObjectArray(value) {
-    return Array.isArray(value) && value.length > 0 && isObject(value[0]);
+    return Array.isArray(value) && value.length > 0 && (0, objectUtils_1.isObject)(value[0]);
 }
 function doCallAfterFind(ctx, model, result) {
     const afterFind = getAfterFindHook(model);
     if (afterFind !== null) {
         const maybePromise = afterFind.call(model, ctx);
-        if (isPromise(maybePromise)) {
+        if ((0, promiseUtils_1.isPromise)(maybePromise)) {
             return maybePromise.then(() => result);
         }
         else {
@@ -142,6 +145,3 @@ function getAfterFindHook(model) {
         return null;
     }
 }
-module.exports = {
-    FindOperation,
-};

package/lib/queryBuilder/operations/FirstOperation.js

@@ -1,6 +1,8 @@
-'use strict';
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-class FirstOperation extends QueryBuilderOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirstOperation = void 0;
+const QueryBuilderOperation_1 = require("./QueryBuilderOperation");
+class FirstOperation extends QueryBuilderOperation_1.QueryBuilderOperation {
     onBuildKnex(knexBuilder, builder) {
         const modelClass = builder.modelClass();
         if (builder.isFind() && modelClass.useLimitInFirst) {
@@ -17,6 +19,4 @@ class FirstOperation extends QueryBuilderOperation {
         }
     }
 }
-module.exports = {
-    FirstOperation,
-};
+exports.FirstOperation = FirstOperation;

package/lib/queryBuilder/operations/FromOperation.js

@@ -1,13 +1,15 @@
-'use strict';
-const { ObjectionToKnexConvertingOperation } = require('./ObjectionToKnexConvertingOperation');
-const { isPlainObject, isString } = require('../../utils/objectUtils');
-const { isModelClass } = require('../../utils/resolveModel');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FromOperation = void 0;
+const ObjectionToKnexConvertingOperation_1 = require("./ObjectionToKnexConvertingOperation");
+const objectUtils_1 = require("../../utils/objectUtils");
+const resolveModel_1 = require("../../utils/resolveModel");
 const ALIAS_REGEX = /\s+as\s+/i;
 // FromOperation corresponds to a `.from(args)` call. The call is delegated to
 // knex, but we first try to parse the arguments so that we can determine which
 // tables have been mentioned in a query's from clause. We only parse string
 // references and not `raw` or `ref` etc. references at this point thouhg.
-class FromOperation extends ObjectionToKnexConvertingOperation {
+class FromOperation extends ObjectionToKnexConvertingOperation_1.ObjectionToKnexConvertingOperation {
     constructor(name, opt) {
         super(name, opt);
         this.table = null;
@@ -37,14 +39,15 @@ class FromOperation extends ObjectionToKnexConvertingOperation {
         return clone;
     }
 }
+exports.FromOperation = FromOperation;
 function parseTableAndAlias(arg, builder) {
-    if (isModelClass(arg)) {
+    if ((0, resolveModel_1.isModelClass)(arg)) {
         return parseTableAndAliasFromString(arg.getTableName());
     }
-    else if (isString(arg)) {
+    else if ((0, objectUtils_1.isString)(arg)) {
         return parseTableAndAliasFromString(arg);
     }
-    else if (isPlainObject(arg)) {
+    else if ((0, objectUtils_1.isPlainObject)(arg)) {
         return parseTableAndAliasFromObject(arg, builder);
     }
     else {
@@ -72,8 +75,8 @@ function parseTableAndAliasFromString(arg) {
 }
 function parseTableAndAliasFromObject(arg, builder) {
     for (const alias of Object.keys(arg)) {
-        const value = isModelClass(arg[alias]) ? arg[alias].getTableName() : arg[alias];
-        if (!isString(value)) {
+        const value = (0, resolveModel_1.isModelClass)(arg[alias]) ? arg[alias].getTableName() : arg[alias];
+        if (!(0, objectUtils_1.isString)(value)) {
             continue;
         }
         const table = value.trim();
@@ -86,6 +89,3 @@ function parseTableAndAliasFromObject(arg, builder) {
     }
     throw new Error(`one of the tables in ${JSON.stringify(arg)} must be the query's model class's table.`);
 }
-module.exports = {
-    FromOperation,
-};

package/lib/queryBuilder/operations/InsertAndFetchOperation.js

@@ -1,12 +1,14 @@
-'use strict';
-const { InsertOperation } = require('./InsertOperation');
-const { DelegateOperation } = require('./DelegateOperation');
-const { keyByProps } = require('../../model/modelUtils');
-const { asArray } = require('../../utils/objectUtils');
-class InsertAndFetchOperation extends DelegateOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsertAndFetchOperation = void 0;
+const InsertOperation_1 = require("./InsertOperation");
+const DelegateOperation_1 = require("./DelegateOperation");
+const modelUtils_1 = require("../../model/modelUtils");
+const objectUtils_1 = require("../../utils/objectUtils");
+class InsertAndFetchOperation extends DelegateOperation_1.DelegateOperation {
     constructor(name, opt) {
         super(name, opt);
-        if (!this.delegate.is(InsertOperation)) {
+        if (!this.delegate.is(InsertOperation_1.InsertOperation)) {
             throw new Error('Invalid delegate');
         }
     }
@@ -16,7 +18,7 @@ class InsertAndFetchOperation extends DelegateOperation {
     async onAfter2(builder, inserted) {
         const modelClass = builder.modelClass();
         const insertedModels = await super.onAfter2(builder, inserted);
-        const insertedModelArray = asArray(insertedModels);
+        const insertedModelArray = (0, objectUtils_1.asArray)(insertedModels);
         const idProps = modelClass.getIdPropertyArray();
         const ids = insertedModelArray.map((model) => model.$id());
         const fetchedModels = await modelClass
@@ -24,7 +26,7 @@ class InsertAndFetchOperation extends DelegateOperation {
             .childQueryOf(builder)
             .findByIds(ids)
             .castTo(builder.resultModelClass());
-        const modelsById = keyByProps(fetchedModels, idProps);
+        const modelsById = (0, modelUtils_1.keyByProps)(fetchedModels, idProps);
         // Instead of returning the freshly fetched models, update the input
         // models with the fresh values.
         insertedModelArray.forEach((insertedModel) => {
@@ -33,6 +35,4 @@ class InsertAndFetchOperation extends DelegateOperation {
         return insertedModels;
     }
 }
-module.exports = {
-    InsertAndFetchOperation,
-};
+exports.InsertAndFetchOperation = InsertAndFetchOperation;

package/lib/queryBuilder/operations/InsertGraphAndFetchOperation.js

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

package/lib/queryBuilder/operations/InsertGraphOperation.js

@@ -1,14 +1,16 @@
-'use strict';
-const { DelegateOperation } = require('./DelegateOperation');
-const { InsertOperation } = require('./InsertOperation');
-const { GraphUpsert } = require('../graph/GraphUpsert');
-class InsertGraphOperation extends DelegateOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsertGraphOperation = void 0;
+const DelegateOperation_1 = require("./DelegateOperation");
+const InsertOperation_1 = require("./InsertOperation");
+const GraphUpsert_1 = require("../graph/GraphUpsert");
+class InsertGraphOperation extends DelegateOperation_1.DelegateOperation {
     constructor(name, opt = null) {
         super(name, opt);
-        if (!this.delegate.is(InsertOperation)) {
+        if (!this.delegate.is(InsertOperation_1.InsertOperation)) {
             throw new Error('Invalid delegate');
         }
-        Object.assign(this.delegate.modelOptions, GraphUpsert.modelOptions);
+        Object.assign(this.delegate.modelOptions, GraphUpsert_1.GraphUpsert.modelOptions);
         this.upsertOptions = opt.opt || {};
         this.upsert = null;
     }
@@ -23,7 +25,7 @@ class InsertGraphOperation extends DelegateOperation {
     }
     onAdd(builder, args) {
         const retVal = super.onAdd(builder, args);
-        this.upsert = new GraphUpsert({
+        this.upsert = new GraphUpsert_1.GraphUpsert({
             objects: this.models,
             rootModelClass: builder.modelClass(),
             upsertOptions: Object.assign({}, this.upsertOptions, {
@@ -82,6 +84,4 @@ class InsertGraphOperation extends DelegateOperation {
         return clone;
     }
 }
-module.exports = {
-    InsertGraphOperation,
-};
+exports.InsertGraphOperation = InsertGraphOperation;

package/lib/queryBuilder/operations/InsertOperation.js

@@ -1,15 +1,17 @@
-'use strict';
+"use strict";
 /* global BigInt */
-const { QueryBuilderOperation } = require('./QueryBuilderOperation');
-const { StaticHookArguments, hasStaticHook } = require('../StaticHookArguments');
-const { after, mapAfterAllReturn } = require('../../utils/promiseUtils');
-const { isSqlite, isMySql } = require('../../utils/knexUtils');
-const { isObject } = require('../../utils/objectUtils');
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsertOperation = void 0;
+const QueryBuilderOperation_1 = require("./QueryBuilderOperation");
+const StaticHookArguments_1 = require("../StaticHookArguments");
+const promiseUtils_1 = require("../../utils/promiseUtils");
+const knexUtils_1 = require("../../utils/knexUtils");
+const objectUtils_1 = require("../../utils/objectUtils");
 // `@@auto_increment_increment` for each MySQL knex instance, keyed by the knex config,
 // which transactions share with the knex they were started from.
 const autoIncrementIncrements = new WeakMap();
 // Base class for all insert operations.
-class InsertOperation extends QueryBuilderOperation {
+class InsertOperation extends QueryBuilderOperation_1.QueryBuilderOperation {
     constructor(name, opt) {
         super(name, opt);
         this.models = null;
@@ -26,7 +28,7 @@ class InsertOperation extends QueryBuilderOperation {
     }
     async onBefore2(builder, result) {
         await callBeforeInsert(builder, this.models);
-        if (this.models.length > 1 && isMySql(builder.knex())) {
+        if (this.models.length > 1 && (0, knexUtils_1.isMySql)(builder.knex())) {
             await this.prepareMySqlBatchInsert(builder);
         }
         return result;
@@ -57,7 +59,7 @@ class InsertOperation extends QueryBuilderOperation {
     }
     onBuildKnex(knexBuilder, builder) {
         const knex = builder.knex();
-        const returnsIds = !isMySql(knex) && (!isSqlite(knex) || this.models.length > 1);
+        const returnsIds = !(0, knexUtils_1.isMySql)(knex) && (!(0, knexUtils_1.isSqlite)(knex) || this.models.length > 1);
         if (returnsIds && !builder.has(/returning/)) {
             // If the user hasn't specified a `returning` clause, we make sure
             // that at least the identifier is returned. SQLite only returns the
@@ -66,6 +68,7 @@ class InsertOperation extends QueryBuilderOperation {
         }
         return knexBuilder.insert(this.models.map((model) => model.$toDatabaseJson(builder)));
     }
+    // The subclasses may be async.
     onAfter1(builder, ret) {
         if (!Array.isArray(ret) || !ret.length || ret === this.models) {
             // Early exit if there is nothing to do.
@@ -74,7 +77,7 @@ class InsertOperation extends QueryBuilderOperation {
         if (ret.length === 1 && this.models.length > 1) {
             this.setMySqlBatchInsertIds(builder, ret[0]);
         }
-        else if (isObject(ret[0])) {
+        else if ((0, objectUtils_1.isObject)(ret[0])) {
             // If the user specified a `returning` clause the result may be an array of objects.
             // Merge all values of the objects to our models.
             for (let i = 0, l = this.models.length; i < l; ++i) {
@@ -119,6 +122,7 @@ class InsertOperation extends QueryBuilderOperation {
         return clone;
     }
 }
+exports.InsertOperation = InsertOperation;
 // The id can be a string or a BigInt when the driver is configured to
 // return big numbers that way.
 function addToId(id, amount) {
@@ -134,32 +138,32 @@ function addToId(id, amount) {
 }
 function callBeforeInsert(builder, models) {
     const maybePromise = callInstanceBeforeInsert(builder, models);
-    return after(maybePromise, () => callStaticBeforeInsert(builder));
+    return (0, promiseUtils_1.after)(maybePromise, () => callStaticBeforeInsert(builder));
 }
 function callInstanceBeforeInsert(builder, models) {
-    return mapAfterAllReturn(models, (model) => model.$beforeInsert(builder.context()), models);
+    return (0, promiseUtils_1.mapAfterAllReturn)(models, (model) => model.$beforeInsert(builder.context()), models);
 }
 function callStaticBeforeInsert(builder) {
-    if (!hasStaticHook(builder.modelClass(), 'beforeInsert')) {
+    if (!(0, StaticHookArguments_1.hasStaticHook)(builder.modelClass(), 'beforeInsert')) {
         return undefined;
     }
-    const args = StaticHookArguments.create({ builder });
+    const args = StaticHookArguments_1.StaticHookArguments.create({ builder });
     return builder.modelClass().beforeInsert(args);
 }
 function callAfterInsert(builder, models, result) {
     const maybePromise = callInstanceAfterInsert(builder, models);
-    return after(maybePromise, () => callStaticAfterInsert(builder, result));
+    return (0, promiseUtils_1.after)(maybePromise, () => callStaticAfterInsert(builder, result));
 }
 function callInstanceAfterInsert(builder, models) {
-    return mapAfterAllReturn(models, (model) => model.$afterInsert(builder.context()), models);
+    return (0, promiseUtils_1.mapAfterAllReturn)(models, (model) => model.$afterInsert(builder.context()), models);
 }
 function callStaticAfterInsert(builder, result) {
-    if (!hasStaticHook(builder.modelClass(), 'afterInsert')) {
+    if (!(0, StaticHookArguments_1.hasStaticHook)(builder.modelClass(), 'afterInsert')) {
         return result;
     }
-    const args = StaticHookArguments.create({ builder, result });
+    const args = StaticHookArguments_1.StaticHookArguments.create({ builder, result });
     const maybePromise = builder.modelClass().afterInsert(args);
-    return after(maybePromise, (maybeResult) => {
+    return (0, promiseUtils_1.after)(maybePromise, (maybeResult) => {
         if (maybeResult === undefined) {
             return result;
         }
@@ -168,6 +172,3 @@ function callStaticAfterInsert(builder, result) {
         }
     });
 }
-module.exports = {
-    InsertOperation,
-};

package/lib/queryBuilder/operations/InstanceDeleteOperation.js

@@ -1,9 +1,11 @@
-'use strict';
-const { withWhereScope } = require('../whereScopes');
-const { DeleteOperation } = require('./DeleteOperation');
-const { InstanceFindOperation } = require('./InstanceFindOperation');
-const { assertHasId } = require('../../utils/assert');
-class InstanceDeleteOperation extends DeleteOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceDeleteOperation = void 0;
+const whereScopes_1 = require("../whereScopes");
+const DeleteOperation_1 = require("./DeleteOperation");
+const InstanceFindOperation_1 = require("./InstanceFindOperation");
+const assert_1 = require("../../utils/assert");
+class InstanceDeleteOperation extends DeleteOperation_1.DeleteOperation {
     constructor(name, opt) {
         super(name, opt);
         this.instance = opt.instance;
@@ -15,8 +17,8 @@ class InstanceDeleteOperation extends DeleteOperation {
     }
     onBuild(builder) {
         super.onBuild(builder);
-        assertHasId(this.instance);
-        withWhereScope(builder, () => builder.findById(this.instance.$id()));
+        (0, assert_1.assertHasId)(this.instance);
+        (0, whereScopes_1.withWhereScope)(builder, () => builder.findById(this.instance.$id()));
     }
     async onAfter2(builder, result) {
         // The result may be an object if `returning` was used.
@@ -27,11 +29,9 @@ class InstanceDeleteOperation extends DeleteOperation {
         return super.onAfter2(builder, result);
     }
     toFindOperation() {
-        return new InstanceFindOperation('find', {
+        return new InstanceFindOperation_1.InstanceFindOperation('find', {
             instance: this.instance,
         });
     }
 }
-module.exports = {
-    InstanceDeleteOperation,
-};
+exports.InstanceDeleteOperation = InstanceDeleteOperation;

package/lib/queryBuilder/operations/InstanceFindOperation.js

@@ -1,17 +1,17 @@
-'use strict';
-const { withWhereScope } = require('../whereScopes');
-const { FindOperation } = require('./FindOperation');
-const { assertHasId } = require('../../utils/assert');
-class InstanceFindOperation extends FindOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceFindOperation = void 0;
+const whereScopes_1 = require("../whereScopes");
+const FindOperation_1 = require("./FindOperation");
+const assert_1 = require("../../utils/assert");
+class InstanceFindOperation extends FindOperation_1.FindOperation {
     constructor(name, opt) {
         super(name, opt);
         this.instance = opt.instance;
     }
     onBuild(builder) {
-        assertHasId(this.instance);
-        withWhereScope(builder, () => builder.findById(this.instance.$id()));
+        (0, assert_1.assertHasId)(this.instance);
+        (0, whereScopes_1.withWhereScope)(builder, () => builder.findById(this.instance.$id()));
     }
 }
-module.exports = {
-    InstanceFindOperation,
-};
+exports.InstanceFindOperation = InstanceFindOperation;