@abedmurrar/objection 0.0.0-stage → 4.0.0-alpha.0

package/lib/relations/belongsToOne/BelongsToOneUnrelateOperation.js

@@ -0,0 +1,61 @@
+'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);
+        }
+      }
+
+      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;
+  }
+}
+
+module.exports = {
+  BelongsToOneUnrelateOperation,
+};

package/lib/relations/hasMany/HasManyInsertOperation.js

@@ -0,0 +1,61 @@
+'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]);
+      }
+    }
+
+    return retVal;
+  }
+
+  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;
+  }
+}
+
+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(' '),
+    );
+  }
+}
+
+module.exports = {
+  HasManyInsertOperation,
+};

package/lib/relations/hasMany/HasManyRelateOperation.js

@@ -0,0 +1,64 @@
+'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;
+  }
+}
+
+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(' '),
+    );
+  }
+}
+
+module.exports = {
+  HasManyRelateOperation,
+};

package/lib/relations/hasMany/HasManyRelation.js

@@ -0,0 +1,49 @@
+'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);
+  }
+}
+
+Object.defineProperties(HasManyRelation.prototype, {
+  isObjectionHasManyRelation: {
+    enumerable: false,
+    writable: false,
+    value: true,
+  },
+});
+
+module.exports = {
+  HasManyRelation,
+};

package/lib/relations/hasMany/HasManyUnrelateOperation.js

@@ -0,0 +1,33 @@
+'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;
+  }
+}
+
+module.exports = {
+  HasManyUnrelateOperation,
+};

package/lib/relations/hasOne/HasOneRelation.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const { HasManyRelation } = require('../hasMany/HasManyRelation');
+
+class HasOneRelation extends HasManyRelation {
+  isOneToOne() {
+    return true;
+  }
+}
+
+module.exports = {
+  HasOneRelation,
+};

package/lib/relations/hasOneThrough/HasOneThroughRelation.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const { ManyToManyRelation } = require('../manyToMany/ManyToManyRelation');
+
+class HasOneThroughRelation extends ManyToManyRelation {
+  isOneToOne() {
+    return true;
+  }
+}
+
+module.exports = {
+  HasOneThroughRelation,
+};

package/lib/relations/manyToMany/ManyToManyModifyMixin.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const { withWhereScope } = require('../../queryBuilder/whereScopes');
+const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
+
+// This mixin contains the shared code for all modify operations (update, delete, relate, unrelate)
+// for ManyToManyRelation operations.
+//
+// The most important thing this mixin does is that it moves the filters from the main query
+// into a subquery and then adds a single where clause that uses the subquery. This is done so
+// that we are able to `innerJoin` the join table to the query. Most SQL engines don't allow
+// 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,
+};