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

package/lib/queryBuilder/graph/recursiveUpsert/GraphRecursiveUpsertAction.js

@@ -1,9 +1,44 @@
-'use strict';
-const { GraphAction } = require('../GraphAction');
-const { groupBy, get, set } = require('../../../utils/objectUtils');
-const { forEachPropertyReference } = require('../../../model/graph/ModelGraphBuilder');
-const promiseUtils = require('../../../utils/promiseUtils');
-class GraphRecursiveUpsertAction extends GraphAction {
+"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.GraphRecursiveUpsertAction = void 0;
+const GraphAction_1 = require("../GraphAction");
+const objectUtils_1 = require("../../../utils/objectUtils");
+const ModelGraphBuilder_1 = require("../../../model/graph/ModelGraphBuilder");
+const promiseUtils = __importStar(require("../../../utils/promiseUtils"));
+class GraphRecursiveUpsertAction extends GraphAction_1.GraphAction {
     constructor(graphData, { nodes }) {
         super(graphData);
         // Nodes to upsert.
@@ -16,10 +51,10 @@ class GraphRecursiveUpsertAction extends GraphAction {
         });
     }
     _createUpsertBuilders(parentBuilder, nodesToUpsert) {
-        const nodesByRelation = groupBy(nodesToUpsert, getRelation);
+        const nodesByRelation = (0, objectUtils_1.groupBy)(nodesToUpsert, getRelation);
         const builders = [];
         nodesByRelation.forEach((nodes) => {
-            const nodesByParent = groupBy(nodes, getParent);
+            const nodesByParent = (0, objectUtils_1.groupBy)(nodes, getParent);
             nodesByParent.forEach((nodes) => {
                 for (const node of nodes) {
                     this._resolveReferences(node);
@@ -28,8 +63,10 @@ class GraphRecursiveUpsertAction extends GraphAction {
                 builders.push(nodes[0].modelClass
                     .query()
                     .childQueryOf(parentBuilder)
-                    .copyFrom(parentBuilder, GraphAction.ReturningAllSelector)
-                    .upsertGraph(nodes.map((node) => node.obj), this.graphOptions.rebasedOptions(nodes[0])));
+                    .copyFrom(parentBuilder, GraphAction_1.GraphAction.ReturningAllSelector)
+                    .upsertGraph(nodes.map((node) => node.obj), 
+                // `GraphOptions` also takes a `GraphOptions` as its options.
+                this.graphOptions.rebasedOptions(nodes[0])));
             });
         });
         return builders;
@@ -69,28 +106,27 @@ class GraphRecursiveUpsertAction extends GraphAction {
         delete obj[modelClass.uidRefProp];
     }
     _resolvePropertyReferences(obj) {
-        forEachPropertyReference(obj, ({ path, refMatch, ref, refPath }) => {
+        (0, ModelGraphBuilder_1.forEachPropertyReference)(obj, ({ path, refMatch, ref, refPath, }) => {
             const referencedNode = this.graph.nodes.find((it) => it.uid === ref);
             if (!referencedNode) {
                 return;
             }
-            const referencedValue = get(referencedNode.obj, refPath);
-            const value = get(obj, path);
+            const referencedValue = (0, objectUtils_1.get)(referencedNode.obj, refPath);
+            const value = (0, objectUtils_1.get)(obj, path);
             if (value === refMatch) {
-                set(obj, path, referencedValue);
+                (0, objectUtils_1.set)(obj, path, referencedValue);
             }
             else {
-                set(obj, path, value.replace(refMatch, referencedValue));
+                // The reference is a part of a string: `replace()` converts the value to a string.
+                (0, objectUtils_1.set)(obj, path, value.replace(refMatch, referencedValue));
             }
         });
     }
 }
+exports.GraphRecursiveUpsertAction = GraphRecursiveUpsertAction;
 function getRelation(node) {
     return node.parentEdge.relation;
 }
 function getParent(node) {
     return node.parentNode;
 }
-module.exports = {
-    GraphRecursiveUpsertAction,
-};

package/lib/queryBuilder/join/JoinResultColumn.js

@@ -1,11 +1,15 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinResultColumn = void 0;
 class JoinResultColumn {
+    // The arguments are the properties of the column.
     constructor({ columnAlias, tableNode, name }) {
         this.columnAlias = columnAlias;
         this.tableNode = tableNode;
         this.name = name;
     }
     static create({ tableTree, columnAlias }) {
+        // The column aliases of the joined query are those of the table tree.
         const tableNode = tableTree.getNodeForColumnAlias(columnAlias);
         return new JoinResultColumn({
             columnAlias,
@@ -14,6 +18,4 @@ class JoinResultColumn {
         });
     }
 }
-module.exports = {
-    JoinResultColumn,
-};
+exports.JoinResultColumn = JoinResultColumn;

package/lib/queryBuilder/join/JoinResultParser.js

@@ -1,6 +1,8 @@
-'use strict';
-const { JoinResultColumn } = require('./JoinResultColumn');
-const { groupBy } = require('../../utils/objectUtils');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinResultParser = void 0;
+const JoinResultColumn_1 = require("./JoinResultColumn");
+const objectUtils_1 = require("../../utils/objectUtils");
 class JoinResultParser {
     constructor({ tableTree, omitColumnAliases = [] }) {
         this.tableTree = tableTree;
@@ -54,6 +56,8 @@ class JoinResultParser {
             }
         }
         const model = tableNode.modelClass.fromDatabaseJson(row);
+        // The child nodes and the node of a parent model always have a relation
+        // and a relation property.
         for (const childNode of tableNode.childNodes) {
             if (childNode.relation.isOneToOne()) {
                 model[childNode.relationProperty] = null;
@@ -80,12 +84,13 @@ class JoinResultParser {
     }
     _createColumns(row) {
         const columns = Object.keys(row)
-            .map((columnAlias) => JoinResultColumn.create({ tableTree: this.tableTree, columnAlias }))
+            .map((columnAlias) => JoinResultColumn_1.JoinResultColumn.create({ tableTree: this.tableTree, columnAlias }))
             // The omitted columns are filtered here once instead of for every model.
             .filter((column) => !this.omitColumnAliases.has(column.columnAlias));
-        return groupBy(columns, getTableNode);
+        return (0, objectUtils_1.groupBy)(columns, getTableNode);
     }
 }
+exports.JoinResultParser = JoinResultParser;
 function getTableNode(column) {
     return column.tableNode;
 }
@@ -101,6 +106,3 @@ function createChildMaps(tableNode) {
     }
     return maps;
 }
-module.exports = {
-    JoinResultParser,
-};

package/lib/queryBuilder/join/RelationJoiner.js

@@ -1,13 +1,15 @@
-'use strict';
-const { uniqBy } = require('../../utils/objectUtils');
-const { Selection } = require('../operations/select/Selection');
-const { createModifier } = require('../../utils/createModifier');
-const { map: mapPromise } = require('../../utils/promiseUtils');
-const { getReadConcurrency } = require('../../model/modelConcurrency');
-const { ValidationErrorType } = require('../../model/ValidationError');
-const { TableTree } = require('./TableTree');
-const { JoinResultParser } = require('./JoinResultParser');
-const { ID_LENGTH_LIMIT } = require('./utils');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationJoiner = void 0;
+const objectUtils_1 = require("../../utils/objectUtils");
+const Selection_1 = require("../operations/select/Selection");
+const createModifier_1 = require("../../utils/createModifier");
+const promiseUtils_1 = require("../../utils/promiseUtils");
+const modelConcurrency_1 = require("../../model/modelConcurrency");
+const ValidationError_1 = require("../../model/ValidationError");
+const TableTree_1 = require("./TableTree");
+const JoinResultParser_1 = require("./JoinResultParser");
+const utils_1 = require("./utils");
 /**
  * Given a relation expression, builds a query using joins to fetch it.
  */
@@ -47,8 +49,8 @@ class RelationJoiner {
     fetchColumnInfo(builder) {
         const tableTree = this._getTableTree(builder);
         const allModelClasses = new Set(tableTree.nodes.map((node) => node.modelClass));
-        return mapPromise(Array.from(allModelClasses), (modelClass) => modelClass.fetchTableMetadata({ parentBuilder: builder }), {
-            concurrency: getReadConcurrency(this.rootModelClass, builder.unsafeKnex()),
+        return (0, promiseUtils_1.map)(Array.from(allModelClasses), (modelClass) => modelClass.fetchTableMetadata({ parentBuilder: builder }), {
+            concurrency: (0, modelConcurrency_1.getReadConcurrency)(this.rootModelClass, builder.unsafeKnex()),
         });
     }
     build(builder, buildSelects = true) {
@@ -62,7 +64,7 @@ class RelationJoiner {
         }
     }
     parseResult(builder, flatRows) {
-        const parser = JoinResultParser.create({
+        const parser = JoinResultParser_1.JoinResultParser.create({
             tableTree: this._getTableTree(builder),
             omitColumnAliases: this.internalSelections.map((it) => it.alias),
         });
@@ -71,7 +73,7 @@ class RelationJoiner {
     _getTableTree(builder) {
         if (!this.tableTree) {
             // Create the table tree lazily.
-            this.tableTree = TableTree.create({
+            this.tableTree = TableTree_1.TableTree.create({
                 rootModelClass: this.rootModelClass,
                 rootTableAlias: builder.tableRef(),
                 expression: this.expression,
@@ -80,7 +82,7 @@ class RelationJoiner {
         }
         return this.tableTree;
     }
-    _buildJoinsForNode({ builder, tableNode, userSelectQueries }) {
+    _buildJoinsForNode({ builder, tableNode, userSelectQueries, }) {
         const subqueryToJoin = createSubqueryToJoin({
             builder,
             tableNode,
@@ -107,13 +109,14 @@ class RelationJoiner {
             this._buildJoinsForNode({ builder, tableNode: childNode, userSelectQueries });
         }
     }
-    _buildSelects({ builder, tableNode, userSelectQueries }) {
+    _buildSelects({ builder, tableNode, userSelectQueries, }) {
         const { selections, internalSelections } = getSelectionsForNode({
             builder,
             tableNode,
             userSelectQueries,
         });
         for (const selection of selections) {
+            // The selections that are added here all have an alias.
             checkAliasLength(tableNode.modelClass, selection.name);
         }
         // Save the selections that were added internally (not by the user)
@@ -123,6 +126,7 @@ class RelationJoiner {
         builder.select(selectionsToStrings(selections));
     }
 }
+exports.RelationJoiner = RelationJoiner;
 function defaultOptions() {
     return {
         joinOperation: 'leftJoin',
@@ -131,11 +135,11 @@ function defaultOptions() {
         aliases: {},
     };
 }
-function createSubqueryToJoin({ builder, tableNode, modifiers }) {
+function createSubqueryToJoin({ builder, tableNode, modifiers, }) {
     const { relation, expression, modelClass } = tableNode;
     const modifierQuery = modelClass.query().childQueryOf(builder);
     for (const modifierName of expression.node.$modify) {
-        const modifier = createModifier({
+        const modifier = (0, createModifier_1.createModifier)({
             modifier: modifierName,
             modelClass,
             modifiers,
@@ -146,7 +150,7 @@ function createSubqueryToJoin({ builder, tableNode, modifiers }) {
         catch (err) {
             if (err instanceof modelClass.ModifierNotFoundError) {
                 throw modelClass.createValidationError({
-                    type: ValidationErrorType.RelationExpression,
+                    type: ValidationError_1.ValidationErrorType.RelationExpression,
                     message: `could not find modifier "${modifierName}" for relation "${relation.name}"`,
                 });
             }
@@ -157,19 +161,20 @@ function createSubqueryToJoin({ builder, tableNode, modifiers }) {
     }
     return modifierQuery;
 }
-function ensureIdAndRelationPropsAreSelected({ builder, tableNode }) {
+function ensureIdAndRelationPropsAreSelected({ builder, tableNode, }) {
     const tableRef = builder.tableRef();
     const cols = [
         ...builder.modelClass().getIdColumnArray(),
         ...tableNode.relation.relatedProp.cols,
         ...tableNode.childNodes.reduce((cols, childNode) => [...cols, ...childNode.relation.ownerProp.cols], []),
     ];
-    const selectStrings = uniqBy(cols)
+    const selectStrings = (0, objectUtils_1.uniqBy)(cols)
         .filter((col) => !builder.hasSelectionAs(col, col))
         .map((col) => `${tableRef}.${col}`);
     return builder.select(selectStrings);
 }
-function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
+function getSelectionsForNode({ builder, tableNode, userSelectQueries, }) {
+    // Every node has a query: `build()` and `_buildJoinsForNode()` add them.
     const userSelectQuery = userSelectQueries.get(tableNode);
     const userSelections = userSelectQuery.findAllSelections();
     const userSelectedAllColumns = isSelectAllSelectionSet(userSelections);
@@ -189,6 +194,7 @@ function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
     else {
         const idSelections = getIdSelectionsForNode({ tableNode });
         for (const idSelection of idSelections) {
+            // The id selections have a column.
             if (!userSelectQuery.hasSelectionAs(idSelection.column, idSelection.column)) {
                 selections.push(idSelection);
                 internalSelections.push(idSelection);
@@ -205,29 +211,31 @@ function getSelectionsForNode({ builder, tableNode, userSelectQueries }) {
         internalSelections,
     };
 }
-function mapUserSelectionsFromSubqueryToMainQuery({ userSelections, tableNode }) {
+function mapUserSelectionsFromSubqueryToMainQuery({ userSelections, tableNode, }) {
     return userSelections.filter(isNotSelectAll).map((selection) => {
-        return new Selection(tableNode.alias, selection.name, tableNode.getColumnAliasForColumn(selection.name));
+        // A user selection that isn't `*` has a name.
+        return new Selection_1.Selection(tableNode.alias, selection.name, tableNode.getColumnAliasForColumn(selection.name));
     });
 }
-function getJoinTableExtraSelectionsForNode({ builder, tableNode }) {
+function getJoinTableExtraSelectionsForNode({ builder, tableNode, }) {
     return tableNode.relation.joinTableExtras.map((extra) => {
-        return new Selection(tableNode.getJoinTableAlias(builder), extra.joinTableCol, tableNode.getColumnAliasForColumn(extra.aliasCol));
+        // A many to many relation, which has a join table.
+        return new Selection_1.Selection(tableNode.getJoinTableAlias(builder), extra.joinTableCol, tableNode.getColumnAliasForColumn(extra.aliasCol));
     });
 }
-function getAllColumnSelectionsForNode({ builder, tableNode }) {
+function getAllColumnSelectionsForNode({ builder, tableNode, }) {
     const table = builder.tableNameFor(tableNode.modelClass);
     const tableMeta = tableNode.modelClass.tableMetadata({ table });
     if (!tableMeta) {
         throw new Error(`table metadata has not been fetched for table '${table}'. Are you trying to call toKnexQuery() for a withGraphJoined query? To make sure the table metadata is fetched see the objection.initialize function.`);
     }
     return tableMeta.columns.map((columnName) => {
-        return new Selection(tableNode.alias, columnName, tableNode.getColumnAliasForColumn(columnName));
+        return new Selection_1.Selection(tableNode.alias, columnName, tableNode.getColumnAliasForColumn(columnName));
     });
 }
 function getIdSelectionsForNode({ tableNode }) {
     return tableNode.modelClass.getIdColumnArray().map((columnName) => {
-        return new Selection(tableNode.alias, columnName, tableNode.getColumnAliasForColumn(columnName));
+        return new Selection_1.Selection(tableNode.alias, columnName, tableNode.getColumnAliasForColumn(columnName));
     });
 }
 function selectionsToStrings(selections) {
@@ -246,13 +254,10 @@ function isSelectAllSelectionSet(selections) {
     return selections.length === 0 || selections.some(isSelectAll);
 }
 function checkAliasLength(modelClass, alias) {
-    if (alias.length > ID_LENGTH_LIMIT) {
+    if (alias.length > utils_1.ID_LENGTH_LIMIT) {
         throw modelClass.createValidationError({
-            type: ValidationErrorType.RelationExpression,
-            message: `identifier ${alias} is over ${ID_LENGTH_LIMIT} characters long and would be truncated by the database engine.`,
+            type: ValidationError_1.ValidationErrorType.RelationExpression,
+            message: `identifier ${alias} is over ${utils_1.ID_LENGTH_LIMIT} characters long and would be truncated by the database engine.`,
         });
     }
 }
-module.exports = {
-    RelationJoiner,
-};

package/lib/queryBuilder/join/TableNode.js

@@ -1,6 +1,8 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableNode = void 0;
 class TableNode {
-    constructor({ tableTree, modelClass, expression, parentNode = null, relation = null }) {
+    constructor({ tableTree, modelClass, expression, parentNode = null, relation = null, }) {
         this.tableTree = tableTree;
         this.modelClass = modelClass;
         this.parentNode = parentNode;
@@ -20,6 +22,7 @@ class TableNode {
     get options() {
         return this.tableTree.options;
     }
+    // Null for the root node only.
     get relationProperty() {
         return this.expression.node.$name;
     }
@@ -57,6 +60,7 @@ class TableNode {
     }
     _calculateAlias() {
         if (this.parentNode) {
+            // A child node always has a name.
             const relationName = this.expression.node.$name;
             const alias = this.options.aliases[relationName] || relationName;
             if (this.options.minimize) {
@@ -84,6 +88,7 @@ class TableNode {
         }
     }
 }
+exports.TableNode = TableNode;
 function createIdGetter(columnAliases) {
     const columnAlias = columnAliases[0];
     return (flatRow) => {
@@ -131,6 +136,3 @@ function createMultiIdGetter(columnAliases) {
         return idStr;
     };
 }
-module.exports = {
-    TableNode,
-};

package/lib/queryBuilder/join/TableTree.js

@@ -1,6 +1,8 @@
-'use strict';
-const { forEachChildExpression } = require('./utils');
-const { TableNode } = require('./TableNode');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableTree = void 0;
+const utils_1 = require("./utils");
+const TableNode_1 = require("./TableNode");
 class TableTree {
     constructor({ expression, rootModelClass, rootTableAlias, options }) {
         this.options = options;
@@ -38,7 +40,7 @@ class TableTree {
         }
     }
     _createRootNode({ expression, modelClass }) {
-        const node = TableNode.create({
+        const node = TableNode_1.TableNode.create({
             tableTree: this,
             modelClass,
             expression,
@@ -47,8 +49,12 @@ class TableTree {
         return node;
     }
     _createChildNodes({ expression, modelClass, parentNode }) {
-        forEachChildExpression(expression, modelClass, (childExpr, relation) => {
-            const node = TableNode.create({
+        (0, utils_1.forEachChildExpression)(expression, modelClass, (childExpr, relation) => {
+            // `relation` is only null for a recursive relation that doesn't exist.
+            // Reading its `relatedModelClass` then throws a TypeError.
+            // `Relation` types its model classes as `RelationModelClass`. They are
+            // full model classes.
+            const node = TableNode_1.TableNode.create({
                 tableTree: this,
                 modelClass: relation.relatedModelClass,
                 expression: childExpr,
@@ -64,6 +70,4 @@ class TableTree {
         });
     }
 }
-module.exports = {
-    TableTree,
-};
+exports.TableTree = TableTree;

package/lib/queryBuilder/join/utils.js

@@ -1,19 +1,19 @@
-'use strict';
-const { ValidationErrorType } = require('../../model/ValidationError');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RELATION_RECURSION_LIMIT = exports.ID_LENGTH_LIMIT = void 0;
+exports.forEachChildExpression = forEachChildExpression;
+const ValidationError_1 = require("../../model/ValidationError");
 const ID_LENGTH_LIMIT = 63;
+exports.ID_LENGTH_LIMIT = ID_LENGTH_LIMIT;
 const RELATION_RECURSION_LIMIT = 64;
+exports.RELATION_RECURSION_LIMIT = RELATION_RECURSION_LIMIT;
 // Given a relation expression, goes through all first level children.
 function forEachChildExpression(expr, modelClass, callback) {
     if (expr.node.$allRecursive || expr.maxRecursionDepth > RELATION_RECURSION_LIMIT) {
         throw modelClass.createValidationError({
-            type: ValidationErrorType.RelationExpression,
+            type: ValidationError_1.ValidationErrorType.RelationExpression,
             message: `recursion depth of eager expression ${expr.toString()} too big for JoinEagerAlgorithm`,
         });
     }
     expr.forEachChildExpression(modelClass, callback);
 }
-module.exports = {
-    ID_LENGTH_LIMIT,
-    RELATION_RECURSION_LIMIT,
-    forEachChildExpression,
-};

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;