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

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)),
 	}
 }

package/src/mapper/update/UpdateBuilder.ts

@@ -1,10 +1,11 @@
 import { tuple } from '../../utils'
-import { Input, Model, Value } from '@contember/schema'
+import { Acl, Input, Model, Value } from '@contember/schema'
 import { acceptEveryFieldVisitor, getColumnName, getColumnType } from '@contember/schema-utils'
 import { Client, Operator, QueryBuilder, UpdateBuilder as DbUpdateBuilder, Value as DbValue } from '@contember/database'
 import { PathFactory, WhereBuilder } from '../select'
 import { ColumnValue, ResolvedColumnValue, resolveGenericValue, resolveRowData } from '../ColumnValue'
-import { AbortUpdate } from './Updater'
+import { PredicateFactory } from '../../acl'
+import { AbortDataManipulation, DataManipulationBuilder } from '../DataManipulationBuilder'
 
 export interface UpdateResult {
 	values: ResolvedColumnValue[]
@@ -13,16 +14,16 @@ export interface UpdateResult {
 	affectedRows: number | null
 }
 
-export class UpdateBuilder {
+export class UpdateBuilder implements DataManipulationBuilder {
 	private resolver: (value: number | null) => void = () => {
 		throw new Error('UpdateBuilder: Resolver called too soon')
 	}
 	public readonly update: Promise<number | null> = new Promise(resolve => (this.resolver = resolve))
 
-	private rowData: ColumnValue<AbortUpdate>[] = []
+	private rowData: Map<string, ColumnValue<AbortDataManipulation>> = new Map()
 
-	private newWhere: Input.OptionalWhere = {}
-	private oldWhere: Input.OptionalWhere = {}
+	private newWhere: { and: Input.OptionalWhere[] } = { and: [] }
+	private oldWhere: { and: Input.OptionalWhere[] } = { and: [] }
 
 	constructor(
 		private readonly schema: Model.Schema,
@@ -30,36 +31,42 @@ export class UpdateBuilder {
 		private readonly whereBuilder: WhereBuilder,
 		private readonly uniqueWhere: Input.Where,
 		private readonly pathFactory: PathFactory,
+		private readonly predicateFactory: PredicateFactory,
 	) {}
 
-	public async addFieldValue(
+	public addFieldValue(
 		fieldName: string,
-		value: Value.GenericValueLike<Value.AtomicValue<AbortUpdate | undefined>>,
-	): Promise<Value.AtomicValue<AbortUpdate | undefined>> {
+		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)
 		const resolvedValue = resolveGenericValue(value)
-		this.rowData.push({ columnName, value: resolvedValue, columnType, fieldName })
+		this.rowData.set(columnName, { columnName, value: resolvedValue, columnType, fieldName })
 		return resolvedValue
 	}
 
 	public addNewWhere(where: Input.OptionalWhere): void {
-		this.newWhere = { and: [where, this.newWhere] }
+		this.newWhere.and.push(where)
 	}
 
 	public addOldWhere(where: Input.OptionalWhere): void {
-		this.oldWhere = { and: [where, this.oldWhere] }
+		this.oldWhere.and.push(where)
+	}
+
+	public addPredicates(fields: string[]): void {
+		const predicate = this.predicateFactory.create(this.entity, Acl.Operation.update, fields)
+		this.addNewWhere(predicate)
+		this.addOldWhere(predicate)
 	}
 
 	public async execute(db: Client): Promise<UpdateResult> {
-		let resolvedDataFinal: ResolvedColumnValue[] | null = null
 		try {
-			const resolvedData = await resolveRowData<AbortUpdate>(this.rowData)
+			const resolvedData = await resolveRowData<AbortDataManipulation>([...this.rowData.values()])
 			if (Object.keys(resolvedData).length === 0) {
 				this.resolver(null)
 				return { values: [], affectedRows: null, executed: false, aborted: false }
 			}
-			if (resolvedData.find(it => it.resolvedValue === AbortUpdate)) {
+			if (resolvedData.find(it => it.resolvedValue === AbortDataManipulation)) {
 				this.resolver(null)
 				return { values: [], affectedRows: null, executed: false, aborted: true }
 			}