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

package/lib/relations/belongsToOne/BelongsToOneRelateOperation.js

@@ -1,50 +1,39 @@
-'use strict';
-
-const { normalizeIds } = require('../../utils/normalizeIds');
-const { RelateOperation } = require('../../queryBuilder/operations/RelateOperation');
-
-class BelongsToOneRelateOperation extends RelateOperation {
-  onAdd(_, args) {
-    this.input = args[0];
-    this.ids = normalizeIds(args[0], this.relation.relatedProp, { arrayOutput: true });
-
-    assertOneId(this.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 ownerIds = this.owner.getProps(this.relation, ownerIdProp);
-
-    return this.relation.ownerModelClass
-      .query()
-      .childQueryOf(builder)
-      .patch(patch)
-      .whereInComposite(ownerIdProp.refs(builder), ownerIds);
-  }
+"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 = (0, normalizeIds_1.normalizeIds)(args[0], this.relation.relatedProp, { arrayOutput: true });
+        assertOneId(this.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 ownerIds = this.owner.getProps(this.relation, ownerIdProp);
+        return this.relation.ownerModelClass
+            .query()
+            .childQueryOf(builder)
+            .patch(patch)
+            .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');
-  }
+    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,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,
-    });
-  }
+"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_1.BelongsToOneInsertOperation('insert', {
+            relation: this,
+            owner,
+        });
+    }
+    delete(_, owner) {
+        return new BelongsToOneDeleteOperation_1.BelongsToOneDeleteOperation('delete', {
+            relation: this,
+            owner,
+        });
+    }
+    relate(_, owner) {
+        return new BelongsToOneRelateOperation_1.BelongsToOneRelateOperation('relate', {
+            relation: this,
+            owner,
+        });
+    }
+    unrelate(_, owner) {
+        return new BelongsToOneUnrelateOperation_1.BelongsToOneUnrelateOperation('unrelate', {
+            relation: this,
+            owner,
+        });
+    }
 }
-
+exports.BelongsToOneRelation = BelongsToOneRelation;
 Object.defineProperties(BelongsToOneRelation.prototype, {
-  isObjectionBelongsToOneRelation: {
-    enumerable: false,
-    writable: false,
-    value: true,
-  },
+    isObjectionBelongsToOneRelation: {
+        enumerable: false,
+        writable: false,
+        value: true,
+    },
 });
-
-module.exports = {
-  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);
+"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) => {
+            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,
-};
+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]);
-      }
+"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);
+        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;
-  }
 }
-
+exports.HasManyInsertOperation = HasManyInsertOperation;
 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,
-};

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;
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasManyRelateOperation = void 0;
+const whereScopes_1 = require("../../queryBuilder/whereScopes");
+const normalizeIds_1 = require("../../utils/normalizeIds");
+const RelateOperation_1 = require("../../queryBuilder/operations/RelateOperation");
+class HasManyRelateOperation extends RelateOperation_1.RelateOperation {
+    onAdd(_, args) {
+        this.input = args[0];
+        this.ids = (0, normalizeIds_1.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);
+        (0, whereScopes_1.withWhereScope)(query, () => query.findByIds(this.ids));
+        (0, whereScopes_1.withWhereScope)(query, () => query.modify(this.relation.modify));
+        return query;
+    }
 }
-
+exports.HasManyRelateOperation = HasManyRelateOperation;
 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,
-};

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);
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasManyRelation = void 0;
+const Relation_1 = require("../Relation");
+const HasManyInsertOperation_1 = require("./HasManyInsertOperation");
+const HasManyRelateOperation_1 = require("./HasManyRelateOperation");
+const HasManyUnrelateOperation_1 = require("./HasManyUnrelateOperation");
+class HasManyRelation extends Relation_1.Relation {
+    insert(_, owner) {
+        return new HasManyInsertOperation_1.HasManyInsertOperation('insert', {
+            relation: this,
+            owner: owner,
+        });
+    }
+    relate(_, owner) {
+        return new HasManyRelateOperation_1.HasManyRelateOperation('relate', {
+            relation: this,
+            owner: owner,
+        });
+    }
+    unrelate(_, owner) {
+        return new HasManyUnrelateOperation_1.HasManyUnrelateOperation('unrelate', {
+            relation: this,
+            owner: owner,
+        });
+    }
+    hasRelateProp(model) {
+        return model.$hasId();
+    }
+    setRelateProp(model, values) {
+        model.$id(values);
+    }
 }
-
+exports.HasManyRelation = HasManyRelation;
 Object.defineProperties(HasManyRelation.prototype, {
-  isObjectionHasManyRelation: {
-    enumerable: false,
-    writable: false,
-    value: true,
-  },
+    isObjectionHasManyRelation: {
+        enumerable: false,
+        writable: false,
+        value: true,
+    },
 });
-
-module.exports = {
-  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;
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HasManyUnrelateOperation = void 0;
+const whereScopes_1 = require("../../queryBuilder/whereScopes");
+const UnrelateOperation_1 = require("../../queryBuilder/operations/UnrelateOperation");
+class HasManyUnrelateOperation extends UnrelateOperation_1.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);
+        (0, whereScopes_1.withWhereScope)(query, () => query.whereInComposite(relatedRefs, ownerValues));
+        (0, whereScopes_1.withWhereScope)(query, () => query.modify(this.relation.modify));
+        return query;
+    }
 }
-
-module.exports = {
-  HasManyUnrelateOperation,
-};
+exports.HasManyUnrelateOperation = HasManyUnrelateOperation;