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

package/lib/relations/manyToMany/ManyToManyRelation.js

@@ -0,0 +1,405 @@
+'use strict';
+const { withWhereScope } = require('../../queryBuilder/whereScopes');
+const { getModel } = require('../../model/getModel');
+const { Relation } = require('../Relation');
+const { RelationProperty } = require('../RelationProperty');
+const { isSqlite } = require('../../utils/knexUtils');
+const { inheritModel } = require('../../model/inheritModel');
+const { resolveModel } = require('../../utils/resolveModel');
+const { mapAfterAllReturn } = require('../../utils/promiseUtils');
+const { isFunction, isObject, isString } = require('../../utils/objectUtils');
+const { createModifier } = require('../../utils/createModifier');
+const { ManyToManyFindOperation } = require('./find/ManyToManyFindOperation');
+const { ManyToManyInsertOperation } = require('./insert/ManyToManyInsertOperation');
+const { ManyToManyRelateOperation } = require('./relate/ManyToManyRelateOperation');
+const { ManyToManyUnrelateOperation } = require('./unrelate/ManyToManyUnrelateOperation');
+const { ManyToManyUnrelateSqliteOperation, } = require('./unrelate/ManyToManyUnrelateSqliteOperation');
+const { ManyToManyUpdateOperation } = require('./update/ManyToManyUpdateOperation');
+const { ManyToManyUpdateSqliteOperation } = require('./update/ManyToManyUpdateSqliteOperation');
+const { ManyToManyDeleteOperation } = require('./delete/ManyToManyDeleteOperation');
+const { ManyToManyDeleteSqliteOperation } = require('./delete/ManyToManyDeleteSqliteOperation');
+class ManyToManyRelation extends Relation {
+    setMapping(mapping) {
+        const retVal = super.setMapping(mapping);
+        let ctx = {
+            mapping,
+            ownerModelClass: this.ownerModelClass,
+            relatedModelClass: this.relatedModelClass,
+            ownerProp: this.ownerProp,
+            relatedProp: this.relatedProp,
+            joinTableModelClass: null,
+            joinTableOwnerProp: null,
+            joinTableRelatedProp: null,
+            joinTableBeforeInsert: null,
+            joinTableExtras: [],
+            createError: (msg) => this.createError(msg),
+        };
+        ctx = checkThroughObject(ctx);
+        ctx = resolveJoinModelClassIfDefined(ctx);
+        ctx = createJoinProperties(ctx);
+        ctx = parseExtras(ctx);
+        ctx = parseModify(ctx);
+        ctx = parseBeforeInsert(ctx);
+        ctx = finalizeJoinModelClass(ctx);
+        this.joinTableExtras = ctx.joinTableExtras;
+        this.joinTableModify = ctx.joinTableModify;
+        this.joinTableModelClass = ctx.joinTableModelClass;
+        this.joinTableOwnerProp = ctx.joinTableOwnerProp;
+        this.joinTableRelatedProp = ctx.joinTableRelatedProp;
+        this.joinTableBeforeInsert = ctx.joinTableBeforeInsert;
+        return retVal;
+    }
+    get forbiddenMappingProperties() {
+        return [];
+    }
+    findQuery(builder, owner) {
+        const joinTableOwnerRefs = this.joinTableOwnerProp.refs(builder);
+        const joinTable = builder.tableNameFor(this.joinTable);
+        const joinTableAlias = builder.tableRefFor(this.joinTable);
+        let joinTableSelect = this.joinTableModelClass
+            .query()
+            .childQueryOf(builder)
+            .modify(this.joinTableModify)
+            .as(joinTableAlias);
+        if (joinTableSelect.isSelectAll()) {
+            joinTableSelect = aliasedTableName(joinTable, joinTableAlias);
+        }
+        builder.join(joinTableSelect, (join) => {
+            this.relatedProp.forEach((i) => {
+                const relatedRef = this.relatedProp.ref(builder, i);
+                const joinTableRelatedRef = this.joinTableRelatedProp.ref(builder, i);
+                join.on(relatedRef, joinTableRelatedRef);
+            });
+        });
+        withWhereScope(builder, () => {
+            owner.buildFindQuery(builder, this, joinTableOwnerRefs);
+        });
+        return this.applyModify(builder);
+    }
+    join(builder, { joinOperation = defaultJoinOperation(this, builder), relatedTableAlias = defaultRelatedTableAlias(this, builder), relatedJoinSelectQuery = defaultRelatedJoinSelectQuery(this, builder), relatedTable = defaultRelatedTable(this, builder), ownerTable = defaultOwnerTable(this, builder), joinTableAlias = defaultJoinTableAlias(this, relatedTableAlias, builder), } = {}) {
+        let relatedJoinSelect = this.applyModify(relatedJoinSelectQuery).as(relatedTableAlias);
+        if (relatedJoinSelect.isSelectAll()) {
+            // No need to join a subquery if the query is `select * from "RelatedTable"`.
+            relatedJoinSelect = aliasedTableName(relatedTable, relatedTableAlias);
+        }
+        let joinTableSelect = this.joinTableModelClass
+            .query()
+            .childQueryOf(builder)
+            .modify(this.joinTableModify)
+            .as(joinTableAlias);
+        if (joinTableSelect.isSelectAll()) {
+            joinTableSelect = aliasedTableName(this.joinTable, joinTableAlias);
+        }
+        return builder[joinOperation](joinTableSelect, (join) => {
+            const ownerProp = this.ownerProp;
+            const joinTableOwnerProp = this.joinTableOwnerProp;
+            ownerProp.forEach((i) => {
+                const joinTableOwnerRef = joinTableOwnerProp.ref(builder, i).table(joinTableAlias);
+                const ownerRef = ownerProp.ref(builder, i).table(ownerTable);
+                join.on(joinTableOwnerRef, ownerRef);
+            });
+        })[joinOperation](relatedJoinSelect, (join) => {
+            const relatedProp = this.relatedProp;
+            const joinTableRelatedProp = this.joinTableRelatedProp;
+            relatedProp.forEach((i) => {
+                const joinTableRelatedRef = joinTableRelatedProp.ref(builder, i).table(joinTableAlias);
+                const relatedRef = relatedProp.ref(builder, i).table(relatedTableAlias);
+                join.on(joinTableRelatedRef, relatedRef);
+            });
+        });
+    }
+    find(_, owner) {
+        return new ManyToManyFindOperation('find', {
+            relation: this,
+            owner,
+        });
+    }
+    insert(_, owner) {
+        return new ManyToManyInsertOperation('insert', {
+            relation: this,
+            owner,
+        });
+    }
+    update(builder, owner) {
+        if (isSqlite(builder.knex())) {
+            return new ManyToManyUpdateSqliteOperation('update', {
+                relation: this,
+                owner,
+            });
+        }
+        else {
+            return new ManyToManyUpdateOperation('update', {
+                relation: this,
+                owner,
+            });
+        }
+    }
+    patch(builder, owner) {
+        if (isSqlite(builder.knex())) {
+            return new ManyToManyUpdateSqliteOperation('patch', {
+                modelOptions: { patch: true },
+                relation: this,
+                owner,
+            });
+        }
+        else {
+            return new ManyToManyUpdateOperation('patch', {
+                modelOptions: { patch: true },
+                relation: this,
+                owner,
+            });
+        }
+    }
+    delete(builder, owner) {
+        if (isSqlite(builder.knex())) {
+            return new ManyToManyDeleteSqliteOperation('delete', {
+                relation: this,
+                owner,
+            });
+        }
+        else {
+            return new ManyToManyDeleteOperation('delete', {
+                relation: this,
+                owner,
+            });
+        }
+    }
+    relate(builder, owner) {
+        return new ManyToManyRelateOperation('relate', {
+            relation: this,
+            owner,
+        });
+    }
+    unrelate(builder, owner) {
+        if (isSqlite(builder.knex())) {
+            return new ManyToManyUnrelateSqliteOperation('unrelate', {
+                relation: this,
+                owner,
+            });
+        }
+        else {
+            return new ManyToManyUnrelateOperation('unrelate', {
+                relation: this,
+                owner,
+            });
+        }
+    }
+    createJoinModels(ownerId, related) {
+        return related.map((related) => this.createJoinModel(ownerId, related));
+    }
+    createJoinModel(ownerId, rel) {
+        const joinModel = {};
+        for (let j = 0, lp = this.joinTableOwnerProp.size; j < lp; ++j) {
+            this.joinTableOwnerProp.setProp(joinModel, j, ownerId[j]);
+        }
+        for (let j = 0, lp = this.joinTableRelatedProp.size; j < lp; ++j) {
+            const value = this.relatedProp.getProp(rel, j);
+            if (value !== undefined) {
+                this.joinTableRelatedProp.setProp(joinModel, j, value);
+            }
+        }
+        for (const extra of this.joinTableExtras) {
+            let extraValue = rel[extra.aliasProp];
+            if (extraValue === undefined && rel.$$queryProps) {
+                extraValue = rel.$$queryProps[extra.aliasProp];
+            }
+            if (extraValue !== undefined) {
+                joinModel[extra.joinTableProp] = extraValue;
+            }
+        }
+        return joinModel;
+    }
+    omitExtraProps(models) {
+        if (this.joinTableExtras && this.joinTableExtras.length) {
+            const props = this.joinTableExtras.map((extra) => extra.aliasProp);
+            for (const model of models) {
+                // Omit extra properties instead of deleting them from the models so that they can
+                // be used in the `$before` and `$after` hooks.
+                model.$omitFromDatabaseJson(props);
+            }
+        }
+    }
+    executeJoinTableBeforeInsert(models, queryContext, result) {
+        return mapAfterAllReturn(models, (model) => this.joinTableBeforeInsert(model, queryContext), result);
+    }
+}
+Object.defineProperties(ManyToManyRelation.prototype, {
+    isObjectionManyToManyRelation: {
+        enumerable: false,
+        writable: false,
+        value: true,
+    },
+});
+function defaultJoinOperation() {
+    return 'join';
+}
+function defaultRelatedTableAlias(relation, builder) {
+    return builder.tableRefFor(relation.relatedModelClass);
+}
+function defaultRelatedJoinSelectQuery(relation, builder) {
+    return relation.relatedModelClass.query().childQueryOf(builder);
+}
+function defaultRelatedTable(relation, builder) {
+    return builder.tableNameFor(relation.relatedModelClass);
+}
+function defaultOwnerTable(relation, builder) {
+    return builder.tableRefFor(relation.ownerModelClass);
+}
+function defaultJoinTableAlias(relation, relatedTableAlias, builder) {
+    const alias = builder.tableRefFor(relation.joinTable);
+    if (alias === relation.joinTable) {
+        return relation.ownerModelClass.joinTableAlias(relatedTableAlias);
+    }
+    else {
+        return alias;
+    }
+}
+function aliasedTableName(tableName, alias) {
+    if (tableName === alias) {
+        return tableName;
+    }
+    else {
+        return `${tableName} as ${alias}`;
+    }
+}
+function checkThroughObject(ctx) {
+    const mapping = ctx.mapping;
+    if (!isObject(mapping.join.through)) {
+        throw ctx.createError('join must have a `through` object that describes the join table.');
+    }
+    if (!mapping.join.through.from || !mapping.join.through.to) {
+        throw ctx.createError('join.through must be an object that describes the join table. For example: {from: "JoinTable.someId", to: "JoinTable.someOtherId"}');
+    }
+    return ctx;
+}
+function resolveJoinModelClassIfDefined(ctx) {
+    let joinTableModelClass = null;
+    if (ctx.mapping.join.through.modelClass) {
+        try {
+            joinTableModelClass = resolveModel(ctx.mapping.join.through.modelClass, ctx.ownerModelClass.modelPaths, 'join.through.modelClass');
+        }
+        catch (err) {
+            throw ctx.createError(err.message);
+        }
+    }
+    return Object.assign(ctx, { joinTableModelClass });
+}
+function createJoinProperties(ctx) {
+    let ret;
+    let fromProp;
+    let toProp;
+    let relatedProp;
+    let ownerProp;
+    ret = createRelationProperty(ctx, ctx.mapping.join.through.from, 'join.through.from');
+    fromProp = ret.prop;
+    ctx = ret.ctx;
+    ret = createRelationProperty(ctx, ctx.mapping.join.through.to, 'join.through.to');
+    toProp = ret.prop;
+    ctx = ret.ctx;
+    if (fromProp.modelClass.getTableName() !== toProp.modelClass.getTableName()) {
+        throw ctx.createError('join.through `from` and `to` must point to the same join table.');
+    }
+    if (ctx.relatedProp.modelClass.getTableName() === fromProp.modelClass.getTableName()) {
+        relatedProp = fromProp;
+        ownerProp = toProp;
+    }
+    else {
+        relatedProp = toProp;
+        ownerProp = fromProp;
+    }
+    return Object.assign(ctx, {
+        joinTableOwnerProp: ownerProp,
+        joinTableRelatedProp: relatedProp,
+    });
+}
+function createRelationProperty(ctx, refString, messagePrefix) {
+    let prop = null;
+    let joinTableModelClass = ctx.joinTableModelClass;
+    const resolveModelClass = (table) => {
+        if (joinTableModelClass === null) {
+            joinTableModelClass = inheritModel(getModel());
+            joinTableModelClass.tableName = table;
+            joinTableModelClass.idColumn = null;
+            joinTableModelClass.concurrency = ctx.ownerModelClass.concurrency;
+        }
+        if (joinTableModelClass.getTableName() === table) {
+            return joinTableModelClass;
+        }
+        else {
+            return null;
+        }
+    };
+    try {
+        prop = new RelationProperty(refString, resolveModelClass);
+    }
+    catch (err) {
+        if (err instanceof RelationProperty.ModelNotFoundError) {
+            throw ctx.createError('join.through `from` and `to` must point to the same join table.');
+        }
+        else {
+            throw ctx.createError(`${messagePrefix} must have format JoinTable.columnName. For example "JoinTable.someId" or in case of composite key ["JoinTable.a", "JoinTable.b"].`);
+        }
+    }
+    return {
+        ctx: Object.assign(ctx, { joinTableModelClass }),
+        prop,
+    };
+}
+function parseExtras(ctx) {
+    let extraDef = ctx.mapping.join.through.extra;
+    if (!extraDef) {
+        return ctx;
+    }
+    if (isString(extraDef)) {
+        extraDef = {
+            [extraDef]: extraDef,
+        };
+    }
+    else if (Array.isArray(extraDef)) {
+        extraDef = extraDef.reduce((extraDef, col) => {
+            extraDef[col] = col;
+            return extraDef;
+        }, {});
+    }
+    const joinTableExtras = Object.keys(extraDef).map((key) => {
+        const val = extraDef[key];
+        return {
+            joinTableCol: val,
+            joinTableProp: ctx.joinTableModelClass.columnNameToPropertyName(val),
+            aliasCol: key,
+            aliasProp: ctx.joinTableModelClass.columnNameToPropertyName(key),
+        };
+    });
+    return Object.assign(ctx, { joinTableExtras });
+}
+function parseModify(ctx) {
+    const mapping = ctx.mapping.join.through;
+    const modifier = mapping.modify || mapping.filter;
+    const joinTableModify = modifier &&
+        createModifier({
+            modifier,
+            modelClass: ctx.relatedModelClass,
+        });
+    return Object.assign(ctx, { joinTableModify });
+}
+function parseBeforeInsert(ctx) {
+    let joinTableBeforeInsert;
+    if (isFunction(ctx.mapping.join.through.beforeInsert)) {
+        joinTableBeforeInsert = ctx.mapping.join.through.beforeInsert;
+    }
+    else {
+        joinTableBeforeInsert = (model) => model;
+    }
+    return Object.assign(ctx, { joinTableBeforeInsert });
+}
+function finalizeJoinModelClass(ctx) {
+    if (ctx.joinTableModelClass.getIdColumn() === null) {
+        // We cannot know if the join table has a primary key. Therefore we set some
+        // known column as the idColumn so that inserts will work.
+        ctx.joinTableModelClass.idColumn = ctx.joinTableRelatedProp.cols;
+    }
+    return ctx;
+}
+module.exports = {
+    ManyToManyRelation,
+};

package/lib/relations/manyToMany/ManyToManySqliteModifyMixin.js

@@ -0,0 +1,29 @@
+'use strict';
+const { ManyToManyModifyMixin } = require('./ManyToManyModifyMixin');
+const SQLITE_BUILTIN_ROW_ID = '_rowid_';
+// We need to override this mixin for sqlite because sqlite doesn't support
+// multi-column where in statements with subqueries. We need to use the
+// internal _rowid_ column instead.
+const ManyToManySqliteModifyMixin = (Operation) => {
+    return class extends ManyToManyModifyMixin(Operation) {
+        applyModifyFilterForRelatedTable(builder) {
+            const tableRef = builder.tableRefFor(this.relation.relatedModelClass);
+            const rowIdRef = `${tableRef}.${SQLITE_BUILTIN_ROW_ID}`;
+            const subquery = this.modifyFilterSubquery.clone().select(rowIdRef);
+            return builder.whereInComposite(rowIdRef, subquery);
+        }
+        applyModifyFilterForJoinTable(builder) {
+            const joinTableOwnerRefs = this.relation.joinTableOwnerProp.refs(builder);
+            const tableRef = builder.tableRefFor(this.relation.getJoinModelClass(builder));
+            const rowIdRef = `${tableRef}.${SQLITE_BUILTIN_ROW_ID}`;
+            const ownerValues = this.owner.getProps(this.relation);
+            const subquery = this.modifyFilterSubquery.clone().select(rowIdRef);
+            return builder
+                .whereInComposite(rowIdRef, subquery)
+                .whereInComposite(joinTableOwnerRefs, ownerValues);
+        }
+    };
+};
+module.exports = {
+    ManyToManySqliteModifyMixin,
+};

package/lib/relations/manyToMany/delete/ManyToManyDeleteOperation.js

@@ -0,0 +1,8 @@
+'use strict';
+const { ManyToManyDeleteOperationBase } = require('./ManyToManyDeleteOperationBase');
+const { ManyToManyModifyMixin } = require('../ManyToManyModifyMixin');
+class ManyToManyDeleteOperation extends ManyToManyModifyMixin(ManyToManyDeleteOperationBase) {
+}
+module.exports = {
+    ManyToManyDeleteOperation,
+};

package/lib/relations/manyToMany/delete/ManyToManyDeleteOperationBase.js

@@ -0,0 +1,20 @@
+'use strict';
+const { DeleteOperation } = require('../../../queryBuilder/operations/DeleteOperation');
+class ManyToManyDeleteOperationBase extends DeleteOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.relation = opt.relation;
+        this.owner = opt.owner;
+    }
+    /* istanbul ignore next */
+    applyModifyFilterForRelatedTable(builder) {
+        throw new Error('not implemented');
+    }
+    /* istanbul ignore next */
+    applyModifyFilterForJoinTable(builder) {
+        throw new Error('not implemented');
+    }
+}
+module.exports = {
+    ManyToManyDeleteOperationBase,
+};

package/lib/relations/manyToMany/delete/ManyToManyDeleteSqliteOperation.js

@@ -0,0 +1,8 @@
+'use strict';
+const { ManyToManyDeleteOperationBase } = require('./ManyToManyDeleteOperationBase');
+const { ManyToManySqliteModifyMixin } = require('../ManyToManySqliteModifyMixin');
+class ManyToManyDeleteSqliteOperation extends ManyToManySqliteModifyMixin(ManyToManyDeleteOperationBase) {
+}
+module.exports = {
+    ManyToManyDeleteSqliteOperation,
+};

package/lib/relations/manyToMany/find/ManyToManyFindOperation.js

@@ -0,0 +1,82 @@
+'use strict';
+const { RelationFindOperation } = require('../../RelationFindOperation');
+const { getTempColumn } = require('../../../utils/tmpColumnUtils');
+class ManyToManyFindOperation extends RelationFindOperation {
+    constructor(name, opt) {
+        super(name, opt);
+        this.ownerJoinColumnAlias = new Array(this.relation.joinTableOwnerProp.size);
+        for (let i = 0, l = this.ownerJoinColumnAlias.length; i < l; ++i) {
+            this.ownerJoinColumnAlias[i] = getTempColumn(i);
+        }
+    }
+    onBuild(builder) {
+        const relatedModelClass = this.relation.relatedModelClass;
+        this.maybeApplyAlias(builder);
+        this.relation.findQuery(builder, this.owner);
+        if (!builder.hasSelects()) {
+            const table = builder.tableRefFor(relatedModelClass);
+            // If the user hasn't specified a select clause, select the related model's columns.
+            // If we don't do this we also get the join table's columns.
+            builder.select(`${table}.*`);
+            // Also select all extra columns.
+            for (const extra of this.relation.joinTableExtras) {
+                const joinTable = builder.tableRefFor(this.relation.joinTable);
+                builder.select(`${joinTable}.${extra.joinTableCol} as ${extra.aliasCol}`);
+            }
+        }
+        if (this.assignResultToOwner && this.owner.isModels) {
+            this.selectMissingJoinColumns(builder);
+        }
+    }
+    onAfter2(_, related) {
+        const isOneToOne = this.relation.isOneToOne();
+        if (this.assignResultToOwner && this.owner.isModels) {
+            const owners = this.owner.modelArray;
+            const ownerProp = this.relation.ownerProp;
+            const relatedByOwnerId = new Map();
+            for (let i = 0, l = related.length; i < l; ++i) {
+                const rel = related[i];
+                const key = rel.$propKey(this.ownerJoinColumnAlias);
+                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 = ownerProp.propKey(own);
+                const related = relatedByOwnerId.get(key);
+                if (isOneToOne) {
+                    own[this.relationProperty] = (related && related[0]) || null;
+                }
+                else {
+                    own[this.relationProperty] = related || [];
+                }
+            }
+        }
+        return related;
+    }
+    clone() {
+        const clone = super.clone();
+        clone.ownerJoinColumnAlias = this.ownerJoinColumnAlias.slice();
+        return clone;
+    }
+    selectMissingJoinColumns(builder) {
+        const { relatedModelClass, joinTableOwnerProp } = this.relation;
+        // We must select the owner join columns so that we know for which owner model the related
+        // models belong to after the requests.
+        joinTableOwnerProp.forEach((i) => {
+            const joinTableOwnerRef = joinTableOwnerProp.ref(builder, i);
+            const propName = relatedModelClass.columnNameToPropertyName(this.ownerJoinColumnAlias[i]);
+            builder.select(joinTableOwnerRef.as(this.ownerJoinColumnAlias[i]));
+            // Mark them to be omitted later.
+            this.omitProps.push(propName);
+        });
+        super.selectMissingJoinColumns(builder);
+    }
+}
+module.exports = {
+    ManyToManyFindOperation,
+};

package/lib/relations/manyToMany/insert/ManyToManyInsertOperation.js

@@ -0,0 +1,40 @@
+'use strict';
+const { RelationInsertOperation } = require('../../RelationInsertOperation');
+const { ManyToManyRelateOperation } = require('../relate/ManyToManyRelateOperation');
+class ManyToManyInsertOperation extends RelationInsertOperation {
+    onAdd(builder, args) {
+        const retVal = super.onAdd(builder, args);
+        // Omit extra properties so that we don't try to insert
+        // them to the related table. We don't actually remove them
+        // from the objects, but simply mark them to be removed
+        // from the inserted row.
+        this.relation.omitExtraProps(this.models);
+        return retVal;
+    }
+    async onAfter1(builder, ret) {
+        const inserted = await super.onAfter1(builder, ret);
+        const relateOp = new ManyToManyRelateOperation('relate', {
+            dontCopyReturning: true,
+            dontCopyOnConflict: true,
+            relation: this.relation,
+            owner: this.owner,
+        });
+        const modelsToRelate = inserted.filter((it) => {
+            return this.relation.relatedProp.hasProps(it);
+        });
+        if (this.assignResultToOwner && this.owner.isModels) {
+            for (const owner of this.owner.modelArray) {
+                owner.$appendRelated(this.relation, inserted);
+            }
+        }
+        if (modelsToRelate.length === 0) {
+            return inserted;
+        }
+        relateOp.onAdd(builder, [modelsToRelate]);
+        await relateOp.queryExecutor(builder);
+        return inserted;
+    }
+}
+module.exports = {
+    ManyToManyInsertOperation,
+};

package/lib/relations/manyToMany/relate/ManyToManyRelateOperation.js

@@ -0,0 +1,64 @@
+'use strict';
+const { isPostgres } = require('../../../utils/knexUtils');
+const { normalizeIds } = require('../../../utils/normalizeIds');
+const { RelateOperation } = require('../../../queryBuilder/operations/RelateOperation');
+class ManyToManyRelateOperation extends RelateOperation {
+    onAdd(builder, args) {
+        this.input = args[0];
+        this.ids = normalizeIds(args[0], this.relation.relatedProp);
+        assertOwnerIsSingleItem(builder, this.owner, this.relation);
+        return true;
+    }
+    queryExecutor(builder) {
+        const joinModelClass = this.relation.getJoinModelClass(builder.knex());
+        const ownerValues = this.owner.getSplitProps(builder, this.relation);
+        const joinModels = [];
+        for (const ownerValue of ownerValues) {
+            for (const relatedValue of this.ids) {
+                joinModels.push(joinModelClass.fromJson(this.relation.createJoinModel(ownerValue, relatedValue)));
+            }
+        }
+        return joinModelClass
+            .query()
+            .childQueryOf(builder)
+            .modify((query) => {
+            if (!this.opt.dontCopyReturning) {
+                query.copyFrom(builder, /returning/);
+            }
+            if (!this.opt.dontCopyOnConflict) {
+                query.copyFrom(builder, /onConflict|ignore|merge/);
+            }
+        })
+            .runBefore((_, builder) => {
+            return this.relation.executeJoinTableBeforeInsert(joinModels, builder.context(), null);
+        })
+            .insert(joinModels)
+            .runAfter((models) => {
+            return Array.isArray(models) ? models.length : 1;
+        });
+    }
+}
+function assertOwnerIsSingleItem(builder, 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 (isPostgres(builder.unsafeKnex())) {
+        if (!isModels && !isIdentifiers && !isQueryBuilder) {
+            throw new Error('Parent must be a list of identifiers or a list of models when relating a ManyToManyRelation');
+        }
+    }
+    else {
+        if (!singleModel && !singleId && !isQueryBuilder) {
+            throw new Error([
+                'Can only relate items for one parent at a time in case of ManyToManyRelation.',
+                'Otherwise multiple insert 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 = {
+    ManyToManyRelateOperation,
+};

package/lib/relations/manyToMany/unrelate/ManyToManyUnrelateOperation.js

@@ -0,0 +1,11 @@
+'use strict';
+const { ManyToManyUnrelateOperationBase } = require('./ManyToManyUnrelateOperationBase');
+const { ManyToManyModifyMixin } = require('../ManyToManyModifyMixin');
+class ManyToManyUnrelateOperation extends ManyToManyModifyMixin(ManyToManyUnrelateOperationBase) {
+    get modifyMainQuery() {
+        return false;
+    }
+}
+module.exports = {
+    ManyToManyUnrelateOperation,
+};