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

package/lib/relations/RelationDeleteOperation.js

@@ -1,29 +1,23 @@
 'use strict';
-
 const { DeleteOperation } = require('../queryBuilder/operations/DeleteOperation');
 const { RelationFindOperation } = require('./RelationFindOperation');
-
 class RelationDeleteOperation extends DeleteOperation {
-  constructor(name, opt) {
-    super(name, opt);
-
-    this.relation = opt.relation;
-    this.owner = opt.owner;
-  }
-
-  onBuild(builder) {
-    super.onBuild(builder);
-    this.relation.findQuery(builder, this.owner);
-  }
-
-  toFindOperation() {
-    return new RelationFindOperation('find', {
-      relation: this.relation,
-      owner: this.owner,
-    });
-  }
+    constructor(name, opt) {
+        super(name, opt);
+        this.relation = opt.relation;
+        this.owner = opt.owner;
+    }
+    onBuild(builder) {
+        super.onBuild(builder);
+        this.relation.findQuery(builder, this.owner);
+    }
+    toFindOperation() {
+        return new RelationFindOperation('find', {
+            relation: this.relation,
+            owner: this.owner,
+        });
+    }
 }
-
 module.exports = {
-  RelationDeleteOperation,
+    RelationDeleteOperation,
 };

package/lib/relations/RelationFindOperation.js

@@ -1,149 +1,116 @@
 'use strict';
-
 const { FindOperation } = require('../queryBuilder/operations/FindOperation');
-
 class RelationFindOperation extends FindOperation {
-  constructor(name, opt) {
-    super(name, opt);
-
-    this.relation = opt.relation;
-    this.owner = opt.owner;
-    this.alwaysReturnArray = false;
-    this.assignResultToOwner = true;
-    this.relationProperty = opt.relationProperty || this.relation.name;
-    this.omitProps = [];
-    this.alias = null;
-  }
-
-  onBuild(builder) {
-    this.maybeApplyAlias(builder);
-    this.relation.findQuery(builder, this.owner);
-
-    if (this.assignResultToOwner && this.owner.isModels) {
-      this.selectMissingJoinColumns(builder);
+    constructor(name, opt) {
+        super(name, opt);
+        this.relation = opt.relation;
+        this.owner = opt.owner;
+        this.alwaysReturnArray = false;
+        this.assignResultToOwner = true;
+        this.relationProperty = opt.relationProperty || this.relation.name;
+        this.omitProps = [];
+        this.alias = null;
     }
-  }
-
-  onAfter2(_, related) {
-    const isOneToOne = this.relation.isOneToOne();
-
-    if (this.assignResultToOwner && this.owner.isModels) {
-      const owners = this.owner.modelArray;
-      const relatedByOwnerId = new Map();
-
-      for (let i = 0, l = related.length; i < l; ++i) {
-        const rel = related[i];
-        const key = this.relation.relatedProp.propKey(rel);
-        let arr = relatedByOwnerId.get(key);
-
-        if (!arr) {
-          arr = [];
-          relatedByOwnerId.set(key, arr);
+    onBuild(builder) {
+        this.maybeApplyAlias(builder);
+        this.relation.findQuery(builder, this.owner);
+        if (this.assignResultToOwner && this.owner.isModels) {
+            this.selectMissingJoinColumns(builder);
         }
-
-        arr.push(rel);
-      }
-
-      for (let i = 0, l = owners.length; i < l; ++i) {
-        const own = owners[i];
-        const key = this.relation.ownerProp.propKey(own);
-        const related = relatedByOwnerId.get(key);
-
-        if (isOneToOne) {
-          own[this.relationProperty] = (related && related[0]) || null;
-        } else {
-          own[this.relationProperty] = related || [];
-        }
-      }
-    }
-
-    return related;
-  }
-
-  onAfter3(builder, related) {
-    const isOneToOne = this.relation.isOneToOne();
-    const intOpt = builder.internalOptions();
-
-    if (!intOpt.keepImplicitJoinProps) {
-      this.omitImplicitJoinProps(related);
-    }
-
-    if (!this.alwaysReturnArray && isOneToOne && related.length <= 1) {
-      related = related[0] || undefined;
-    }
-
-    return super.onAfter3(builder, related);
-  }
-
-  selectMissingJoinColumns(builder) {
-    const relatedProp = this.relation.relatedProp;
-    const addedSelects = [];
-
-    for (let c = 0, lc = relatedProp.size; c < lc; ++c) {
-      const fullCol = relatedProp.ref(builder, c).fullColumn(builder);
-      const prop = relatedProp.props[c];
-      const col = relatedProp.cols[c];
-
-      if (!builder.hasSelectionAs(fullCol, col) && addedSelects.indexOf(fullCol) === -1) {
-        this.omitProps.push(prop);
-        addedSelects.push(fullCol);
-      }
     }
-
-    if (addedSelects.length) {
-      builder.select(addedSelects);
+    onAfter2(_, related) {
+        const isOneToOne = this.relation.isOneToOne();
+        if (this.assignResultToOwner && this.owner.isModels) {
+            const owners = this.owner.modelArray;
+            const relatedByOwnerId = new Map();
+            for (let i = 0, l = related.length; i < l; ++i) {
+                const rel = related[i];
+                const key = this.relation.relatedProp.propKey(rel);
+                let arr = relatedByOwnerId.get(key);
+                if (!arr) {
+                    arr = [];
+                    relatedByOwnerId.set(key, arr);
+                }
+                arr.push(rel);
+            }
+            for (let i = 0, l = owners.length; i < l; ++i) {
+                const own = owners[i];
+                const key = this.relation.ownerProp.propKey(own);
+                const related = relatedByOwnerId.get(key);
+                if (isOneToOne) {
+                    own[this.relationProperty] = (related && related[0]) || null;
+                }
+                else {
+                    own[this.relationProperty] = related || [];
+                }
+            }
+        }
+        return related;
     }
-  }
-
-  maybeApplyAlias(builder) {
-    if (!builder.alias() && this.alias) {
-      builder.alias(this.alias);
+    onAfter3(builder, related) {
+        const isOneToOne = this.relation.isOneToOne();
+        const intOpt = builder.internalOptions();
+        if (!intOpt.keepImplicitJoinProps) {
+            this.omitImplicitJoinProps(related);
+        }
+        if (!this.alwaysReturnArray && isOneToOne && related.length <= 1) {
+            related = related[0] || undefined;
+        }
+        return super.onAfter3(builder, related);
     }
-  }
-
-  omitImplicitJoinProps(related) {
-    const relatedModelClass = this.relation.relatedModelClass;
-
-    if (!this.omitProps.length || !related) {
-      return related;
+    selectMissingJoinColumns(builder) {
+        const relatedProp = this.relation.relatedProp;
+        const addedSelects = [];
+        for (let c = 0, lc = relatedProp.size; c < lc; ++c) {
+            const fullCol = relatedProp.ref(builder, c).fullColumn(builder);
+            const prop = relatedProp.props[c];
+            const col = relatedProp.cols[c];
+            if (!builder.hasSelectionAs(fullCol, col) && addedSelects.indexOf(fullCol) === -1) {
+                this.omitProps.push(prop);
+                addedSelects.push(fullCol);
+            }
+        }
+        if (addedSelects.length) {
+            builder.select(addedSelects);
+        }
     }
-
-    if (!Array.isArray(related)) {
-      return this.omitImplicitJoinPropsFromOne(relatedModelClass, related);
+    maybeApplyAlias(builder) {
+        if (!builder.alias() && this.alias) {
+            builder.alias(this.alias);
+        }
     }
-
-    if (!related.length) {
-      return related;
+    omitImplicitJoinProps(related) {
+        const relatedModelClass = this.relation.relatedModelClass;
+        if (!this.omitProps.length || !related) {
+            return related;
+        }
+        if (!Array.isArray(related)) {
+            return this.omitImplicitJoinPropsFromOne(relatedModelClass, related);
+        }
+        if (!related.length) {
+            return related;
+        }
+        for (let i = 0, l = related.length; i < l; ++i) {
+            this.omitImplicitJoinPropsFromOne(relatedModelClass, related[i]);
+        }
+        return related;
     }
-
-    for (let i = 0, l = related.length; i < l; ++i) {
-      this.omitImplicitJoinPropsFromOne(relatedModelClass, related[i]);
+    omitImplicitJoinPropsFromOne(relatedModelClass, model) {
+        for (let c = 0, lc = this.omitProps.length; c < lc; ++c) {
+            relatedModelClass.omitImpl(model, this.omitProps[c]);
+        }
+        return model;
     }
-
-    return related;
-  }
-
-  omitImplicitJoinPropsFromOne(relatedModelClass, model) {
-    for (let c = 0, lc = this.omitProps.length; c < lc; ++c) {
-      relatedModelClass.omitImpl(model, this.omitProps[c]);
+    clone() {
+        const clone = super.clone();
+        clone.alwaysReturnArray = this.alwaysReturnArray;
+        clone.assignResultToOwner = this.assignResultToOwner;
+        clone.relationProperty = this.relationProperty;
+        clone.omitProps = this.omitProps.slice();
+        clone.alias = this.alias;
+        return clone;
     }
-
-    return model;
-  }
-
-  clone() {
-    const clone = super.clone();
-
-    clone.alwaysReturnArray = this.alwaysReturnArray;
-    clone.assignResultToOwner = this.assignResultToOwner;
-    clone.relationProperty = this.relationProperty;
-    clone.omitProps = this.omitProps.slice();
-    clone.alias = this.alias;
-
-    return clone;
-  }
 }
-
 module.exports = {
-  RelationFindOperation,
+    RelationFindOperation,
 };

package/lib/relations/RelationInsertOperation.js

@@ -1,33 +1,25 @@
 'use strict';
-
 const { InsertOperation } = require('../queryBuilder/operations/InsertOperation');
-
 class RelationInsertOperation extends InsertOperation {
-  constructor(name, opt) {
-    super(name, opt);
-
-    this.relation = opt.relation;
-    this.owner = opt.owner;
-    this.assignResultToOwner = true;
-  }
-
-  async onBefore2(builder, result) {
-    const queryContext = builder.context();
-    result = await this.relation.executeBeforeInsert(this.models, queryContext, result);
-    return super.onBefore2(builder, result);
-  }
-
-  clone() {
-    const clone = super.clone();
-
-    clone.relation = this.relation;
-    clone.owner = this.owner;
-    clone.assignResultToOwner = this.assignResultToOwner;
-
-    return clone;
-  }
+    constructor(name, opt) {
+        super(name, opt);
+        this.relation = opt.relation;
+        this.owner = opt.owner;
+        this.assignResultToOwner = true;
+    }
+    async onBefore2(builder, result) {
+        const queryContext = builder.context();
+        result = await this.relation.executeBeforeInsert(this.models, queryContext, result);
+        return super.onBefore2(builder, result);
+    }
+    clone() {
+        const clone = super.clone();
+        clone.relation = this.relation;
+        clone.owner = this.owner;
+        clone.assignResultToOwner = this.assignResultToOwner;
+        return clone;
+    }
 }
-
 module.exports = {
-  RelationInsertOperation,
+    RelationInsertOperation,
 };