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

package/lib/relations/belongsToOne/BelongsToOneRelation.js

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

package/lib/relations/belongsToOne/BelongsToOneUnrelateOperation.js

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

package/lib/relations/hasMany/HasManyUnrelateOperation.js

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

package/lib/relations/hasOne/HasOneRelation.js

@@ -0,0 +1,10 @@
+'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,10 @@
+'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,82 @@
+'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,
+};