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

package/lib/relations/hasOne/HasOneRelation.js

@@ -1,13 +1,10 @@
-'use strict';
-
-const { HasManyRelation } = require('../hasMany/HasManyRelation');
-
-class HasOneRelation extends HasManyRelation {
-  isOneToOne() {
-    return true;
-  }
+"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,13 +1,10 @@
-'use strict';
-
-const { ManyToManyRelation } = require('../manyToMany/ManyToManyRelation');
-
-class HasOneThroughRelation extends ManyToManyRelation {
-  isOneToOne() {
-    return true;
-  }
+"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,8 +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.
 //
@@ -12,94 +12,72 @@ const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
 // joins in updates or deletes. Join table is joined so that queries can reference the join
 // table columns.
 const ManyToManyModifyMixin = (Operation) => {
-  return class extends Operation {
-    constructor(...args) {
-      super(...args);
-      this.modifyFilterSubquery = null;
-    }
-
-    get modifyMainQuery() {
-      return true;
-    }
-
-    // At this point `builder` should only have the user's own wheres and joins. There can
-    // be other operations (like orderBy) too, but those are meaningless with modify operations.
-    onBuild(builder) {
-      this.modifyFilterSubquery = this.createModifyFilterSubquery(builder);
-
-      if (this.modifyMainQuery) {
-        // 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));
-      }
-
-      return super.onBuild(builder);
-    }
-
-    createModifyFilterSubquery(builder) {
-      const relatedModelClass = this.relation.relatedModelClass;
-      const builderClass = builder.constructor;
-
-      // Create an empty subquery.
-      const modifyFilterSubquery = relatedModelClass.query().childQueryOf(builder);
-
-      // Add the necessary joins and wheres so that only rows related to
-      // `this.owner` are selected.
-      this.relation.findQuery(modifyFilterSubquery, this.owner);
-
-      // Copy all where and join statements from the main query to the subquery.
-      modifyFilterSubquery
-        .copyFrom(builder, builderClass.WhereSelector)
-        .copyFrom(builder, builderClass.JoinSelector);
-
-      return modifyFilterSubquery.clearSelect();
-    }
-
-    removeFiltersFromMainQuery(builder) {
-      const builderClass = builder.constructor;
-
-      builder.clear(builderClass.WhereSelector);
-      builder.clear(builderClass.JoinSelector);
-    }
-
-    applyModifyFilterForRelatedTable(builder) {
-      const idRefs = this.relation.relatedModelClass.getIdRelationProperty().refs(builder);
-      const subquery = this.modifyFilterSubquery.clone().select(idRefs);
-
-      return builder.whereInComposite(idRefs, subquery);
-    }
-
-    applyModifyFilterForJoinTable(builder) {
-      const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
-      const joinTableRelatedRefs = this.relation.joinTableRelatedProp.refs(builder);
-
-      const relatedRefs = this.relation.relatedProp.refs(builder);
-      const ownerValues = this.owner.getProps(this.relation);
-
-      const subquery = this.modifyFilterSubquery.clone().select(relatedRefs);
-
-      return builder
-        .whereInComposite(joinTableRelatedRefs, subquery)
-        .whereInComposite(joinTableOwnerRefs, ownerValues);
-    }
-
-    toFindOperation() {
-      return new ManyToManyFindOperation('find', {
-        relation: this.relation,
-        owner: this.owner,
-      });
-    }
-
-    clone() {
-      const clone = super.clone();
-      clone.modifyFilterSubquery = this.modifyFilterSubquery;
-      return clone;
-    }
-  };
-};
-
-module.exports = {
-  ManyToManyModifyMixin,
+    return class extends Operation {
+        // The arguments of the operation class this mixin is applied to.
+        constructor(...args) {
+            super(...args);
+            this.modifyFilterSubquery = null;
+        }
+        get modifyMainQuery() {
+            return true;
+        }
+        // At this point `builder` should only have the user's own wheres and joins. There can
+        // be other operations (like orderBy) too, but those are meaningless with modify operations.
+        onBuild(builder) {
+            this.modifyFilterSubquery = this.createModifyFilterSubquery(builder);
+            if (this.modifyMainQuery) {
+                // 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.
+                (0, whereScopes_1.withWhereScope)(builder, () => this.applyModifyFilterForRelatedTable(builder));
+            }
+            return super.onBuild(builder);
+        }
+        createModifyFilterSubquery(builder) {
+            const relatedModelClass = this.relation.relatedModelClass;
+            const builderClass = builder.constructor;
+            // Create an empty subquery.
+            const modifyFilterSubquery = relatedModelClass.query().childQueryOf(builder);
+            // Add the necessary joins and wheres so that only rows related to
+            // `this.owner` are selected.
+            this.relation.findQuery(modifyFilterSubquery, this.owner);
+            // Copy all where and join statements from the main query to the subquery.
+            modifyFilterSubquery
+                .copyFrom(builder, builderClass.WhereSelector)
+                .copyFrom(builder, builderClass.JoinSelector);
+            return modifyFilterSubquery.clearSelect();
+        }
+        removeFiltersFromMainQuery(builder) {
+            const builderClass = builder.constructor;
+            builder.clear(builderClass.WhereSelector);
+            builder.clear(builderClass.JoinSelector);
+        }
+        applyModifyFilterForRelatedTable(builder) {
+            const idRefs = this.relation.relatedModelClass.getIdRelationProperty().refs(builder);
+            const subquery = this.modifyFilterSubquery.clone().select(idRefs);
+            return builder.whereInComposite(idRefs, subquery);
+        }
+        applyModifyFilterForJoinTable(builder) {
+            const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
+            const joinTableRelatedRefs = this.relation.joinTableRelatedProp.refs(builder);
+            const relatedRefs = this.relation.relatedProp.refs(builder);
+            const ownerValues = this.owner.getProps(this.relation);
+            const subquery = this.modifyFilterSubquery.clone().select(relatedRefs);
+            return builder
+                .whereInComposite(joinTableRelatedRefs, subquery)
+                .whereInComposite(joinTableOwnerRefs, ownerValues);
+        }
+        toFindOperation() {
+            return new ManyToManyFindOperation_1.ManyToManyFindOperation('find', {
+                relation: this.relation,
+                owner: this.owner,
+            });
+        }
+        clone() {
+            const clone = super.clone();
+            clone.modifyFilterSubquery = this.modifyFilterSubquery;
+            return clone;
+        }
+    };
 };
+exports.ManyToManyModifyMixin = ManyToManyModifyMixin;