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

package/lib/relations/Relation.js

@@ -1,13 +1,15 @@
-'use strict';
-const { withWhereScope } = require('../queryBuilder/whereScopes');
-const { RelationProperty } = require('./RelationProperty');
-const { RelationFindOperation } = require('./RelationFindOperation');
-const { RelationUpdateOperation } = require('./RelationUpdateOperation');
-const { RelationDeleteOperation } = require('./RelationDeleteOperation');
-const { resolveModel } = require('../utils/resolveModel');
-const { get, isFunction } = require('../utils/objectUtils');
-const { mapAfterAllReturn } = require('../utils/promiseUtils');
-const { createModifier } = require('../utils/createModifier');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Relation = void 0;
+const whereScopes_1 = require("../queryBuilder/whereScopes");
+const RelationProperty_1 = require("./RelationProperty");
+const RelationFindOperation_1 = require("./RelationFindOperation");
+const RelationUpdateOperation_1 = require("./RelationUpdateOperation");
+const RelationDeleteOperation_1 = require("./RelationDeleteOperation");
+const resolveModel_1 = require("../utils/resolveModel");
+const objectUtils_1 = require("../utils/objectUtils");
+const promiseUtils_1 = require("../utils/promiseUtils");
+const createModifier_1 = require("../utils/createModifier");
 class Relation {
     constructor(relationName, OwnerClass) {
         this.name = relationName;
@@ -92,7 +94,7 @@ class Relation {
     }
     findQuery(builder, owner) {
         const relatedRefs = this.relatedProp.refs(builder);
-        withWhereScope(builder, () => {
+        (0, whereScopes_1.withWhereScope)(builder, () => {
             owner.buildFindQuery(builder, this, relatedRefs);
         });
         return this.applyModify(builder);
@@ -101,7 +103,7 @@ class Relation {
         try {
             // The relation's `modify` gets its own scope so that an `orWhere`
             // in it can't escape the owner condition.
-            return withWhereScope(builder, () => builder.modify(this.modify));
+            return (0, whereScopes_1.withWhereScope)(builder, () => builder.modify(this.modify));
         }
         catch (err) {
             if (err instanceof this.relatedModelClass.ModifierNotFoundError) {
@@ -129,7 +131,7 @@ class Relation {
         });
     }
     find(_, owner) {
-        return new RelationFindOperation('find', {
+        return new RelationFindOperation_1.RelationFindOperation('find', {
             relation: this,
             owner,
         });
@@ -139,20 +141,20 @@ class Relation {
         throw this.createError('not implemented');
     }
     update(_, owner) {
-        return new RelationUpdateOperation('update', {
+        return new RelationUpdateOperation_1.RelationUpdateOperation('update', {
             relation: this,
             owner,
         });
     }
     patch(_, owner) {
-        return new RelationUpdateOperation('patch', {
+        return new RelationUpdateOperation_1.RelationUpdateOperation('patch', {
             relation: this,
             owner,
             modelOptions: { patch: true },
         });
     }
     delete(_, owner) {
-        return new RelationDeleteOperation('delete', {
+        return new RelationDeleteOperation_1.RelationDeleteOperation('delete', {
             relation: this,
             owner,
         });
@@ -174,7 +176,7 @@ class Relation {
         });
     }
     executeBeforeInsert(models, queryContext, result) {
-        return mapAfterAllReturn(models, (model) => this.beforeInsert(model, queryContext), result);
+        return (0, promiseUtils_1.mapAfterAllReturn)(models, (model) => this.beforeInsert(model, queryContext), result);
     }
     createError(message) {
         if (this.ownerModelClass && this.ownerModelClass.name && this.name) {
@@ -185,6 +187,7 @@ class Relation {
         }
     }
 }
+exports.Relation = Relation;
 Object.defineProperties(Relation, {
     isObjectionRelationClass: {
         enumerable: false,
@@ -201,14 +204,14 @@ Object.defineProperties(Relation.prototype, {
 });
 function checkForbiddenProperties(ctx) {
     ctx.forbiddenMappingProperties.forEach((prop) => {
-        if (get(ctx.mapping, prop.split('.')) !== undefined) {
+        if ((0, objectUtils_1.get)(ctx.mapping, prop.split('.')) !== undefined) {
             throw ctx.createError(`Property ${prop} is not supported for this relation type.`);
         }
     });
     return ctx;
 }
 function checkOwnerModelClass(ctx) {
-    if (!isFunction(ctx.ownerModelClass) || !ctx.ownerModelClass.isObjectionModelClass) {
+    if (!(0, objectUtils_1.isFunction)(ctx.ownerModelClass) || !ctx.ownerModelClass.isObjectionModelClass) {
         throw ctx.createError(`Relation's owner is not a subclass of Model`);
     }
     return ctx;
@@ -222,7 +225,9 @@ function checkRelatedModelClass(ctx) {
 function resolveRelatedModelClass(ctx) {
     let relatedModelClass;
     try {
-        relatedModelClass = resolveModel(ctx.mapping.modelClass, ctx.ownerModelClass.modelPaths, 'modelClass');
+        // undefined only for a relative path without `modelPaths`, which then
+        // fails further on, as it did in the JavaScript code.
+        relatedModelClass = (0, resolveModel_1.resolveModel)(ctx.mapping.modelClass, ctx.ownerModelClass.modelPaths, 'modelClass');
     }
     catch (err) {
         throw ctx.createError(err.message);
@@ -233,7 +238,7 @@ function checkRelation(ctx) {
     if (!ctx.mapping.relation) {
         throw ctx.createError('relation is not defined');
     }
-    if (!isFunction(ctx.mapping.relation) || !ctx.mapping.relation.isObjectionRelationClass) {
+    if (!(0, objectUtils_1.isFunction)(ctx.mapping.relation) || !ctx.mapping.relation.isObjectionRelationClass) {
         throw ctx.createError('relation is not a subclass of Relation');
     }
     return ctx;
@@ -268,15 +273,15 @@ function createJoinProperties(ctx) {
 }
 function createRelationProperty(ctx, refString, propName) {
     try {
-        return new RelationProperty(refString, (table) => {
+        return new RelationProperty_1.RelationProperty(refString, (table) => {
             return [ctx.ownerModelClass, ctx.relatedModelClass].find((it) => it.getTableName() === table);
         });
     }
     catch (err) {
-        if (err instanceof RelationProperty.ModelNotFoundError) {
+        if (err instanceof RelationProperty_1.RelationProperty.ModelNotFoundError) {
             throw ctx.createError(`join: either \`from\` or \`to\` must point to the owner model table and the other one to the related table. It might be that specified table '${err.tableName}' is not correct`);
         }
-        else if (err instanceof RelationProperty.InvalidReferenceError) {
+        else if (err instanceof RelationProperty_1.RelationProperty.InvalidReferenceError) {
             throw ctx.createError(`${propName} must have format TableName.columnName. For example "SomeTable.id" or in case of composite key ["SomeTable.a", "SomeTable.b"].`);
         }
         else {
@@ -288,7 +293,7 @@ function parseModify(ctx) {
     const mapping = ctx.mapping;
     const modifier = mapping.modify || mapping.filter;
     const modify = modifier &&
-        createModifier({
+        (0, createModifier_1.createModifier)({
             modifier,
             modelClass: ctx.relatedModelClass,
         });
@@ -296,7 +301,7 @@ function parseModify(ctx) {
 }
 function parseBeforeInsert(ctx) {
     let beforeInsert;
-    if (isFunction(ctx.mapping.beforeInsert)) {
+    if ((0, objectUtils_1.isFunction)(ctx.mapping.beforeInsert)) {
         beforeInsert = ctx.mapping.beforeInsert;
     }
     else {
@@ -312,6 +317,3 @@ function aliasedTableName(tableName, alias) {
         return `${tableName} as ${alias}`;
     }
 }
-module.exports = {
-    Relation,
-};

package/lib/relations/RelationDeleteOperation.js

@@ -1,8 +1,11 @@
-'use strict';
-const { DeleteOperation } = require('../queryBuilder/operations/DeleteOperation');
-const { RelationFindOperation } = require('./RelationFindOperation');
-class RelationDeleteOperation extends DeleteOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationDeleteOperation = void 0;
+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;
@@ -11,13 +14,12 @@ class RelationDeleteOperation extends 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('find', {
+        return new RelationFindOperation_1.RelationFindOperation('find', {
             relation: this.relation,
             owner: this.owner,
         });
     }
 }
-module.exports = {
-    RelationDeleteOperation,
-};
+exports.RelationDeleteOperation = RelationDeleteOperation;

package/lib/relations/RelationFindOperation.js

@@ -1,7 +1,10 @@
-'use strict';
-const { FindOperation } = require('../queryBuilder/operations/FindOperation');
-class RelationFindOperation extends FindOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
@@ -47,6 +50,8 @@ class RelationFindOperation extends FindOperation {
         }
         return related;
     }
+    // `related` is the array of the found models. It becomes a single model
+    // (or undefined) for one-to-one relations.
     onAfter3(builder, related) {
         const isOneToOne = this.relation.isOneToOne();
         const intOpt = builder.internalOptions();
@@ -111,6 +116,4 @@ class RelationFindOperation extends FindOperation {
         return clone;
     }
 }
-module.exports = {
-    RelationFindOperation,
-};
+exports.RelationFindOperation = RelationFindOperation;

package/lib/relations/RelationInsertOperation.js

@@ -1,6 +1,8 @@
-'use strict';
-const { InsertOperation } = require('../queryBuilder/operations/InsertOperation');
-class RelationInsertOperation extends InsertOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationInsertOperation = void 0;
+const InsertOperation_1 = require("../queryBuilder/operations/InsertOperation");
+class RelationInsertOperation extends InsertOperation_1.InsertOperation {
     constructor(name, opt) {
         super(name, opt);
         this.relation = opt.relation;
@@ -20,6 +22,4 @@ class RelationInsertOperation extends InsertOperation {
         return clone;
     }
 }
-module.exports = {
-    RelationInsertOperation,
-};
+exports.RelationInsertOperation = RelationInsertOperation;

package/lib/relations/RelationOwner.js

@@ -1,6 +1,8 @@
-'use strict';
-const { isObject, asArray, asSingle, uniqBy } = require('../utils/objectUtils');
-const { normalizeIds } = require('../utils/normalizeIds');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationOwner = void 0;
+const objectUtils_1 = require("../utils/objectUtils");
+const normalizeIds_1 = require("../utils/normalizeIds");
 const Type = {
     Models: 'Models',
     Reference: 'Reference',
@@ -31,10 +33,10 @@ class RelationOwner {
         return this.type === Type.Identifiers;
     }
     get modelArray() {
-        return asArray(this.owner);
+        return (0, objectUtils_1.asArray)(this.owner);
     }
     get model() {
-        return asSingle(this.owner);
+        return (0, objectUtils_1.asSingle)(this.owner);
     }
     get reference() {
         return this.owner;
@@ -65,6 +67,8 @@ class RelationOwner {
         }
         return builder;
     }
+    // Returns an array of value arrays (one per owner), or a query builder
+    // that selects them.
     getProps(relation, ownerProp = relation.ownerProp) {
         if (this.isModels) {
             return this._getPropsFromModels(ownerProp);
@@ -97,7 +101,7 @@ class RelationOwner {
         }
     }
     getNormalizedIdentifiers(ownerProp) {
-        return normalizeIds(this.identifiers, ownerProp, {
+        return (0, normalizeIds_1.normalizeIds)(this.identifiers, ownerProp, {
             arrayOutput: true,
         });
     }
@@ -106,7 +110,7 @@ class RelationOwner {
         if (!containsNonNull(props)) {
             return null;
         }
-        return uniqBy(props, join);
+        return (0, objectUtils_1.uniqBy)(props, join);
     }
     _getPropsFromIdentifiers(relation, ownerProp) {
         const ids = this.getNormalizedIdentifiers(ownerProp);
@@ -129,6 +133,7 @@ class RelationOwner {
         return query;
     }
 }
+exports.RelationOwner = RelationOwner;
 function detectType(owner) {
     if (isModel(owner) || isModelArray(owner)) {
         return Type.Models;
@@ -144,19 +149,20 @@ function detectType(owner) {
     }
 }
 function isModel(item) {
-    return isObject(item) && !!item.$isObjectionModel;
+    return (0, objectUtils_1.isObject)(item) && !!item.$isObjectionModel;
 }
 function isModelArray(item) {
     return Array.isArray(item) && isModel(item[0]);
 }
 function isReference(item) {
-    return isObject(item) && !!item.isObjectionReferenceBuilder;
+    return ((0, objectUtils_1.isObject)(item) &&
+        !!item.isObjectionReferenceBuilder);
 }
 function isReferenceArray(item) {
     return Array.isArray(item) && isReference(item[0]);
 }
 function isQueryBuilder(item) {
-    return isObject(item) && !!item.isObjectionQueryBuilder;
+    return ((0, objectUtils_1.isObject)(item) && !!item.isObjectionQueryBuilder);
 }
 function findFirstNonPartialAncestorQuery(builder) {
     builder = builder.parentQuery();
@@ -194,6 +200,3 @@ function isIdProp(relationProp) {
 function isOwnerModelClassQuery(query, relation) {
     return query.modelClass().getTableName() === relation.ownerModelClass.getTableName();
 }
-module.exports = {
-    RelationOwner,
-};

package/lib/relations/RelationProperty.js

@@ -1,7 +1,9 @@
-'use strict';
-const { asArray, isObject, uniqBy, get, set } = require('../utils/objectUtils');
-const { ref: createRef } = require('../queryBuilder/ReferenceBuilder');
-const { propToStr, PROP_KEY_PREFIX } = require('../model/modelValues');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationProperty = void 0;
+const objectUtils_1 = require("../utils/objectUtils");
+const ReferenceBuilder_1 = require("../queryBuilder/ReferenceBuilder");
+const modelValues_1 = require("../model/modelValues");
 class ModelNotFoundError extends Error {
     constructor(tableName) {
         super();
@@ -28,7 +30,7 @@ class RelationProperty {
     // modelClassResolver must be a function that takes a table name
     // and returns a model class.
     constructor(references, modelClassResolver) {
-        const refs = createRefs(asArray(references));
+        const refs = createRefs((0, objectUtils_1.asArray)(references));
         const paths = createPaths(refs, modelClassResolver);
         const modelClass = resolveModelClass(paths);
         this._refs = refs.map((ref) => ref.model(modelClass));
@@ -75,9 +77,9 @@ class RelationProperty {
     // Creates a concatenated string from the property values of the given object.
     propKey(obj) {
         const size = this.size;
-        let key = PROP_KEY_PREFIX;
+        let key = modelValues_1.PROP_KEY_PREFIX;
         for (let i = 0; i < size; ++i) {
-            key += propToStr(this.getProp(obj, i));
+            key += (0, modelValues_1.propToStr)(this.getProp(obj, i));
             if (i !== size - 1) {
                 key += ',';
             }
@@ -135,11 +137,13 @@ class RelationProperty {
         return this._refs[index].expression;
     }
 }
+exports.RelationProperty = RelationProperty;
 function createRefs(refs) {
     try {
         return refs.map((it) => {
-            if (!isObject(it) || !it.isObjectionReferenceBuilder) {
-                return createRef(it);
+            if (!(0, objectUtils_1.isObject)(it) ||
+                !it.isObjectionReferenceBuilder) {
+                return (0, ReferenceBuilder_1.ref)(it);
             }
             else {
                 return it;
@@ -160,6 +164,8 @@ function createPaths(refs, modelClassResolver) {
             throw new ModelNotFoundError(ref.tableName);
         }
         const prop = modelClass.columnNameToPropertyName(ref.column);
+        // A ReferenceBuilder is only unparsed inside clone(), which copies the
+        // parsed expression right after.
         const jsonPath = ref.parsedExpr.access.map((it) => it.ref);
         return {
             path: [prop].concat(jsonPath),
@@ -169,7 +175,7 @@ function createPaths(refs, modelClassResolver) {
 }
 function resolveModelClass(paths) {
     const modelClasses = paths.map((it) => it.modelClass);
-    const uniqueModelClasses = uniqBy(modelClasses);
+    const uniqueModelClasses = (0, objectUtils_1.uniqBy)(modelClasses);
     if (uniqueModelClasses.length !== 1) {
         throw new InvalidReferenceError();
     }
@@ -181,7 +187,7 @@ function createGetter(path) {
         return (obj) => obj[prop];
     }
     else {
-        return (obj) => get(obj, path);
+        return (obj) => (0, objectUtils_1.get)(obj, path);
     }
 }
 function createSetter(path) {
@@ -190,7 +196,7 @@ function createSetter(path) {
         return (obj, value) => (obj[prop] = value);
     }
     else {
-        return (obj, value) => set(obj, path, value);
+        return (obj, value) => (0, objectUtils_1.set)(obj, path, value);
     }
 }
 function createPatcher(ref, path) {
@@ -202,6 +208,3 @@ function createPatcher(ref, path) {
         return (patch, value) => (patch[ref.expression] = value);
     }
 }
-module.exports = {
-    RelationProperty,
-};

package/lib/relations/RelationUpdateOperation.js

@@ -1,7 +1,9 @@
-'use strict';
-const { UpdateOperation } = require('../queryBuilder/operations/UpdateOperation');
-const { RelationFindOperation } = require('./RelationFindOperation');
-class RelationUpdateOperation extends UpdateOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationUpdateOperation = void 0;
+const UpdateOperation_1 = require("../queryBuilder/operations/UpdateOperation");
+const RelationFindOperation_1 = require("./RelationFindOperation");
+class RelationUpdateOperation extends UpdateOperation_1.UpdateOperation {
     constructor(name, opt) {
         super(name, opt);
         this.relation = opt.relation;
@@ -11,13 +13,12 @@ class RelationUpdateOperation extends 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('find', {
+        return new RelationFindOperation_1.RelationFindOperation('find', {
             relation: this.relation,
             owner: this.owner,
         });
     }
 }
-module.exports = {
-    RelationUpdateOperation,
-};
+exports.RelationUpdateOperation = RelationUpdateOperation;

package/lib/relations/belongsToOne/BelongsToOneDeleteOperation.js

@@ -1,6 +1,8 @@
-'use strict';
-const { RelationDeleteOperation } = require('../RelationDeleteOperation');
-class BelongsToOneDeleteOperation extends RelationDeleteOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BelongsToOneDeleteOperation = void 0;
+const RelationDeleteOperation_1 = require("../RelationDeleteOperation");
+class BelongsToOneDeleteOperation extends RelationDeleteOperation_1.RelationDeleteOperation {
     onAfter1(_, result) {
         if (this.owner.isModels) {
             const ownerProp = this.relation.ownerProp;
@@ -13,6 +15,4 @@ class BelongsToOneDeleteOperation extends RelationDeleteOperation {
         return result;
     }
 }
-module.exports = {
-    BelongsToOneDeleteOperation,
-};
+exports.BelongsToOneDeleteOperation = BelongsToOneDeleteOperation;

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,
-};