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

package/lib/queryBuilder/transformations/WrapMysqlModifySubqueryTransformation.js

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

package/lib/queryBuilder/transformations/index.js

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

package/lib/queryBuilder/whereScopes.js

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

package/lib/relations/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,7 +1,9 @@
-'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) {
         super(name, opt);
         this.relation = opt.relation;
@@ -12,12 +14,10 @@ class RelationDeleteOperation extends DeleteOperation {
         this.relation.findQuery(builder, this.owner);
     }
     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,6 +1,8 @@
-'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) {
         super(name, opt);
         this.relation = opt.relation;
@@ -47,6 +49,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 +115,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;
@@ -12,12 +14,10 @@ class RelationUpdateOperation extends UpdateOperation {
         this.relation.findQuery(builder, this.owner);
     }
     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;