@contember/engine-content-api 1.2.0-rc.3 → 1.3.0-alpha.1

package/src/mapper/select/optimizer/WhereOptimizer.ts

@@ -140,7 +140,9 @@ export class WhereOptimizer {
 				const a = result[j]
 				const b = result[i]
 				if (i !== j && typeof a !== 'boolean' && typeof b !== 'boolean') {
-					const elResult = replaceWhere(a, b, { [entity.primary]: replacement })
+					const elResult = replaceWhere(a, b, { [entity.primary]: replacement }, {
+						replaceSubOperands: true,
+					})
 					if (elResult !== a) {
 						if (!copied) {
 							result = [...result]

package/src/mapper/select/optimizer/WhereReplacer.ts

@@ -1,39 +1,66 @@
 import { Input, Writable } from '@contember/schema'
 import deepEqual from 'fast-deep-equal'
 
-export const replaceWhere = (subject: Input.OptionalWhere, find: Input.OptionalWhere, replace: Input.OptionalWhere): Input.OptionalWhere => {
+export const replaceWhere = (subject: Input.OptionalWhere, find: Input.OptionalWhere, replace: Input.OptionalWhere, opts: { replaceSubOperands?: boolean } = {}): Input.OptionalWhere => {
 	if (deepEqual(subject, find)) {
 		return replace
 	}
 	let result: Writable<Input.OptionalWhere> = subject
 	let copied = false
+	// copy on write to preserve referential integrity, when nothing has changed
+	const write = <T extends string>(key: T, value: Input.OptionalWhere[T]) => {
+		if (!copied) {
+			result = { ...result }
+			copied = true
+		}
+		result[key] = value
+	}
+
 	for (const key in subject) {
 		const value = subject[key]
 		if (key === 'not') {
-			const newNot = replaceWhere(value as Input.OptionalWhere, find, replace)
+			const newNot = replaceWhere(value as Input.OptionalWhere, find, replace, opts)
 			if (newNot !== value) {
-				if (!copied) {
-					result = { ...result }
-				}
-				result['not'] = newNot
+				write('not', newNot)
 			}
 		} else if (key === 'and' || key === 'or') {
-			const items: Input.OptionalWhere[] = []
-			let itemChanged = false
-			for (const el of value as Input.OptionalWhere[]) {
-				const newEl = replaceWhere(el, find, replace)
-				if (newEl !== el) {
-					itemChanged = true
+			const operands = value as Input.OptionalWhere[]
+			const subOperandsToFind = opts.replaceSubOperands && Object.keys(find).length === 1 && find[key] ? (find[key] as Input.OptionalWhere[]) : null
+			if (subOperandsToFind !== null && containsAllOperands(operands, subOperandsToFind)) {
+				write(key, [replace])
+			} else {
+				const items: Input.OptionalWhere[] = []
+				let itemChanged = false
+				for (const el of operands) {
+					const newEl = replaceWhere(el, find, replace, opts)
+					if (newEl !== el) {
+						itemChanged = true
+					}
+					items.push(newEl)
 				}
-				items.push(newEl)
-			}
-			if (itemChanged) {
-				if (!copied) {
-					result = { ...result }
+				if (itemChanged) {
+					write(key, items)
 				}
-				result[key] = items
 			}
+
 		}
 	}
 	return result
 }
+
+
+const containsAllOperands = (subjectOperands: Input.OptionalWhere[], findOperands: Input.OptionalWhere[]): boolean => {
+	for (const op1 of findOperands) {
+		let found = false
+		for (const op2 of subjectOperands) {
+			if (deepEqual(op1, op2)) {
+				found = true
+				break
+			}
+		}
+		if (!found) {
+			return false
+		}
+	}
+	return true
+}

package/src/mapper/update/SqlUpdateInputProcessor.ts

@@ -1,24 +1,22 @@
 import { Input, Model, Value } from '@contember/schema'
 import { Mapper } from '../Mapper'
 import { UpdateBuilder } from './UpdateBuilder'
-import { UpdateInputProcessor } from '../../inputProcessing'
-import {
-	ConstraintType,
-	getInsertPrimary,
-	MutationConstraintViolationError,
-	MutationEntryNotFoundError,
-	MutationNothingToDo,
-	MutationResultList,
-	MutationResultType,
-	NothingToDoReason,
-} from '../Result'
 import { hasManyProcessor, hasOneProcessor } from '../MutationProcessorHelper'
-import { AbortUpdate } from './Updater'
-import { ImplementationException } from '../../exception'
-import { CheckedPrimary } from '../CheckedPrimary'
-import { logger } from '@contember/logger'
+import { OneHasOneInverseUpdateInputProcessor } from '../relations/OneHasOneInverseUpdateInputProcessor'
+import { OneHasOneOwningUpdateInputProcessor } from '../relations/OneHasOneOwningUpdateInputProcessor'
+import { OneHasManyInputProcessor } from '../relations/OneHasManyInputProcessor'
+import { ManyHasOneInputProcessor } from '../relations/ManyHasOneInputProcessor'
+import { ManyHasManyInputProcessor } from '../relations/ManyHasManyInputProcessor'
+import { UpdateInputProcessor } from '../../inputProcessing'
+import { MutationResultList } from '../Result'
 
 export class SqlUpdateInputProcessor implements UpdateInputProcessor<MutationResultList> {
+	private oneHasOneInverseUpdateInputProcessor = new OneHasOneInverseUpdateInputProcessor(this.primaryValue, this.mapper)
+	private oneHasOneOwningUpdateInputProcessor = new OneHasOneOwningUpdateInputProcessor(this.primaryValue, this.mapper, this.updateBuilder)
+	private oneHasManyUpdateInputProcessor = new OneHasManyInputProcessor(this.mapper)
+	private manyHasOneUpdateInputProcessor = new ManyHasOneInputProcessor(this.mapper)
+	private manyHasManyUpdateInputProcessor = new ManyHasManyInputProcessor(this.mapper)
+
 	constructor(
 		private readonly primaryValue: Input.PrimaryValue,
 		private readonly data: Input.UpdateDataInput,
@@ -34,489 +32,62 @@ export class SqlUpdateInputProcessor implements UpdateInputProcessor<MutationRes
 	}
 
 	manyHasManyInverse: UpdateInputProcessor<MutationResultList>['manyHasManyInverse'] = {
-		connect: hasManyProcessor(async ({ targetEntity, targetRelation, input, entity }) => {
-			const primaryValue = await this.mapper.getPrimaryValue(targetEntity, input)
-			if (!primaryValue) {
-				return [new MutationEntryNotFoundError([], input)]
-			}
-
-			return await this.mapper.connectJunction(targetEntity, targetRelation, primaryValue, this.primaryValue)
-		}),
-		create: hasManyProcessor(async ({ targetEntity, targetRelation, input, entity }) => {
-			const insertResult = await this.mapper.insert(targetEntity, input)
-			const primaryValue = getInsertPrimary(insertResult)
-			if (!primaryValue) {
-				return insertResult
-			}
-			return await this.mapper.connectJunction(targetEntity, targetRelation, primaryValue, this.primaryValue)
-		}),
-		update: hasManyProcessor(async ({ targetEntity, targetRelation, input: { where, data }, entity }) => {
-			const primary = await this.mapper.getPrimaryValue(targetEntity, where)
-			if (!primary) {
-				return [new MutationEntryNotFoundError([], where)]
-			}
-			return [
-				...(await this.mapper.update(targetEntity, { [targetEntity.primary]: primary }, data)),
-				...(await this.mapper.connectJunction(targetEntity, targetRelation, primary, this.primaryValue)),
-			]
-		}),
-		upsert: hasManyProcessor(async ({ targetEntity, targetRelation, input: { where, update, create }, entity }) => {
-			const primary = await this.mapper.getPrimaryValue(targetEntity, where)
-			if (primary) {
-				const updateResult = await this.mapper.update(targetEntity, { [targetEntity.primary]: primary }, update)
-				const connectResult = await this.mapper.connectJunction(
-					targetEntity,
-					targetRelation,
-					primary,
-					this.primaryValue,
-				)
-				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(
-					targetEntity,
-					targetRelation,
-					primaryValue,
-					this.primaryValue,
-				)
-				return [...insertResult, ...connectResult]
-			}
-		}),
-		delete: hasManyProcessor(async ({ targetEntity, input }) => {
-			return await this.mapper.delete(targetEntity, input)
-		}),
-		disconnect: hasManyProcessor(async ({ targetEntity, targetRelation, input, entity }) => {
-			const primaryValue = await this.mapper.getPrimaryValue(targetEntity, input)
-			if (!primaryValue) {
-				return [new MutationEntryNotFoundError([], input)]
-			}
-
-			return await this.mapper.disconnectJunction(targetEntity, targetRelation, primaryValue, this.primaryValue)
-		}),
+		connect: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.connect(ctx, this.primaryValue)),
+		create: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.create(ctx, this.primaryValue)),
+		connectOrCreate: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.connectOrCreate(ctx, this.primaryValue)),
+		update: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.update(ctx, this.primaryValue)),
+		upsert: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.upsert(ctx, this.primaryValue)),
+		delete: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.delete(ctx, this.primaryValue)),
+		disconnect: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.disconnect(ctx, this.primaryValue)),
 	}
 
 	manyHasManyOwning: UpdateInputProcessor<MutationResultList>['manyHasManyOwning'] = {
-		connect: hasManyProcessor(async ({ input, entity, relation, targetEntity }) => {
-			const primaryValue = await this.mapper.getPrimaryValue(targetEntity, input)
-			if (!primaryValue) {
-				return [new MutationEntryNotFoundError([], input)]
-			}
-			return await this.mapper.connectJunction(entity, relation, this.primaryValue, primaryValue)
-		}),
-		create: hasManyProcessor(async ({ targetEntity, input, entity, relation }) => {
-			const insertResult = await this.mapper.insert(targetEntity, input)
-			const insertPrimary = getInsertPrimary(insertResult)
-			if (!insertPrimary) {
-				return insertResult
-			}
-			return [
-				...insertResult,
-				...(await this.mapper.connectJunction(entity, relation, this.primaryValue, insertPrimary)),
-			]
-		}),
-		update: hasManyProcessor(async ({ targetEntity, input: { where, data }, entity, relation }) => {
-			const primary = await this.mapper.getPrimaryValue(targetEntity, where)
-			if (!primary) {
-				return [new MutationEntryNotFoundError([], where)]
-			}
-			return [
-				...(await this.mapper.update(targetEntity, { [targetEntity.primary]: primary }, data)),
-				...(await this.mapper.connectJunction(entity, relation, this.primaryValue, primary)),
-			]
-		}),
-		upsert: hasManyProcessor(async ({ targetEntity, input: { where, update, create }, entity, relation }) => {
-			const primary = await this.mapper.getPrimaryValue(targetEntity, where)
-			if (primary) {
-				const updateResult = await this.mapper.update(targetEntity, { [targetEntity.primary]: primary }, update)
-				const connectResult = await this.mapper.connectJunction(entity, relation, this.primaryValue, primary)
-				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, this.primaryValue, primaryValue)
-				return [...insertResult, ...connectResult]
-			}
-		}),
-		delete: hasManyProcessor(async ({ targetEntity, input }) => {
-			return await this.mapper.delete(targetEntity, input)
-		}),
-		disconnect: hasManyProcessor(async ({ input, entity, relation, targetEntity }) => {
-			const primaryValue = await this.mapper.getPrimaryValue(targetEntity, input)
-			if (!primaryValue) {
-				return [new MutationEntryNotFoundError([], input)]
-			}
-
-			return await this.mapper.disconnectJunction(entity, relation, this.primaryValue, primaryValue)
-		}),
+		connect: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.connect(ctx, this.primaryValue)),
+		create: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.create(ctx, this.primaryValue)),
+		connectOrCreate: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.connectOrCreate(ctx, this.primaryValue)),
+		update: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.update(ctx, this.primaryValue)),
+		upsert: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.upsert(ctx, this.primaryValue)),
+		delete: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.delete(ctx, this.primaryValue)),
+		disconnect: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.disconnect(ctx, this.primaryValue)),
 	}
 
 	manyHasOne: UpdateInputProcessor<MutationResultList>['manyHasOne'] = {
-		connect: hasOneProcessor(async ({ targetEntity, input, relation }) => {
-			const primaryValue = this.mapper.getPrimaryValue(targetEntity, input)
-			this.updateBuilder.addFieldValue(relation.name, async () => {
-				const value = await primaryValue
-				if (!value) {
-					return AbortUpdate
-				}
-				return value
-			})
-			if (!(await primaryValue)) {
-				return [new MutationEntryNotFoundError([], input)]
-			}
-			return []
-		}),
-		create: hasOneProcessor(async ({ targetEntity, input, relation }) => {
-			// intentionally no await here
-			const insert = this.mapper.insert(targetEntity, input)
-			this.updateBuilder.addFieldValue(relation.name, async () => {
-				const insertResult = await insert
-				const value = getInsertPrimary(insertResult)
-				if (!value) {
-					return AbortUpdate
-				}
-				return value
-			})
-			return await insert
-		}),
-		update: hasOneProcessor(async ({ targetEntity, input, entity, relation }) => {
-			const inversePrimary = await this.mapper.selectField(
-				entity,
-				{ [entity.primary]: this.primaryValue },
-				relation.name,
-			)
-			if (!inversePrimary) {
-				return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
-			}
-			return await this.mapper.update(targetEntity, { [targetEntity.primary]: inversePrimary }, input)
-		}),
-		upsert: hasOneProcessor(async ({ targetEntity, input: { create, update }, entity, relation }) => {
-			const select = this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
-
-			const result: MutationResultList = []
-			// addFieldValue has to be called immediately
-			await this.updateBuilder.addFieldValue(relation.name, async () => {
-				const primary = await select
-				if (primary) {
-					return undefined
-				}
-				const insertResult = await this.mapper.insert(targetEntity, create)
-				const insertPrimary = getInsertPrimary(insertResult)
-				if (insertPrimary) {
-					return insertPrimary
-				}
-				result.push(...insertResult)
-				return AbortUpdate
-			})
-
-			const inversePrimary = await select
-			if (inversePrimary) {
-				return await this.mapper.update(targetEntity, { [targetEntity.primary]: inversePrimary }, update)
-			} else {
-				return result
-			}
-		}),
-		delete: hasOneProcessor(async ({ targetEntity, entity, relation }) => {
-			if (!relation.nullable && relation.joiningColumn.onDelete !== Model.OnDelete.cascade) {
-				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-			}
-			if (relation.joiningColumn.onDelete === Model.OnDelete.restrict) {
-				logger.warn('You are deleting an entity over the relation where onDelete behaviour is set to restrict. This will fail in next version.', { loc: 'SqlUpdateInputProcessor' })
-				this.updateBuilder.addFieldValue(relation.name, null)
-			}
-			const inversePrimary = await this.mapper.selectField(
-				entity,
-				{ [entity.primary]: this.primaryValue },
-				relation.name,
-			)
-			await this.updateBuilder.update
-			return await this.mapper.delete(targetEntity, { [targetEntity.primary]: inversePrimary })
-		}),
-		disconnect: hasOneProcessor(async ({ entity, relation }) => {
-			if (!relation.nullable) {
-				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-			}
-			this.updateBuilder.addFieldValue(relation.name, null)
-			return []
-		}),
+		connect: hasOneProcessor(ctx => this.manyHasOneUpdateInputProcessor.connect(ctx, this.updateBuilder)),
+		create: hasOneProcessor(ctx => this.manyHasOneUpdateInputProcessor.create(ctx, this.updateBuilder)),
+		connectOrCreate: hasOneProcessor(ctx => this.manyHasOneUpdateInputProcessor.connectOrCreate(ctx, this.updateBuilder)),
+		update: hasOneProcessor(ctx => this.manyHasOneUpdateInputProcessor.update(ctx, this.primaryValue)),
+		upsert: hasOneProcessor(ctx => this.manyHasOneUpdateInputProcessor.upsert(ctx, this.updateBuilder, this.primaryValue)),
+		delete: hasOneProcessor(ctx => this.manyHasOneUpdateInputProcessor.delete(ctx, this.updateBuilder, this.primaryValue)),
+		disconnect: hasOneProcessor(ctx => this.manyHasOneUpdateInputProcessor.disconnect(ctx, this.updateBuilder)),
 	}
 
 	oneHasMany: UpdateInputProcessor<MutationResultList>['oneHasMany'] = {
-		connect: hasManyProcessor(async ({ targetEntity, targetRelation, input, entity }) => {
-			return await this.mapper.update(targetEntity, input, {
-				[targetRelation.name]: { connect: { [entity.primary]: this.primaryValue } },
-			})
-		}),
-		create: hasManyProcessor(async ({ targetEntity, targetRelation, input, entity }) => {
-			return await this.mapper.insert(targetEntity, {
-				...input,
-				[targetRelation.name]: { connect: { [entity.primary]: this.primaryValue } },
-			})
-		}),
-		update: hasManyProcessor(async ({ targetEntity, targetRelation, input: { where, data }, entity }) => {
-			return await this.mapper.update(
-				targetEntity,
-				{ ...where, [targetRelation.name]: { [entity.primary]: this.primaryValue } },
-				{
-					...data,
-					// [targetRelation.name]: {connect: thisPrimary}
-				},
-			)
-		}),
-		upsert: hasManyProcessor(async ({ targetEntity, targetRelation, input: { create, where, update }, entity }) => {
-			const result = await this.mapper.update(
-				targetEntity,
-				{ ...where, [targetRelation.name]: { [entity.primary]: this.primaryValue } },
-				{
-					...update,
-					// [targetRelation.name]: {connect: thisPrimary}
-				},
-			)
-			if (result[0].result === MutationResultType.notFoundError) {
-				return await this.mapper.insert(targetEntity, {
-					...create,
-					[targetRelation.name]: { connect: { [entity.primary]: this.primaryValue } },
-				})
-			}
-			return result
-		}),
-		delete: hasManyProcessor(async ({ targetEntity, targetRelation, input, entity }) => {
-			return await this.mapper.delete(targetEntity, {
-				...input,
-				[targetRelation.name]: { [entity.primary]: this.primaryValue },
-			})
-		}),
-		disconnect: hasManyProcessor(async ({ targetEntity, targetRelation, input, entity }) => {
-			return await this.mapper.update(
-				targetEntity,
-				{ ...input, [targetRelation.name]: { [entity.primary]: this.primaryValue } },
-				{ [targetRelation.name]: { disconnect: true } },
-			)
-		}),
+		connect: hasManyProcessor(ctx => this.oneHasManyUpdateInputProcessor.connect(ctx, this.primaryValue)),
+		create: hasManyProcessor(ctx => this.oneHasManyUpdateInputProcessor.create(ctx, this.primaryValue)),
+		connectOrCreate: hasManyProcessor(ctx => this.oneHasManyUpdateInputProcessor.connectOrCreate(ctx, this.primaryValue)),
+		update: hasManyProcessor(ctx => this.oneHasManyUpdateInputProcessor.update(ctx, this.primaryValue)),
+		upsert: hasManyProcessor(ctx => this.oneHasManyUpdateInputProcessor.upsert(ctx, this.primaryValue)),
+		delete: hasManyProcessor(ctx => this.oneHasManyUpdateInputProcessor.delete(ctx, this.primaryValue)),
+		disconnect: hasManyProcessor(ctx => this.oneHasManyUpdateInputProcessor.disconnect(ctx, this.primaryValue)),
 	}
 
 	oneHasOneInverse: UpdateInputProcessor<MutationResultList>['oneHasOneInverse'] = {
-		connect: hasOneProcessor(async ({ targetEntity, targetRelation, input, entity }) => {
-			return await this.mapper.update(targetEntity, input, {
-				[targetRelation.name]: { connect: { [entity.primary]: this.primaryValue } },
-			})
-		}),
-		create: hasOneProcessor(async ({ targetEntity, targetRelation, input, entity }) => {
-			return [
-				...(
-					await this.mapper.update(
-						targetEntity,
-						{ [targetRelation.name]: { [entity.primary]: this.primaryValue } },
-						{ [targetRelation.name]: { disconnect: true } },
-					)
-				).filter(it => it.result !== MutationResultType.notFoundError),
-				...(await this.mapper.insert(targetEntity, {
-					...input,
-					[targetRelation.name]: { connect: { [entity.primary]: this.primaryValue } },
-				})),
-			]
-		}),
-		update: hasOneProcessor(async ({ targetEntity, targetRelation, input, entity }) => {
-			return await this.mapper.update(
-				targetEntity,
-				{ [targetRelation.name]: { [entity.primary]: this.primaryValue } },
-				input,
-			)
-		}),
-		upsert: hasOneProcessor(async ({ targetEntity, targetRelation, input: { create, update }, entity }) => {
-			const result = await this.mapper.update(
-				targetEntity,
-				{ [targetRelation.name]: { [entity.primary]: this.primaryValue } },
-				update,
-			)
-			if (result[0].result === MutationResultType.notFoundError) {
-				return await this.mapper.insert(targetEntity, {
-					...create,
-					[targetRelation.name]: { connect: { [entity.primary]: this.primaryValue } },
-				})
-			}
-			return result
-		}),
-		delete: hasOneProcessor(async ({ targetEntity, targetRelation, entity, relation }) => {
-			if (!relation.nullable) {
-				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-			}
-			return await this.mapper.delete(targetEntity, { [targetRelation.name]: { [entity.primary]: this.primaryValue } })
-		}),
-		disconnect: hasOneProcessor(async ({ targetEntity, targetRelation, entity, relation }) => {
-			if (!relation.nullable) {
-				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-			}
-			return await this.mapper.update(
-				targetEntity,
-				{ [targetRelation.name]: { [entity.primary]: this.primaryValue } },
-				{ [targetRelation.name]: { disconnect: true } },
-			)
-		}),
+		connect: hasOneProcessor(ctx => this.oneHasOneInverseUpdateInputProcessor.connect(ctx)),
+		create: hasOneProcessor(ctx => this.oneHasOneInverseUpdateInputProcessor.create(ctx)),
+		connectOrCreate: hasOneProcessor(ctx => this.oneHasOneInverseUpdateInputProcessor.connectOrCreate(ctx)),
+		update: hasOneProcessor(ctx => this.oneHasOneInverseUpdateInputProcessor.update(ctx)),
+		upsert: hasOneProcessor(ctx => this.oneHasOneInverseUpdateInputProcessor.upsert(ctx)),
+		delete: hasOneProcessor(ctx => this.oneHasOneInverseUpdateInputProcessor.delete(ctx)),
+		disconnect: hasOneProcessor(ctx => this.oneHasOneInverseUpdateInputProcessor.disconnect(ctx)),
 	}
 
 	oneHasOneOwning: UpdateInputProcessor<MutationResultList>['oneHasOneOwning'] = {
-		connect: hasOneProcessor(async ({ targetEntity, input, entity, relation, targetRelation }) => {
-			const result: MutationResultList = []
-
-			await this.updateBuilder.addFieldValue(relation.name, async () => {
-				const targetPrimary = (await this.mapper.getPrimaryValue(targetEntity, input)) as Input.PrimaryValue
-				if (!targetPrimary) {
-					result.push(new MutationEntryNotFoundError([], input))
-					return AbortUpdate
-				}
-
-				const currentOwnerOfTarget = await this.mapper.getPrimaryValue(entity, {
-					[relation.name]: { [targetEntity.primary]: targetPrimary },
-				})
-
-				if (currentOwnerOfTarget === this.primaryValue) {
-					// same owner, nothing to do
-					return undefined
-				}
-				if (targetRelation && !targetRelation.nullable) {
-					const currentTargetPrimary = await this.mapper.selectField(
-						entity,
-						{ [entity.primary]: this.primaryValue },
-						relation.name,
-					)
-					if (currentTargetPrimary === targetPrimary) {
-						// should be already handled in a currentOwnerOfTarget === this.primaryValue branch
-						throw new ImplementationException()
-					}
-					if (currentTargetPrimary) {
-						result.push(new MutationConstraintViolationError([], ConstraintType.uniqueKey))
-						return AbortUpdate
-					}
-				}
-
-				if (currentOwnerOfTarget) {
-					if (!relation.nullable) {
-						result.push(new MutationConstraintViolationError([], ConstraintType.notNull))
-						return AbortUpdate
-					}
-
-					result.push(
-						...(await this.mapper.updateInternal(
-							entity,
-							{
-								[entity.primary]: currentOwnerOfTarget,
-							},
-							[relation.name],
-							builder => {
-								builder.addFieldValue(relation.name, null)
-							},
-						)),
-					)
-				}
-				return targetPrimary
-			})
-			return result
-		}),
-		create: hasOneProcessor(async ({ targetEntity, input, relation, entity, targetRelation }) => {
-			const insert = this.mapper.insert(targetEntity, input)
-			const result: MutationResultList = []
-			this.updateBuilder.addFieldValue(relation.name, async () => {
-				if (targetRelation && !targetRelation.nullable) {
-					const currentTargetPrimary = await this.mapper.selectField(
-						entity,
-						{ [entity.primary]: this.primaryValue },
-						relation.name,
-					)
-					if (currentTargetPrimary) {
-						result.push(new MutationConstraintViolationError([], ConstraintType.uniqueKey))
-						return AbortUpdate
-					}
-				}
-
-				const insertResult = await insert
-				const insertPrimary = getInsertPrimary(insertResult)
-				if (insertPrimary) {
-					return insertPrimary
-				}
-				return AbortUpdate
-			})
-			result.push(...(await insert))
-			return result
-		}),
-		update: hasOneProcessor(async ({ targetEntity, input, entity, relation }) => {
-			const inversePrimary = await this.mapper.selectField(
-				entity,
-				{ [entity.primary]: this.primaryValue },
-				relation.name,
-			)
-			if (!inversePrimary) {
-				return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
-			}
-			return await this.mapper.update(targetEntity, { [targetEntity.primary]: inversePrimary }, input)
-		}),
-		upsert: hasOneProcessor(async ({ targetEntity, input: { create, update }, entity, relation }) => {
-			const select = this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
-
-			const result: MutationResultList = []
-			//addColumnData has to be called synchronously
-			await this.updateBuilder.addFieldValue(relation.name, async () => {
-				const primary = await select
-				if (primary) {
-					return undefined
-				}
-				const insertResult = await this.mapper.insert(targetEntity, create)
-				const insertPrimary = getInsertPrimary(insertResult)
-				if (insertPrimary) {
-					return insertPrimary
-				}
-				result.push(...insertResult)
-				return AbortUpdate
-			})
-
-			const inversePrimary = await select
-			if (inversePrimary) {
-				return await this.mapper.update(targetEntity, { [targetEntity.primary]: inversePrimary }, update)
-			}
-			return result
-		}),
-		delete: hasOneProcessor(async ({ targetEntity, entity, relation }) => {
-			if (!relation.nullable && relation.joiningColumn.onDelete !== Model.OnDelete.cascade) {
-				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-			}
-			if (relation.joiningColumn.onDelete === Model.OnDelete.restrict) {
-				logger.warn('You are deleting an entity over the relation where onDelete behaviour is set to restrict. This will fail in next version.', { loc: 'SqlUpdateInputProcessor' })
-				this.updateBuilder.addFieldValue(relation.name, null)
-			}
-			const targetPrimary = await this.mapper.selectField(
-				entity,
-				{ [entity.primary]: this.primaryValue },
-				relation.name,
-			)
-			if (!targetPrimary) {
-				return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
-			}
-			await this.updateBuilder.update
-			return await this.mapper.delete(targetEntity, new CheckedPrimary(targetPrimary))
-		}),
-		disconnect: hasOneProcessor(async ({ entity, relation, targetRelation, input }) => {
-			if (!relation.nullable) {
-				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-			}
-			if (targetRelation && !targetRelation.nullable) {
-				const targetPrimary = await this.mapper.selectField(
-					entity,
-					{ [entity.primary]: this.primaryValue },
-					relation.name,
-				)
-				if (targetPrimary) {
-					return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-				}
-			}
-			this.updateBuilder.addFieldValue(relation.name, null)
-			return []
-		}),
+		connect: hasOneProcessor(ctx => this.oneHasOneOwningUpdateInputProcessor.connect(ctx)),
+		create: hasOneProcessor(ctx => this.oneHasOneOwningUpdateInputProcessor.create(ctx)),
+		connectOrCreate: hasOneProcessor(ctx => this.oneHasOneOwningUpdateInputProcessor.connectOrCreate(ctx)),
+		update: hasOneProcessor(ctx => this.oneHasOneOwningUpdateInputProcessor.update(ctx)),
+		upsert: hasOneProcessor(ctx => this.oneHasOneOwningUpdateInputProcessor.upsert(ctx)),
+		delete: hasOneProcessor(ctx => this.oneHasOneOwningUpdateInputProcessor.delete(ctx)),
+		disconnect: hasOneProcessor(ctx => this.oneHasOneOwningUpdateInputProcessor.disconnect(ctx)),
 	}
 }