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

package/lib/relations/belongsToOne/BelongsToOneInsertOperation.js

@@ -1,7 +1,9 @@
-'use strict';
-const { RelationInsertOperation } = require('../RelationInsertOperation');
-const { BelongsToOneRelateOperation } = require('./BelongsToOneRelateOperation');
-class BelongsToOneInsertOperation extends RelationInsertOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BelongsToOneInsertOperation = void 0;
+const RelationInsertOperation_1 = require("../RelationInsertOperation");
+const BelongsToOneRelateOperation_1 = require("./BelongsToOneRelateOperation");
+class BelongsToOneInsertOperation extends RelationInsertOperation_1.RelationInsertOperation {
     onAdd(builder, args) {
         const retVal = super.onAdd(builder, args);
         if (this.models.length > 1) {
@@ -14,7 +16,7 @@ class BelongsToOneInsertOperation extends RelationInsertOperation {
         if (!builder.isExecutable()) {
             return inserted;
         }
-        const relateOp = new BelongsToOneRelateOperation('relate', {
+        const relateOp = new BelongsToOneRelateOperation_1.BelongsToOneRelateOperation('relate', {
             relation: this.relation,
             owner: this.owner,
         });
@@ -28,6 +30,4 @@ class BelongsToOneInsertOperation extends RelationInsertOperation {
         return inserted;
     }
 }
-module.exports = {
-    BelongsToOneInsertOperation,
-};
+exports.BelongsToOneInsertOperation = BelongsToOneInsertOperation;

package/lib/relations/belongsToOne/BelongsToOneRelateOperation.js

@@ -1,10 +1,12 @@
-'use strict';
-const { normalizeIds } = require('../../utils/normalizeIds');
-const { RelateOperation } = require('../../queryBuilder/operations/RelateOperation');
-class BelongsToOneRelateOperation extends RelateOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BelongsToOneRelateOperation = void 0;
+const normalizeIds_1 = require("../../utils/normalizeIds");
+const RelateOperation_1 = require("../../queryBuilder/operations/RelateOperation");
+class BelongsToOneRelateOperation extends RelateOperation_1.RelateOperation {
     onAdd(_, args) {
         this.input = args[0];
-        this.ids = normalizeIds(args[0], this.relation.relatedProp, { arrayOutput: true });
+        this.ids = (0, normalizeIds_1.normalizeIds)(args[0], this.relation.relatedProp, { arrayOutput: true });
         assertOneId(this.ids);
         return true;
     }
@@ -29,11 +31,9 @@ class BelongsToOneRelateOperation extends RelateOperation {
             .whereInComposite(ownerIdProp.refs(builder), ownerIds);
     }
 }
+exports.BelongsToOneRelateOperation = BelongsToOneRelateOperation;
 function assertOneId(ids) {
     if (ids.length > 1) {
         throw new Error('can only relate one model to a BelongsToOneRelation');
     }
 }
-module.exports = {
-    BelongsToOneRelateOperation,
-};

package/lib/relations/belongsToOne/BelongsToOneRelation.js

@@ -1,38 +1,41 @@
-'use strict';
-const { Relation } = require('../Relation');
-const { BelongsToOneInsertOperation } = require('./BelongsToOneInsertOperation');
-const { BelongsToOneDeleteOperation } = require('./BelongsToOneDeleteOperation');
-const { BelongsToOneRelateOperation } = require('./BelongsToOneRelateOperation');
-const { BelongsToOneUnrelateOperation } = require('./BelongsToOneUnrelateOperation');
-class BelongsToOneRelation extends Relation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BelongsToOneRelation = void 0;
+const Relation_1 = require("../Relation");
+const BelongsToOneInsertOperation_1 = require("./BelongsToOneInsertOperation");
+const BelongsToOneDeleteOperation_1 = require("./BelongsToOneDeleteOperation");
+const BelongsToOneRelateOperation_1 = require("./BelongsToOneRelateOperation");
+const BelongsToOneUnrelateOperation_1 = require("./BelongsToOneUnrelateOperation");
+class BelongsToOneRelation extends Relation_1.Relation {
     isOneToOne() {
         return true;
     }
     insert(_, owner) {
-        return new BelongsToOneInsertOperation('insert', {
+        return new BelongsToOneInsertOperation_1.BelongsToOneInsertOperation('insert', {
             relation: this,
             owner,
         });
     }
     delete(_, owner) {
-        return new BelongsToOneDeleteOperation('delete', {
+        return new BelongsToOneDeleteOperation_1.BelongsToOneDeleteOperation('delete', {
             relation: this,
             owner,
         });
     }
     relate(_, owner) {
-        return new BelongsToOneRelateOperation('relate', {
+        return new BelongsToOneRelateOperation_1.BelongsToOneRelateOperation('relate', {
             relation: this,
             owner,
         });
     }
     unrelate(_, owner) {
-        return new BelongsToOneUnrelateOperation('unrelate', {
+        return new BelongsToOneUnrelateOperation_1.BelongsToOneUnrelateOperation('unrelate', {
             relation: this,
             owner,
         });
     }
 }
+exports.BelongsToOneRelation = BelongsToOneRelation;
 Object.defineProperties(BelongsToOneRelation.prototype, {
     isObjectionBelongsToOneRelation: {
         enumerable: false,
@@ -40,6 +43,3 @@ Object.defineProperties(BelongsToOneRelation.prototype, {
         value: true,
     },
 });
-module.exports = {
-    BelongsToOneRelation,
-};

package/lib/relations/belongsToOne/BelongsToOneUnrelateOperation.js

@@ -1,6 +1,8 @@
-'use strict';
-const { UnrelateOperation } = require('../../queryBuilder/operations/UnrelateOperation');
-class BelongsToOneUnrelateOperation extends UnrelateOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BelongsToOneUnrelateOperation = void 0;
+const UnrelateOperation_1 = require("../../queryBuilder/operations/UnrelateOperation");
+class BelongsToOneUnrelateOperation extends UnrelateOperation_1.UnrelateOperation {
     onAdd() {
         const ids = new Array(this.relation.ownerProp.size);
         this.relation.ownerProp.forEach((i) => {
@@ -41,6 +43,4 @@ class BelongsToOneUnrelateOperation extends UnrelateOperation {
         return query;
     }
 }
-module.exports = {
-    BelongsToOneUnrelateOperation,
-};
+exports.BelongsToOneUnrelateOperation = BelongsToOneUnrelateOperation;

package/lib/relations/hasMany/HasManyInsertOperation.js

@@ -1,6 +1,8 @@
-'use strict';
-const { RelationInsertOperation } = require('../RelationInsertOperation');
-class HasManyInsertOperation extends RelationInsertOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasManyInsertOperation = void 0;
+const RelationInsertOperation_1 = require("../RelationInsertOperation");
+class HasManyInsertOperation extends RelationInsertOperation_1.RelationInsertOperation {
     onAdd(builder, args) {
         const retVal = super.onAdd(builder, args);
         assertOwnerIsSingleItem(this.owner, this.relation);
@@ -26,6 +28,7 @@ class HasManyInsertOperation extends RelationInsertOperation {
         return inserted;
     }
 }
+exports.HasManyInsertOperation = HasManyInsertOperation;
 function assertOwnerIsSingleItem(owner, relation) {
     const { isModels, isIdentifiers, isQueryBuilder } = owner;
     const { ownerProp } = relation;
@@ -40,6 +43,3 @@ function assertOwnerIsSingleItem(owner, relation) {
         ].join(' '));
     }
 }
-module.exports = {
-    HasManyInsertOperation,
-};

package/lib/relations/hasMany/HasManyRelateOperation.js

@@ -1,11 +1,13 @@
-'use strict';
-const { withWhereScope } = require('../../queryBuilder/whereScopes');
-const { normalizeIds } = require('../../utils/normalizeIds');
-const { RelateOperation } = require('../../queryBuilder/operations/RelateOperation');
-class HasManyRelateOperation extends RelateOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasManyRelateOperation = void 0;
+const whereScopes_1 = require("../../queryBuilder/whereScopes");
+const normalizeIds_1 = require("../../utils/normalizeIds");
+const RelateOperation_1 = require("../../queryBuilder/operations/RelateOperation");
+class HasManyRelateOperation extends RelateOperation_1.RelateOperation {
     onAdd(_, args) {
         this.input = args[0];
-        this.ids = normalizeIds(args[0], this.relation.relatedModelClass.getIdRelationProperty(), {
+        this.ids = (0, normalizeIds_1.normalizeIds)(args[0], this.relation.relatedModelClass.getIdRelationProperty(), {
             arrayOutput: true,
         });
         assertOwnerIsSingleItem(this.owner, this.relation);
@@ -24,11 +26,12 @@ class HasManyRelateOperation extends RelateOperation {
             .patch(patch)
             .copyFrom(builder, builder.constructor.JoinSelector)
             .copyFrom(builder, builder.constructor.WhereSelector);
-        withWhereScope(query, () => query.findByIds(this.ids));
-        withWhereScope(query, () => query.modify(this.relation.modify));
+        (0, whereScopes_1.withWhereScope)(query, () => query.findByIds(this.ids));
+        (0, whereScopes_1.withWhereScope)(query, () => query.modify(this.relation.modify));
         return query;
     }
 }
+exports.HasManyRelateOperation = HasManyRelateOperation;
 function assertOwnerIsSingleItem(owner, relation) {
     const { isModels, isIdentifiers, isQueryBuilder } = owner;
     const { ownerProp } = relation;
@@ -43,6 +46,3 @@ function assertOwnerIsSingleItem(owner, relation) {
         ].join(' '));
     }
 }
-module.exports = {
-    HasManyRelateOperation,
-};

package/lib/relations/hasMany/HasManyRelation.js

@@ -1,23 +1,25 @@
-'use strict';
-const { Relation } = require('../Relation');
-const { HasManyInsertOperation } = require('./HasManyInsertOperation');
-const { HasManyRelateOperation } = require('./HasManyRelateOperation');
-const { HasManyUnrelateOperation } = require('./HasManyUnrelateOperation');
-class HasManyRelation extends Relation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasManyRelation = void 0;
+const Relation_1 = require("../Relation");
+const HasManyInsertOperation_1 = require("./HasManyInsertOperation");
+const HasManyRelateOperation_1 = require("./HasManyRelateOperation");
+const HasManyUnrelateOperation_1 = require("./HasManyUnrelateOperation");
+class HasManyRelation extends Relation_1.Relation {
     insert(_, owner) {
-        return new HasManyInsertOperation('insert', {
+        return new HasManyInsertOperation_1.HasManyInsertOperation('insert', {
             relation: this,
             owner: owner,
         });
     }
     relate(_, owner) {
-        return new HasManyRelateOperation('relate', {
+        return new HasManyRelateOperation_1.HasManyRelateOperation('relate', {
             relation: this,
             owner: owner,
         });
     }
     unrelate(_, owner) {
-        return new HasManyUnrelateOperation('unrelate', {
+        return new HasManyUnrelateOperation_1.HasManyUnrelateOperation('unrelate', {
             relation: this,
             owner: owner,
         });
@@ -29,6 +31,7 @@ class HasManyRelation extends Relation {
         model.$id(values);
     }
 }
+exports.HasManyRelation = HasManyRelation;
 Object.defineProperties(HasManyRelation.prototype, {
     isObjectionHasManyRelation: {
         enumerable: false,
@@ -36,6 +39,3 @@ Object.defineProperties(HasManyRelation.prototype, {
         value: true,
     },
 });
-module.exports = {
-    HasManyRelation,
-};

package/lib/relations/hasMany/HasManyUnrelateOperation.js

@@ -1,7 +1,9 @@
-'use strict';
-const { withWhereScope } = require('../../queryBuilder/whereScopes');
-const { UnrelateOperation } = require('../../queryBuilder/operations/UnrelateOperation');
-class HasManyUnrelateOperation extends UnrelateOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasManyUnrelateOperation = void 0;
+const whereScopes_1 = require("../../queryBuilder/whereScopes");
+const UnrelateOperation_1 = require("../../queryBuilder/operations/UnrelateOperation");
+class HasManyUnrelateOperation extends UnrelateOperation_1.UnrelateOperation {
     queryExecutor(builder) {
         const patch = {};
         const relatedProp = this.relation.relatedProp;
@@ -16,11 +18,9 @@ class HasManyUnrelateOperation extends UnrelateOperation {
             .patch(patch)
             .copyFrom(builder, builder.constructor.JoinSelector)
             .copyFrom(builder, builder.constructor.WhereSelector);
-        withWhereScope(query, () => query.whereInComposite(relatedRefs, ownerValues));
-        withWhereScope(query, () => query.modify(this.relation.modify));
+        (0, whereScopes_1.withWhereScope)(query, () => query.whereInComposite(relatedRefs, ownerValues));
+        (0, whereScopes_1.withWhereScope)(query, () => query.modify(this.relation.modify));
         return query;
     }
 }
-module.exports = {
-    HasManyUnrelateOperation,
-};
+exports.HasManyUnrelateOperation = HasManyUnrelateOperation;

package/lib/relations/hasOne/HasOneRelation.js

@@ -1,10 +1,10 @@
-'use strict';
-const { HasManyRelation } = require('../hasMany/HasManyRelation');
-class HasOneRelation extends HasManyRelation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasOneRelation = void 0;
+const HasManyRelation_1 = require("../hasMany/HasManyRelation");
+class HasOneRelation extends HasManyRelation_1.HasManyRelation {
     isOneToOne() {
         return true;
     }
 }
-module.exports = {
-    HasOneRelation,
-};
+exports.HasOneRelation = HasOneRelation;

package/lib/relations/hasOneThrough/HasOneThroughRelation.js

@@ -1,10 +1,10 @@
-'use strict';
-const { ManyToManyRelation } = require('../manyToMany/ManyToManyRelation');
-class HasOneThroughRelation extends ManyToManyRelation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasOneThroughRelation = void 0;
+const ManyToManyRelation_1 = require("../manyToMany/ManyToManyRelation");
+class HasOneThroughRelation extends ManyToManyRelation_1.ManyToManyRelation {
     isOneToOne() {
         return true;
     }
 }
-module.exports = {
-    HasOneThroughRelation,
-};
+exports.HasOneThroughRelation = HasOneThroughRelation;

package/lib/relations/manyToMany/ManyToManyModifyMixin.js

@@ -1,6 +1,8 @@
-'use strict';
-const { withWhereScope } = require('../../queryBuilder/whereScopes');
-const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManyModifyMixin = void 0;
+const whereScopes_1 = require("../../queryBuilder/whereScopes");
+const ManyToManyFindOperation_1 = require("./find/ManyToManyFindOperation");
 // This mixin contains the shared code for all modify operations (update, delete, relate, unrelate)
 // for ManyToManyRelation operations.
 //
@@ -11,6 +13,7 @@ const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
 // table columns.
 const ManyToManyModifyMixin = (Operation) => {
     return class extends Operation {
+        // The arguments of the operation class this mixin is applied to.
         constructor(...args) {
             super(...args);
             this.modifyFilterSubquery = null;
@@ -26,7 +29,7 @@ const ManyToManyModifyMixin = (Operation) => {
                 // We can now remove the where and join statements from the main query.
                 this.removeFiltersFromMainQuery(builder);
                 // Add a single where clause that uses the created subquery.
-                withWhereScope(builder, () => this.applyModifyFilterForRelatedTable(builder));
+                (0, whereScopes_1.withWhereScope)(builder, () => this.applyModifyFilterForRelatedTable(builder));
             }
             return super.onBuild(builder);
         }
@@ -65,7 +68,7 @@ const ManyToManyModifyMixin = (Operation) => {
                 .whereInComposite(joinTableOwnerRefs, ownerValues);
         }
         toFindOperation() {
-            return new ManyToManyFindOperation('find', {
+            return new ManyToManyFindOperation_1.ManyToManyFindOperation('find', {
                 relation: this.relation,
                 owner: this.owner,
             });
@@ -77,6 +80,4 @@ const ManyToManyModifyMixin = (Operation) => {
         }
     };
 };
-module.exports = {
-    ManyToManyModifyMixin,
-};
+exports.ManyToManyModifyMixin = ManyToManyModifyMixin;

package/lib/relations/manyToMany/ManyToManyRelation.js

@@ -1,24 +1,26 @@
-'use strict';
-const { withWhereScope } = require('../../queryBuilder/whereScopes');
-const { getModel } = require('../../model/getModel');
-const { Relation } = require('../Relation');
-const { RelationProperty } = require('../RelationProperty');
-const { isSqlite } = require('../../utils/knexUtils');
-const { inheritModel } = require('../../model/inheritModel');
-const { resolveModel } = require('../../utils/resolveModel');
-const { mapAfterAllReturn } = require('../../utils/promiseUtils');
-const { isFunction, isObject, isString } = require('../../utils/objectUtils');
-const { createModifier } = require('../../utils/createModifier');
-const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
-const { ManyToManyInsertOperation } = require('./insert/ManyToManyInsertOperation');
-const { ManyToManyRelateOperation } = require('./relate/ManyToManyRelateOperation');
-const { ManyToManyUnrelateOperation } = require('./unrelate/ManyToManyUnrelateOperation');
-const { ManyToManyUnrelateSqliteOperation, } = require('./unrelate/ManyToManyUnrelateSqliteOperation');
-const { ManyToManyUpdateOperation } = require('./update/ManyToManyUpdateOperation');
-const { ManyToManyUpdateSqliteOperation } = require('./update/ManyToManyUpdateSqliteOperation');
-const { ManyToManyDeleteOperation } = require('./delete/ManyToManyDeleteOperation');
-const { ManyToManyDeleteSqliteOperation } = require('./delete/ManyToManyDeleteSqliteOperation');
-class ManyToManyRelation extends Relation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManyRelation = void 0;
+const whereScopes_1 = require("../../queryBuilder/whereScopes");
+const getModel_1 = require("../../model/getModel");
+const Relation_1 = require("../Relation");
+const RelationProperty_1 = require("../RelationProperty");
+const knexUtils_1 = require("../../utils/knexUtils");
+const inheritModel_1 = require("../../model/inheritModel");
+const resolveModel_1 = require("../../utils/resolveModel");
+const promiseUtils_1 = require("../../utils/promiseUtils");
+const objectUtils_1 = require("../../utils/objectUtils");
+const createModifier_1 = require("../../utils/createModifier");
+const ManyToManyFindOperation_1 = require("./find/ManyToManyFindOperation");
+const ManyToManyInsertOperation_1 = require("./insert/ManyToManyInsertOperation");
+const ManyToManyRelateOperation_1 = require("./relate/ManyToManyRelateOperation");
+const ManyToManyUnrelateOperation_1 = require("./unrelate/ManyToManyUnrelateOperation");
+const ManyToManyUnrelateSqliteOperation_1 = require("./unrelate/ManyToManyUnrelateSqliteOperation");
+const ManyToManyUpdateOperation_1 = require("./update/ManyToManyUpdateOperation");
+const ManyToManyUpdateSqliteOperation_1 = require("./update/ManyToManyUpdateSqliteOperation");
+const ManyToManyDeleteOperation_1 = require("./delete/ManyToManyDeleteOperation");
+const ManyToManyDeleteSqliteOperation_1 = require("./delete/ManyToManyDeleteSqliteOperation");
+class ManyToManyRelation extends Relation_1.Relation {
     setMapping(mapping) {
         const retVal = super.setMapping(mapping);
         let ctx = {
@@ -71,7 +73,7 @@ class ManyToManyRelation extends Relation {
                 join.on(relatedRef, joinTableRelatedRef);
             });
         });
-        withWhereScope(builder, () => {
+        (0, whereScopes_1.withWhereScope)(builder, () => {
             owner.buildFindQuery(builder, this, joinTableOwnerRefs);
         });
         return this.applyModify(builder);
@@ -109,41 +111,41 @@ class ManyToManyRelation extends Relation {
         });
     }
     find(_, owner) {
-        return new ManyToManyFindOperation('find', {
+        return new ManyToManyFindOperation_1.ManyToManyFindOperation('find', {
             relation: this,
             owner,
         });
     }
     insert(_, owner) {
-        return new ManyToManyInsertOperation('insert', {
+        return new ManyToManyInsertOperation_1.ManyToManyInsertOperation('insert', {
             relation: this,
             owner,
         });
     }
     update(builder, owner) {
-        if (isSqlite(builder.knex())) {
-            return new ManyToManyUpdateSqliteOperation('update', {
+        if ((0, knexUtils_1.isSqlite)(builder.knex())) {
+            return new ManyToManyUpdateSqliteOperation_1.ManyToManyUpdateSqliteOperation('update', {
                 relation: this,
                 owner,
             });
         }
         else {
-            return new ManyToManyUpdateOperation('update', {
+            return new ManyToManyUpdateOperation_1.ManyToManyUpdateOperation('update', {
                 relation: this,
                 owner,
             });
         }
     }
     patch(builder, owner) {
-        if (isSqlite(builder.knex())) {
-            return new ManyToManyUpdateSqliteOperation('patch', {
+        if ((0, knexUtils_1.isSqlite)(builder.knex())) {
+            return new ManyToManyUpdateSqliteOperation_1.ManyToManyUpdateSqliteOperation('patch', {
                 modelOptions: { patch: true },
                 relation: this,
                 owner,
             });
         }
         else {
-            return new ManyToManyUpdateOperation('patch', {
+            return new ManyToManyUpdateOperation_1.ManyToManyUpdateOperation('patch', {
                 modelOptions: { patch: true },
                 relation: this,
                 owner,
@@ -151,34 +153,34 @@ class ManyToManyRelation extends Relation {
         }
     }
     delete(builder, owner) {
-        if (isSqlite(builder.knex())) {
-            return new ManyToManyDeleteSqliteOperation('delete', {
+        if ((0, knexUtils_1.isSqlite)(builder.knex())) {
+            return new ManyToManyDeleteSqliteOperation_1.ManyToManyDeleteSqliteOperation('delete', {
                 relation: this,
                 owner,
             });
         }
         else {
-            return new ManyToManyDeleteOperation('delete', {
+            return new ManyToManyDeleteOperation_1.ManyToManyDeleteOperation('delete', {
                 relation: this,
                 owner,
             });
         }
     }
     relate(builder, owner) {
-        return new ManyToManyRelateOperation('relate', {
+        return new ManyToManyRelateOperation_1.ManyToManyRelateOperation('relate', {
             relation: this,
             owner,
         });
     }
     unrelate(builder, owner) {
-        if (isSqlite(builder.knex())) {
-            return new ManyToManyUnrelateSqliteOperation('unrelate', {
+        if ((0, knexUtils_1.isSqlite)(builder.knex())) {
+            return new ManyToManyUnrelateSqliteOperation_1.ManyToManyUnrelateSqliteOperation('unrelate', {
                 relation: this,
                 owner,
             });
         }
         else {
-            return new ManyToManyUnrelateOperation('unrelate', {
+            return new ManyToManyUnrelateOperation_1.ManyToManyUnrelateOperation('unrelate', {
                 relation: this,
                 owner,
             });
@@ -187,6 +189,7 @@ class ManyToManyRelation extends Relation {
     createJoinModels(ownerId, related) {
         return related.map((related) => this.createJoinModel(ownerId, related));
     }
+    // `rel` is a related model, or an id object (see ManyToManyRelateOperation).
     createJoinModel(ownerId, rel) {
         const joinModel = {};
         for (let j = 0, lp = this.joinTableOwnerProp.size; j < lp; ++j) {
@@ -220,9 +223,10 @@ class ManyToManyRelation extends Relation {
         }
     }
     executeJoinTableBeforeInsert(models, queryContext, result) {
-        return mapAfterAllReturn(models, (model) => this.joinTableBeforeInsert(model, queryContext), result);
+        return (0, promiseUtils_1.mapAfterAllReturn)(models, (model) => this.joinTableBeforeInsert(model, queryContext), result);
     }
 }
+exports.ManyToManyRelation = ManyToManyRelation;
 Object.defineProperties(ManyToManyRelation.prototype, {
     isObjectionManyToManyRelation: {
         enumerable: false,
@@ -264,7 +268,7 @@ function aliasedTableName(tableName, alias) {
 }
 function checkThroughObject(ctx) {
     const mapping = ctx.mapping;
-    if (!isObject(mapping.join.through)) {
+    if (!(0, objectUtils_1.isObject)(mapping.join.through)) {
         throw ctx.createError('join must have a `through` object that describes the join table.');
     }
     if (!mapping.join.through.from || !mapping.join.through.to) {
@@ -276,7 +280,9 @@ function resolveJoinModelClassIfDefined(ctx) {
     let joinTableModelClass = null;
     if (ctx.mapping.join.through.modelClass) {
         try {
-            joinTableModelClass = resolveModel(ctx.mapping.join.through.modelClass, ctx.ownerModelClass.modelPaths, 'join.through.modelClass');
+            // undefined only for a relative path without `modelPaths`, which then
+            // fails further on, as it did in the JavaScript code.
+            joinTableModelClass = (0, resolveModel_1.resolveModel)(ctx.mapping.join.through.modelClass, ctx.ownerModelClass.modelPaths, 'join.through.modelClass');
         }
         catch (err) {
             throw ctx.createError(err.message);
@@ -317,7 +323,7 @@ function createRelationProperty(ctx, refString, messagePrefix) {
     let joinTableModelClass = ctx.joinTableModelClass;
     const resolveModelClass = (table) => {
         if (joinTableModelClass === null) {
-            joinTableModelClass = inheritModel(getModel());
+            joinTableModelClass = (0, inheritModel_1.inheritModel)((0, getModel_1.getModel)());
             joinTableModelClass.tableName = table;
             joinTableModelClass.idColumn = null;
             joinTableModelClass.concurrency = ctx.ownerModelClass.concurrency;
@@ -330,10 +336,10 @@ function createRelationProperty(ctx, refString, messagePrefix) {
         }
     };
     try {
-        prop = new RelationProperty(refString, resolveModelClass);
+        prop = new RelationProperty_1.RelationProperty(refString, resolveModelClass);
     }
     catch (err) {
-        if (err instanceof RelationProperty.ModelNotFoundError) {
+        if (err instanceof RelationProperty_1.RelationProperty.ModelNotFoundError) {
             throw ctx.createError('join.through `from` and `to` must point to the same join table.');
         }
         else {
@@ -350,7 +356,7 @@ function parseExtras(ctx) {
     if (!extraDef) {
         return ctx;
     }
-    if (isString(extraDef)) {
+    if ((0, objectUtils_1.isString)(extraDef)) {
         extraDef = {
             [extraDef]: extraDef,
         };
@@ -376,7 +382,7 @@ function parseModify(ctx) {
     const mapping = ctx.mapping.join.through;
     const modifier = mapping.modify || mapping.filter;
     const joinTableModify = modifier &&
-        createModifier({
+        (0, createModifier_1.createModifier)({
             modifier,
             modelClass: ctx.relatedModelClass,
         });
@@ -384,7 +390,7 @@ function parseModify(ctx) {
 }
 function parseBeforeInsert(ctx) {
     let joinTableBeforeInsert;
-    if (isFunction(ctx.mapping.join.through.beforeInsert)) {
+    if ((0, objectUtils_1.isFunction)(ctx.mapping.join.through.beforeInsert)) {
         joinTableBeforeInsert = ctx.mapping.join.through.beforeInsert;
     }
     else {
@@ -400,6 +406,3 @@ function finalizeJoinModelClass(ctx) {
     }
     return ctx;
 }
-module.exports = {
-    ManyToManyRelation,
-};

package/lib/relations/manyToMany/ManyToManySqliteModifyMixin.js

@@ -1,11 +1,13 @@
-'use strict';
-const { ManyToManyModifyMixin } = require('./ManyToManyModifyMixin');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManyToManySqliteModifyMixin = void 0;
+const ManyToManyModifyMixin_1 = require("./ManyToManyModifyMixin");
 const SQLITE_BUILTIN_ROW_ID = '_rowid_';
 // We need to override this mixin for sqlite because sqlite doesn't support
 // multi-column where in statements with subqueries. We need to use the
 // internal _rowid_ column instead.
 const ManyToManySqliteModifyMixin = (Operation) => {
-    return class extends ManyToManyModifyMixin(Operation) {
+    return class extends (0, ManyToManyModifyMixin_1.ManyToManyModifyMixin)(Operation) {
         applyModifyFilterForRelatedTable(builder) {
             const tableRef = builder.tableRefFor(this.relation.relatedModelClass);
             const rowIdRef = `${tableRef}.${SQLITE_BUILTIN_ROW_ID}`;
@@ -24,6 +26,4 @@ const ManyToManySqliteModifyMixin = (Operation) => {
         }
     };
 };
-module.exports = {
-    ManyToManySqliteModifyMixin,
-};
+exports.ManyToManySqliteModifyMixin = ManyToManySqliteModifyMixin;