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

package/lib/relations/belongsToOne/BelongsToOneRelation.js

@@ -1,53 +1,45 @@
 '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 {
-  isOneToOne() {
-    return true;
-  }
-
-  insert(_, owner) {
-    return new BelongsToOneInsertOperation('insert', {
-      relation: this,
-      owner,
-    });
-  }
-
-  delete(_, owner) {
-    return new BelongsToOneDeleteOperation('delete', {
-      relation: this,
-      owner,
-    });
-  }
-
-  relate(_, owner) {
-    return new BelongsToOneRelateOperation('relate', {
-      relation: this,
-      owner,
-    });
-  }
-
-  unrelate(_, owner) {
-    return new BelongsToOneUnrelateOperation('unrelate', {
-      relation: this,
-      owner,
-    });
-  }
+    isOneToOne() {
+        return true;
+    }
+    insert(_, owner) {
+        return new BelongsToOneInsertOperation('insert', {
+            relation: this,
+            owner,
+        });
+    }
+    delete(_, owner) {
+        return new BelongsToOneDeleteOperation('delete', {
+            relation: this,
+            owner,
+        });
+    }
+    relate(_, owner) {
+        return new BelongsToOneRelateOperation('relate', {
+            relation: this,
+            owner,
+        });
+    }
+    unrelate(_, owner) {
+        return new BelongsToOneUnrelateOperation('unrelate', {
+            relation: this,
+            owner,
+        });
+    }
 }
-
 Object.defineProperties(BelongsToOneRelation.prototype, {
-  isObjectionBelongsToOneRelation: {
-    enumerable: false,
-    writable: false,
-    value: true,
-  },
+    isObjectionBelongsToOneRelation: {
+        enumerable: false,
+        writable: false,
+        value: true,
+    },
 });
-
 module.exports = {
-  BelongsToOneRelation,
+    BelongsToOneRelation,
 };

package/lib/relations/belongsToOne/BelongsToOneUnrelateOperation.js

@@ -1,61 +1,46 @@
 'use strict';
-
 const { UnrelateOperation } = require('../../queryBuilder/operations/UnrelateOperation');
-
 class BelongsToOneUnrelateOperation extends UnrelateOperation {
-  onAdd() {
-    const ids = new Array(this.relation.ownerProp.size);
-
-    this.relation.ownerProp.forEach((i) => {
-      ids[i] = null;
-    });
-
-    this.ids = [ids];
-    return true;
-  }
-
-  queryExecutor(builder) {
-    const patch = {};
-    const ownerProp = this.relation.ownerProp;
-
-    ownerProp.forEach((i) => {
-      const relatedValue = this.ids[0][i];
-
-      if (this.owner.isModels) {
-        for (const owner of this.owner.modelArray) {
-          ownerProp.setProp(owner, i, relatedValue);
+    onAdd() {
+        const ids = new Array(this.relation.ownerProp.size);
+        this.relation.ownerProp.forEach((i) => {
+            ids[i] = null;
+        });
+        this.ids = [ids];
+        return true;
+    }
+    queryExecutor(builder) {
+        const patch = {};
+        const ownerProp = this.relation.ownerProp;
+        ownerProp.forEach((i) => {
+            const relatedValue = this.ids[0][i];
+            if (this.owner.isModels) {
+                for (const owner of this.owner.modelArray) {
+                    ownerProp.setProp(owner, i, relatedValue);
+                }
+            }
+            ownerProp.patch(patch, i, relatedValue);
+        });
+        const ownerIdProp = this.relation.ownerModelClass.getIdRelationProperty();
+        const ownerRefs = ownerIdProp.refs(builder);
+        const ownerIds = this.owner.getProps(this.relation, ownerIdProp);
+        const query = this.relation.ownerModelClass
+            .query()
+            .childQueryOf(builder)
+            .patch(patch)
+            .whereInComposite(ownerRefs, ownerIds);
+        // We are creating a query to the related items. So any `where` statements
+        // must filter the *related* items, not the root query above, which is actually
+        // for the owners.
+        if (builder.has(builder.constructor.WhereSelector)) {
+            query.whereExists(this.relation.ownerModelClass
+                .relatedQuery(this.relation.name)
+                .copyFrom(builder, builder.constructor.JoinSelector)
+                .copyFrom(builder, builder.constructor.WhereSelector));
         }
-      }
-
-      ownerProp.patch(patch, i, relatedValue);
-    });
-
-    const ownerIdProp = this.relation.ownerModelClass.getIdRelationProperty();
-    const ownerRefs = ownerIdProp.refs(builder);
-    const ownerIds = this.owner.getProps(this.relation, ownerIdProp);
-
-    const query = this.relation.ownerModelClass
-      .query()
-      .childQueryOf(builder)
-      .patch(patch)
-      .whereInComposite(ownerRefs, ownerIds);
-
-    // We are creating a query to the related items. So any `where` statements
-    // must filter the *related* items, not the root query above, which is actually
-    // for the owners.
-    if (builder.has(builder.constructor.WhereSelector)) {
-      query.whereExists(
-        this.relation.ownerModelClass
-          .relatedQuery(this.relation.name)
-          .copyFrom(builder, builder.constructor.JoinSelector)
-          .copyFrom(builder, builder.constructor.WhereSelector),
-      );
+        return query;
     }
-
-    return query;
-  }
 }
-
 module.exports = {
-  BelongsToOneUnrelateOperation,
+    BelongsToOneUnrelateOperation,
 };

package/lib/relations/hasMany/HasManyInsertOperation.js

@@ -1,61 +1,45 @@
 'use strict';
-
 const { RelationInsertOperation } = require('../RelationInsertOperation');
-
 class HasManyInsertOperation extends RelationInsertOperation {
-  onAdd(builder, args) {
-    const retVal = super.onAdd(builder, args);
-    assertOwnerIsSingleItem(this.owner, this.relation);
-
-    const ownerValues = this.owner.getSplitProps(builder, this.relation);
-    const relatedProp = this.relation.relatedProp;
-
-    for (const model of this.models) {
-      for (let j = 0, lp = relatedProp.size; j < lp; ++j) {
-        relatedProp.setProp(model, j, ownerValues[0][j]);
-      }
+    onAdd(builder, args) {
+        const retVal = super.onAdd(builder, args);
+        assertOwnerIsSingleItem(this.owner, this.relation);
+        const ownerValues = this.owner.getSplitProps(builder, this.relation);
+        const relatedProp = this.relation.relatedProp;
+        for (const model of this.models) {
+            for (let j = 0, lp = relatedProp.size; j < lp; ++j) {
+                relatedProp.setProp(model, j, ownerValues[0][j]);
+            }
+        }
+        return retVal;
     }
-
-    return retVal;
-  }
-
-  async onAfter1(builder, ret) {
-    const inserted = await super.onAfter1(builder, ret);
-
-    if (!this.assignResultToOwner) {
-      return inserted;
+    async onAfter1(builder, ret) {
+        const inserted = await super.onAfter1(builder, ret);
+        if (!this.assignResultToOwner) {
+            return inserted;
+        }
+        if (this.owner.isModels) {
+            for (const owner of this.owner.modelArray) {
+                owner.$appendRelated(this.relation, inserted);
+            }
+        }
+        return inserted;
     }
-
-    if (this.owner.isModels) {
-      for (const owner of this.owner.modelArray) {
-        owner.$appendRelated(this.relation, inserted);
-      }
-    }
-
-    return inserted;
-  }
 }
-
 function assertOwnerIsSingleItem(owner, relation) {
-  const { isModels, isIdentifiers, isQueryBuilder } = owner;
-  const { ownerProp } = relation;
-
-  const singleModel = isModels && owner.modelArray.length === 1;
-  const singleId = isIdentifiers && owner.getNormalizedIdentifiers(ownerProp).length === 1;
-
-  if (!singleModel && !singleId && !isQueryBuilder) {
-    throw new Error(
-      [
-        'Can only insert items for one parent at a time in case of HasManyRelation.',
-        'Otherwise multiple insert queries would need to be created.',
-
-        'If you need to insert items for multiple parents, simply loop through them.',
-        `That's the most performant way.`,
-      ].join(' '),
-    );
-  }
+    const { isModels, isIdentifiers, isQueryBuilder } = owner;
+    const { ownerProp } = relation;
+    const singleModel = isModels && owner.modelArray.length === 1;
+    const singleId = isIdentifiers && owner.getNormalizedIdentifiers(ownerProp).length === 1;
+    if (!singleModel && !singleId && !isQueryBuilder) {
+        throw new Error([
+            'Can only insert items for one parent at a time in case of HasManyRelation.',
+            'Otherwise multiple insert queries would need to be created.',
+            'If you need to insert items for multiple parents, simply loop through them.',
+            `That's the most performant way.`,
+        ].join(' '));
+    }
 }
-
 module.exports = {
-  HasManyInsertOperation,
+    HasManyInsertOperation,
 };

package/lib/relations/hasMany/HasManyRelateOperation.js

@@ -1,64 +1,48 @@
 'use strict';
-
 const { withWhereScope } = require('../../queryBuilder/whereScopes');
 const { normalizeIds } = require('../../utils/normalizeIds');
 const { RelateOperation } = require('../../queryBuilder/operations/RelateOperation');
-
 class HasManyRelateOperation extends RelateOperation {
-  onAdd(_, args) {
-    this.input = args[0];
-
-    this.ids = normalizeIds(args[0], this.relation.relatedModelClass.getIdRelationProperty(), {
-      arrayOutput: true,
-    });
-
-    assertOwnerIsSingleItem(this.owner, this.relation);
-    return true;
-  }
-
-  queryExecutor(builder) {
-    const patch = {};
-    const relatedProp = this.relation.relatedProp;
-    const ownerValues = this.owner.getSplitProps(builder, this.relation);
-
-    relatedProp.forEach((i) => {
-      relatedProp.patch(patch, i, ownerValues[0][i]);
-    });
-
-    const query = this.relation.relatedModelClass
-      .query()
-      .childQueryOf(builder)
-      .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));
-
-    return query;
-  }
+    onAdd(_, args) {
+        this.input = args[0];
+        this.ids = normalizeIds(args[0], this.relation.relatedModelClass.getIdRelationProperty(), {
+            arrayOutput: true,
+        });
+        assertOwnerIsSingleItem(this.owner, this.relation);
+        return true;
+    }
+    queryExecutor(builder) {
+        const patch = {};
+        const relatedProp = this.relation.relatedProp;
+        const ownerValues = this.owner.getSplitProps(builder, this.relation);
+        relatedProp.forEach((i) => {
+            relatedProp.patch(patch, i, ownerValues[0][i]);
+        });
+        const query = this.relation.relatedModelClass
+            .query()
+            .childQueryOf(builder)
+            .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));
+        return query;
+    }
 }
-
 function assertOwnerIsSingleItem(owner, relation) {
-  const { isModels, isIdentifiers, isQueryBuilder } = owner;
-  const { ownerProp } = relation;
-
-  const singleModel = isModels && owner.modelArray.length === 1;
-  const singleId = isIdentifiers && owner.getNormalizedIdentifiers(ownerProp).length === 1;
-
-  if (!singleModel && !singleId && !isQueryBuilder) {
-    throw new Error(
-      [
-        'Can only relate items for one parent at a time in case of HasManyRelation.',
-        'Otherwise multiple update queries would need to be created.',
-
-        'If you need to relate items for multiple parents, simply loop through them.',
-        `That's the most performant way.`,
-      ].join(' '),
-    );
-  }
+    const { isModels, isIdentifiers, isQueryBuilder } = owner;
+    const { ownerProp } = relation;
+    const singleModel = isModels && owner.modelArray.length === 1;
+    const singleId = isIdentifiers && owner.getNormalizedIdentifiers(ownerProp).length === 1;
+    if (!singleModel && !singleId && !isQueryBuilder) {
+        throw new Error([
+            'Can only relate items for one parent at a time in case of HasManyRelation.',
+            'Otherwise multiple update queries would need to be created.',
+            'If you need to relate items for multiple parents, simply loop through them.',
+            `That's the most performant way.`,
+        ].join(' '));
+    }
 }
-
 module.exports = {
-  HasManyRelateOperation,
+    HasManyRelateOperation,
 };

package/lib/relations/hasMany/HasManyRelation.js

@@ -1,49 +1,41 @@
 'use strict';
-
 const { Relation } = require('../Relation');
 const { HasManyInsertOperation } = require('./HasManyInsertOperation');
 const { HasManyRelateOperation } = require('./HasManyRelateOperation');
 const { HasManyUnrelateOperation } = require('./HasManyUnrelateOperation');
-
 class HasManyRelation extends Relation {
-  insert(_, owner) {
-    return new HasManyInsertOperation('insert', {
-      relation: this,
-      owner: owner,
-    });
-  }
-
-  relate(_, owner) {
-    return new HasManyRelateOperation('relate', {
-      relation: this,
-      owner: owner,
-    });
-  }
-
-  unrelate(_, owner) {
-    return new HasManyUnrelateOperation('unrelate', {
-      relation: this,
-      owner: owner,
-    });
-  }
-
-  hasRelateProp(model) {
-    return model.$hasId();
-  }
-
-  setRelateProp(model, values) {
-    model.$id(values);
-  }
+    insert(_, owner) {
+        return new HasManyInsertOperation('insert', {
+            relation: this,
+            owner: owner,
+        });
+    }
+    relate(_, owner) {
+        return new HasManyRelateOperation('relate', {
+            relation: this,
+            owner: owner,
+        });
+    }
+    unrelate(_, owner) {
+        return new HasManyUnrelateOperation('unrelate', {
+            relation: this,
+            owner: owner,
+        });
+    }
+    hasRelateProp(model) {
+        return model.$hasId();
+    }
+    setRelateProp(model, values) {
+        model.$id(values);
+    }
 }
-
 Object.defineProperties(HasManyRelation.prototype, {
-  isObjectionHasManyRelation: {
-    enumerable: false,
-    writable: false,
-    value: true,
-  },
+    isObjectionHasManyRelation: {
+        enumerable: false,
+        writable: false,
+        value: true,
+    },
 });
-
 module.exports = {
-  HasManyRelation,
+    HasManyRelation,
 };

package/lib/relations/hasMany/HasManyUnrelateOperation.js

@@ -1,33 +1,26 @@
 'use strict';
-
 const { withWhereScope } = require('../../queryBuilder/whereScopes');
 const { UnrelateOperation } = require('../../queryBuilder/operations/UnrelateOperation');
-
 class HasManyUnrelateOperation extends UnrelateOperation {
-  queryExecutor(builder) {
-    const patch = {};
-    const relatedProp = this.relation.relatedProp;
-    const ownerValues = this.owner.getProps(this.relation);
-    const relatedRefs = relatedProp.refs(builder);
-
-    relatedProp.forEach((i) => {
-      relatedProp.patch(patch, i, null);
-    });
-
-    const query = this.relation.relatedModelClass
-      .query()
-      .childQueryOf(builder)
-      .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));
-
-    return query;
-  }
+    queryExecutor(builder) {
+        const patch = {};
+        const relatedProp = this.relation.relatedProp;
+        const ownerValues = this.owner.getProps(this.relation);
+        const relatedRefs = relatedProp.refs(builder);
+        relatedProp.forEach((i) => {
+            relatedProp.patch(patch, i, null);
+        });
+        const query = this.relation.relatedModelClass
+            .query()
+            .childQueryOf(builder)
+            .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));
+        return query;
+    }
 }
-
 module.exports = {
-  HasManyUnrelateOperation,
+    HasManyUnrelateOperation,
 };

package/lib/relations/hasOne/HasOneRelation.js

@@ -1,13 +1,10 @@
 'use strict';
-
 const { HasManyRelation } = require('../hasMany/HasManyRelation');
-
 class HasOneRelation extends HasManyRelation {
-  isOneToOne() {
-    return true;
-  }
+    isOneToOne() {
+        return true;
+    }
 }
-
 module.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;
-  }
+    isOneToOne() {
+        return true;
+    }
 }
-
 module.exports = {
-  HasOneThroughRelation,
+    HasOneThroughRelation,
 };