@contember/engine-content-api 1.2.1 → 1.3.0-alpha.13

package/src/mapper/insert/InsertBuilder.ts

@@ -1,10 +1,13 @@
-import { Input, Model, Value } from '@contember/schema'
+import { Acl, Input, Model, Value } from '@contember/schema'
 import { Client, InsertBuilder as DbInsertBuilder, QueryBuilder, Value as DbValue } from '@contember/database'
 import { PathFactory, WhereBuilder } from '../select'
 import { getColumnName, getColumnType } from '@contember/schema-utils'
 import { ColumnValue, ResolvedColumnValue, resolveGenericValue, resolveRowData } from '../ColumnValue'
 import { ImplementationException } from '../../exception'
-import { AbortInsert } from './Inserter'
+import { PredicateFactory } from '../../acl'
+import { AbortDataManipulation, DataManipulationBuilder } from '../DataManipulationBuilder'
+import { AfterInsertEvent, BeforeInsertEvent, EventManager } from '../EventManager'
+import { Mapper } from '../Mapper'
 
 export interface InsertResult {
 	values: ResolvedColumnValue[]
@@ -13,41 +16,51 @@ export interface InsertResult {
 	primaryValue: Value.PrimaryValue | null
 }
 
-export class InsertBuilder {
+export class InsertBuilder implements DataManipulationBuilder {
 	private resolver: (value: Value.PrimaryValue | null) => void = () => {
 		throw new ImplementationException('InsertBuilder: Resolver called too soon')
 	}
 	public readonly insert: Promise<Value.PrimaryValue | null> = new Promise(resolve => (this.resolver = resolve))
 
-	private rowData: ColumnValue<AbortInsert | undefined>[] = []
-	private where: Input.OptionalWhere = {}
+	private rowData: Map<string, ColumnValue<AbortDataManipulation | undefined>> = new Map()
+	private where: { and: Input.OptionalWhere[] } = { and: [] }
 
 	constructor(
 		private readonly schema: Model.Schema,
 		private readonly entity: Model.Entity,
 		private readonly whereBuilder: WhereBuilder,
 		private readonly pathFactory: PathFactory,
+		private readonly predicateFactory: PredicateFactory,
 	) {}
 
-	public addFieldValue(fieldName: string, value: Value.GenericValueLike<Value.AtomicValue<AbortInsert | undefined>>) {
+	public addFieldValue(
+		fieldName: string,
+		value: Value.GenericValueLike<Value.AtomicValue<AbortDataManipulation | undefined>>,
+	): Promise<Value.AtomicValue<AbortDataManipulation | undefined>> {
 		const columnName = getColumnName(this.schema, this.entity, fieldName)
 		const columnType = getColumnType(this.schema, this.entity, fieldName)
-		this.rowData.push({ columnName, value: resolveGenericValue(value), columnType, fieldName })
+		const resolvedValue = resolveGenericValue(value)
+		this.rowData.set(columnName, { columnName, value: resolvedValue, columnType, fieldName })
+		return resolvedValue
+	}
+
+	public addPredicates(fields: string[]): void {
+		const where = this.predicateFactory.create(this.entity, Acl.Operation.create, fields)
+		this.addWhere(where)
 	}
 
 	public addWhere(where: Input.OptionalWhere): void {
-		this.where = { and: [where, this.where] }
+		this.where.and.push(where)
 	}
 
-	public async getResolvedData(): Promise<ResolvedColumnValue<AbortInsert>[]> {
-		return resolveRowData(this.rowData)
+	public async getResolvedData(): Promise<ResolvedColumnValue<AbortDataManipulation>[]> {
+		return resolveRowData([...this.rowData.values()])
 	}
 
-	public async execute(db: Client): Promise<InsertResult> {
-		let resolvedDataFinal: ResolvedColumnValue[] | null = null
+	public async execute(mapper: Mapper): Promise<InsertResult> {
 		try {
 			const resolvedData = await this.getResolvedData()
-			if (resolvedData.find(it => it.resolvedValue === AbortInsert)) {
+			if (resolvedData.find(it => it.resolvedValue === AbortDataManipulation)) {
 				this.resolver(null)
 				return { aborted: true, executed: false, primaryValue: null, values: [] }
 			}
@@ -72,8 +85,16 @@ export class InsertBuilder {
 				})
 				.returning(this.entity.primaryColumn)
 
-			const returning = (await qb.execute(db)).map(it => it[this.entity.primaryColumn])
+			const beforeInsertEvent = new BeforeInsertEvent(this.entity, resolvedData as ResolvedColumnValue[])
+			await mapper.eventManager.fire(beforeInsertEvent)
+
+			const returning = (await qb.execute(mapper.db)).map(it => it[this.entity.primaryColumn])
 			const result = returning.length === 1 ? returning[0] : null
+
+			const afterInsertEvent = new AfterInsertEvent(this.entity, resolvedData as ResolvedColumnValue[], result)
+			beforeInsertEvent.afterEvent = afterInsertEvent
+			await mapper.eventManager.fire(afterInsertEvent)
+
 			this.resolver(result)
 			return { values: resolvedData as ResolvedColumnValue[], executed: true, primaryValue: result, aborted: false }
 		} catch (e) {

package/src/mapper/insert/InsertBuilderFactory.ts

@@ -1,15 +1,17 @@
 import { PathFactory, WhereBuilder } from '../select'
 import { Model } from '@contember/schema'
 import { InsertBuilder } from './InsertBuilder'
+import { PredicateFactory } from '../../acl'
 
 export class InsertBuilderFactory {
 	constructor(
 		private readonly schema: Model.Schema,
 		private readonly whereBuilder: WhereBuilder,
 		private readonly pathFactory: PathFactory,
+		private readonly predicateFactory: PredicateFactory,
 	) {}
 
 	public create(entity: Model.Entity): InsertBuilder {
-		return new InsertBuilder(this.schema, entity, this.whereBuilder, this.pathFactory)
+		return new InsertBuilder(this.schema, entity, this.whereBuilder, this.pathFactory, this.predicateFactory)
 	}
 }

package/src/mapper/insert/Inserter.ts

@@ -10,11 +10,9 @@ import {
 import { CreateInputVisitor } from '../../inputProcessing'
 import { SqlCreateInputProcessor } from './SqlCreateInputProcessor'
 import { Mapper } from '../Mapper'
-import { Acl, Input, Model, Value } from '@contember/schema'
-import { acceptEveryFieldVisitor, Providers } from '@contember/schema-utils'
-import { PredicateFactory } from '../../acl'
+import { Input, Model, Value } from '@contember/schema'
+import { acceptEveryFieldVisitor, Providers, SchemaDatabaseMetadata } from '@contember/schema-utils'
 import { InsertBuilderFactory } from './InsertBuilderFactory'
-import { Client } from '@contember/database'
 import { InsertBuilder } from './InsertBuilder'
 import { tryMutation } from '../ErrorUtils'
 import { rowDataToFieldValues } from '../ColumnValue'
@@ -22,7 +20,7 @@ import { rowDataToFieldValues } from '../ColumnValue'
 export class Inserter {
 	constructor(
 		private readonly schema: Model.Schema,
-		private readonly predicateFactory: PredicateFactory,
+		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
 		private readonly insertBuilderFactory: InsertBuilderFactory,
 		private readonly providers: Providers,
 	) {}
@@ -31,15 +29,14 @@ export class Inserter {
 		mapper: Mapper,
 		entity: Model.Entity,
 		data: Input.CreateDataInput,
-		pushId: (id: string) => void,
+		insertIdCallback: (id: string) => void,
+		builderCb: (builder: InsertBuilder) => void,
 	): Promise<MutationResultList> {
-		const where = this.predicateFactory.create(entity, Acl.Operation.create, Object.keys(data))
 		const insertBuilder = this.insertBuilderFactory.create(entity)
 		// eslint-disable-next-line promise/catch-or-return
-		insertBuilder.insert.then(id => id && pushId(String(id)))
-
-		insertBuilder.addWhere(where)
+		insertBuilder.insert.then(id => id && insertIdCallback(String(id)))
 
+		insertBuilder.addPredicates(Object.keys(data))
 		const visitor = new CreateInputVisitor<MutationResultList>(
 			new SqlCreateInputProcessor(insertBuilder, mapper, this.providers),
 			this.schema,
@@ -50,21 +47,22 @@ export class Inserter {
 			entity,
 			visitor,
 		)
+		builderCb(insertBuilder)
 
 		const okResultFactory = (primary: Value.PrimaryValue, values: RowValues) =>
 			new MutationCreateOk([], entity, primary, data, values)
-		const insertPromise = this.executeInsert(insertBuilder, mapper.db, okResultFactory)
+		const insertPromise = this.executeInsert(insertBuilder, mapper, okResultFactory)
 
-		return await collectResults(this.schema, insertPromise, Object.values(promises))
+		return await collectResults(this.schema, this.schemaDatabaseMetadata, insertPromise, Object.values(promises))
 	}
 
 	private async executeInsert(
 		insertBuilder: InsertBuilder,
-		db: Client,
+		mapper: Mapper,
 		okResultFactory: (primary: Value.PrimaryValue, values: RowValues) => MutationCreateOk,
 	): Promise<MutationResultList> {
-		return tryMutation(this.schema, async () => {
-			const result = await insertBuilder.execute(db)
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
+			const result = await insertBuilder.execute(mapper)
 			if (result.aborted) {
 				return [new MutationNothingToDo([], NothingToDoReason.aborted)]
 			}
@@ -77,5 +75,3 @@ export class Inserter {
 	}
 }
 
-export const AbortInsert = Symbol('AbortInsert')
-export type AbortInsert = typeof AbortInsert

package/src/mapper/insert/SqlCreateInputProcessor.ts

@@ -2,18 +2,30 @@ import { Input, Model, Value } from '@contember/schema'
 import { Mapper } from '../Mapper'
 import { InsertBuilder } from './InsertBuilder'
 import { Providers, resolveColumnValue } from '@contember/schema-utils'
-import { CreateInputProcessor } from '../../inputProcessing'
 import * as Context from '../../inputProcessing'
-import { getInsertPrimary, MutationEntryNotFoundError, MutationResultList } from '../Result'
+import { CreateInputProcessor } from '../../inputProcessing'
+import { MutationResultList } from '../Result'
 import { hasManyProcessor, hasOneProcessor } from '../MutationProcessorHelper'
-import { AbortInsert } from './Inserter'
+import { OneHasOneInverseCreateInputProcessor } from '../relations/OneHasOneInverseCreateInputProcessor'
+import { OneHasOneOwningCreateInputProcessor } from '../relations/OneHasOneOwningCreateInputProcessor'
+import { ManyHasManyInputProcessor } from '../relations/ManyHasManyInputProcessor'
+import { ManyHasOneInputProcessor } from '../relations/ManyHasOneInputProcessor'
+import { OneHasManyInputProcessor } from '../relations/OneHasManyInputProcessor'
 
 export class SqlCreateInputProcessor implements CreateInputProcessor<MutationResultList> {
+
+	private oneHasOneInverseCreateInputProcessor = new OneHasOneInverseCreateInputProcessor(this.insertBuilder, this.mapper)
+	private oneHasOneOwningCreateInputProcessor = new OneHasOneOwningCreateInputProcessor(this.insertBuilder, this.mapper)
+	private oneHasManyCreateInputProcessor = new OneHasManyInputProcessor(this.mapper)
+	private manyHasOneCreateInputProcessor = new ManyHasOneInputProcessor(this.mapper)
+	private manyHasManyCreateInputProcessor = new ManyHasManyInputProcessor(this.mapper)
+
 	constructor(
 		private readonly insertBuilder: InsertBuilder,
 		private readonly mapper: Mapper,
 		private readonly providers: Providers,
-	) {}
+	) {
+	}
 
 	public async column(context: Model.ColumnContext & { input: Input.ColumnValue | undefined }): Promise<MutationResultList> {
 		this.insertBuilder.addFieldValue(
@@ -26,71 +38,50 @@ export class SqlCreateInputProcessor implements CreateInputProcessor<MutationRes
 	}
 
 	manyHasManyInverse: CreateInputProcessor<MutationResultList>['manyHasManyInverse'] = {
-		connect: hasManyProcessor(async (context): Promise<MutationResultList> => {
-			const inversePrimary = await this.insertBuilder.insert
-			if (!inversePrimary) {
+		connect: hasManyProcessor(async ctx => {
+			const primary = await this.insertBuilder.insert
+			if (!primary) {
 				return []
 			}
-			const owningPrimary = await this.mapper.getPrimaryValue(context.targetEntity, context.input)
-			if (!owningPrimary) {
-				return [new MutationEntryNotFoundError([], context.input)]
-			}
-			return await this.mapper.connectJunction(
-				context.targetEntity,
-				context.targetRelation,
-				owningPrimary,
-				inversePrimary,
-			)
+			return this.manyHasManyCreateInputProcessor.connect(ctx, primary)
 		}),
-		create: hasOneProcessor(async (context): Promise<MutationResultList> => {
-			const inversePrimary = await this.insertBuilder.insert
-			if (!inversePrimary) {
+		create: hasManyProcessor(async ctx => {
+			const primary = await this.insertBuilder.insert
+			if (!primary) {
 				return []
 			}
-			const insertResult = await this.mapper.insert(context.targetEntity, context.input)
-			const owningPrimary = getInsertPrimary(insertResult)
-			if (owningPrimary) {
-				const connectResult = await this.mapper.connectJunction(
-					context.targetEntity,
-					context.targetRelation,
-					owningPrimary,
-					inversePrimary,
-				)
-				return [...insertResult, ...connectResult]
+			return this.manyHasManyCreateInputProcessor.create(ctx, primary)
+		}),
+		connectOrCreate: hasManyProcessor(async ctx => {
+			const primary = await this.insertBuilder.insert
+			if (!primary) {
+				return []
 			}
-			return insertResult
+			return this.manyHasManyCreateInputProcessor.connectOrCreate(ctx, primary)
 		}),
 	}
 
 	manyHasManyOwning: CreateInputProcessor<MutationResultList>['manyHasManyOwning'] = {
-		connect: hasManyProcessor(async (context): Promise<MutationResultList> => {
+		connect: hasManyProcessor(async ctx => {
 			const primary = await this.insertBuilder.insert
 			if (!primary) {
 				return []
 			}
-			const inversePrimary = await this.mapper.getPrimaryValue(context.targetEntity, context.input)
-			if (!inversePrimary) {
-				return [new MutationEntryNotFoundError([], context.input)]
-			}
-			return await this.mapper.connectJunction(context.entity, context.relation, primary, inversePrimary)
+			return this.manyHasManyCreateInputProcessor.connect(ctx, primary)
 		}),
-		create: hasManyProcessor(async (context): Promise<MutationResultList> => {
+		create: hasManyProcessor(async ctx => {
 			const primary = await this.insertBuilder.insert
 			if (!primary) {
 				return []
 			}
-			const insertResult = await this.mapper.insert(context.targetEntity, context.input)
-			const inversePrimary = getInsertPrimary(insertResult)
-			if (inversePrimary) {
-				const connectResult = await this.mapper.connectJunction(
-					context.entity,
-					context.relation,
-					primary,
-					inversePrimary,
-				)
-				return [...insertResult, ...connectResult]
+			return this.manyHasManyCreateInputProcessor.create(ctx, primary)
+		}),
+		connectOrCreate: hasManyProcessor(async ctx => {
+			const primary = await this.insertBuilder.insert
+			if (!primary) {
+				return []
 			}
-			return insertResult
+			return this.manyHasManyCreateInputProcessor.connectOrCreate(ctx, primary)
 		}),
 	}
 
@@ -99,118 +90,49 @@ export class SqlCreateInputProcessor implements CreateInputProcessor<MutationRes
 			this.insertBuilder.addFieldValue(ctx.relation.name, null)
 			return []
 		},
-		connect: hasOneProcessor(async (context): Promise<MutationResultList> => {
-			const primaryValue = this.mapper.getPrimaryValue(context.targetEntity, context.input)
-			this.insertBuilder.addFieldValue(context.relation.name, async () => {
-				const value = await primaryValue
-				if (!value) {
-					return AbortInsert
-				}
-				return value
-			})
-			if (!(await primaryValue)) {
-				return [new MutationEntryNotFoundError([], context.input)]
-			}
-			return []
-		}),
-		create: hasOneProcessor(async (context): Promise<MutationResultList> => {
-			const insertPromise = this.mapper.insert(context.targetEntity, context.input)
-			await this.insertBuilder.addFieldValue(context.relation.name, async () => {
-				const insertResult = await insertPromise
-				const primary = getInsertPrimary(insertResult)
-				if (!primary) {
-					return AbortInsert
-				}
-				return primary
-			})
-			return await insertPromise
-		}),
+		connect: hasOneProcessor(ctx => this.manyHasOneCreateInputProcessor.connect(ctx, this.insertBuilder)),
+		create: hasOneProcessor(ctx => this.manyHasOneCreateInputProcessor.create(ctx, this.insertBuilder)),
+		connectOrCreate: hasOneProcessor(ctx => this.manyHasOneCreateInputProcessor.connectOrCreate(ctx, this.insertBuilder)),
 	}
 
 	oneHasMany: CreateInputProcessor<MutationResultList>['oneHasMany'] = {
-		connect: hasManyProcessor(async (context): Promise<MutationResultList> => {
+		connect: hasManyProcessor(async ctx => {
+			const primary = await this.insertBuilder.insert
+			if (!primary) {
+				return []
+			}
+			return this.oneHasManyCreateInputProcessor.connect(ctx, primary)
+		}),
+		create: hasManyProcessor(async ctx => {
 			const primary = await this.insertBuilder.insert
 			if (!primary) {
 				return []
 			}
-			return await this.mapper.update(context.targetEntity, context.input, {
-				[context.targetRelation.name]: {
-					connect: { [context.entity.primary]: primary },
-				},
-			})
+			return this.oneHasManyCreateInputProcessor.create(ctx, primary)
 		}),
-		create: hasManyProcessor(async (context): Promise<MutationResultList> => {
+		connectOrCreate: hasManyProcessor(async ctx => {
 			const primary = await this.insertBuilder.insert
 			if (!primary) {
 				return []
 			}
-			return await this.mapper.insert(context.targetEntity, {
-				...context.input,
-				[context.targetRelation.name]: {
-					connect: { [context.entity.primary]: primary },
-				},
-			})
+			return this.oneHasManyCreateInputProcessor.connectOrCreate(ctx, primary)
 		}),
 	}
 
+
 	oneHasOneOwning: CreateInputProcessor<MutationResultList>['oneHasOneOwning'] = {
 		nothing: async ctx => {
 			this.insertBuilder.addFieldValue(ctx.relation.name, null)
 			return []
 		},
-		connect: hasOneProcessor(
-			async (context: Model.OneHasOneOwningContext & { input: Input.UniqueWhere }): Promise<MutationResultList> => {
-				const primaryValue = this.mapper.getPrimaryValue(context.targetEntity, context.input)
-				this.insertBuilder.addFieldValue(context.relation.name, async () => {
-					const value = await primaryValue
-					if (!value) {
-						return AbortInsert
-					}
-					return value
-				})
-				if (!(await primaryValue)) {
-					return [new MutationEntryNotFoundError([], context.input)]
-				}
-				return []
-			},
-		),
-		create: hasOneProcessor(async (context): Promise<MutationResultList> => {
-			const insertPromise = this.mapper.insert(context.targetEntity, context.input)
-			await this.insertBuilder.addFieldValue(context.relation.name, async () => {
-				const insertResult = await insertPromise
-				const primary = getInsertPrimary(insertResult)
-				if (!primary) {
-					return AbortInsert
-				}
-				return primary
-			})
-			return await insertPromise
-		}),
+		connect: hasOneProcessor(ctx => this.oneHasOneOwningCreateInputProcessor.connect(ctx)),
+		create: hasOneProcessor(ctx => this.oneHasOneOwningCreateInputProcessor.create(ctx)),
+		connectOrCreate: hasOneProcessor(ctx => this.oneHasOneOwningCreateInputProcessor.connectOrCreate(ctx)),
 	}
 
 	oneHasOneInverse: CreateInputProcessor<MutationResultList>['oneHasOneInverse'] = {
-		connect: hasOneProcessor(async (context): Promise<MutationResultList> => {
-			const value = await this.insertBuilder.insert
-			if (!value) {
-				return []
-			}
-			return await this.mapper.update(context.targetEntity, context.input, {
-				[context.targetRelation.name]: {
-					connect: { [context.entity.primary]: value },
-				},
-			})
-		}),
-		create: hasOneProcessor(async (context): Promise<MutationResultList> => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return await this.mapper.insert(context.targetEntity, {
-				...context.input,
-				[context.targetRelation.name]: {
-					connect: { [context.entity.primary]: primary },
-				},
-			})
-		}),
+		connect: hasOneProcessor(ctx => this.oneHasOneInverseCreateInputProcessor.connect(ctx)),
+		create: hasOneProcessor(ctx => this.oneHasOneInverseCreateInputProcessor.create(ctx)),
+		connectOrCreate: hasOneProcessor(ctx => this.oneHasOneInverseCreateInputProcessor.connectOrCreate(ctx)),
 	}
 }

package/src/mapper/relations/ManyHasManyInputProcessor.ts

@@ -0,0 +1,108 @@
+import { UpdateInputProcessor } from '../../inputProcessing'
+import { Input, Model } from '@contember/schema'
+import { getInsertPrimary, MutationEntryNotFoundError, MutationResultList } from '../Result'
+import { Mapper } from '../Mapper'
+
+type RelationContext = Model.ManyHasManyOwningContext | Model.ManyHasManyInverseContext
+
+export class ManyHasManyInputProcessor {
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect(
+		{ entity, targetEntity, relation, targetRelation, input }: RelationContext & { input: Input.UniqueWhere },
+		primary: Input.PrimaryValue,
+	) {
+		const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, input)
+		if (!otherPrimary) {
+			return [new MutationEntryNotFoundError([], input)]
+		}
+		return await this.mapper.connectJunction(entity, relation, primary, otherPrimary)
+	}
+
+	public async create(
+		{ entity, targetEntity, relation, input }: RelationContext & { input: Input.CreateDataInput },
+		primary: Input.PrimaryValue,
+	) {
+		const insertResult = await this.mapper.insert(targetEntity, input)
+		const insertPrimary = getInsertPrimary(insertResult)
+		if (!insertPrimary) {
+			return insertResult
+		}
+		return [
+			...insertResult,
+			...(await this.mapper.connectJunction(entity, relation, primary, insertPrimary)),
+		]
+	}
+
+	public async connectOrCreate(
+		context: RelationContext & { input: Input.ConnectOrCreateInput },
+		primary: Input.PrimaryValue,
+	): Promise<MutationResultList> {
+		let otherPrimary = await this.mapper.getPrimaryValue(context.targetEntity, context.input.connect)
+		if (!otherPrimary) {
+			const insertResult = await this.mapper.insert(context.targetEntity, context.input.create)
+			otherPrimary = getInsertPrimary(insertResult)
+			if (!otherPrimary) {
+				return insertResult
+			}
+		}
+		return await this.mapper.connectJunction(context.entity, context.relation, primary, otherPrimary)
+	}
+
+	public async update(
+		{ entity, targetEntity, relation, input: { where, data } }: RelationContext & { input: UpdateInputProcessor.UpdateManyInput },
+		primary: Input.PrimaryValue,
+	) {
+		const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, where)
+		if (!otherPrimary) {
+			return [new MutationEntryNotFoundError([], where)]
+		}
+		return [
+			...(await this.mapper.update(targetEntity, { [targetEntity.primary]: otherPrimary }, data)),
+			...(await this.mapper.connectJunction(entity, relation, primary, otherPrimary)),
+		]
+	}
+
+	public async upsert(
+		{ entity, relation, targetEntity, input: { create, update, where } }: RelationContext & { input: UpdateInputProcessor.UpsertManyInput },
+		primary: Input.PrimaryValue,
+	) {
+		const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, where)
+		if (otherPrimary) {
+			const updateResult = await this.mapper.update(targetEntity, { [targetEntity.primary]: otherPrimary }, update)
+			const connectResult = await this.mapper.connectJunction(entity, relation, primary, otherPrimary)
+			return [...updateResult, ...connectResult]
+		} else {
+			const insertResult = await this.mapper.insert(targetEntity, create)
+
+			const primaryValue = getInsertPrimary(insertResult)
+			if (!primaryValue) {
+				return insertResult
+			}
+			const connectResult = await this.mapper.connectJunction(entity, relation, primary, primaryValue)
+			return [...insertResult, ...connectResult]
+		}
+	}
+
+	public async disconnect(
+		{ entity, targetEntity, relation, input }: RelationContext & { input: Input.UniqueWhere },
+		primary: Input.PrimaryValue,
+	) {
+		const otherPrimary = await this.mapper.getPrimaryValue(targetEntity, input)
+		if (!otherPrimary) {
+			return [new MutationEntryNotFoundError([], input)]
+		}
+
+		return await this.mapper.disconnectJunction(entity, relation, primary, otherPrimary)
+	}
+
+	public async delete(
+		{ entity, targetEntity, relation, targetRelation, input }: RelationContext & { input: Input.UniqueWhere },
+		primary: Input.PrimaryValue,
+	) {
+		return await this.mapper.delete(targetEntity, input)
+	}
+}