@contember/engine-content-api 2.0.0-alpha.8 → 2.0.0-beta.1

package/src/mapper/update/SqlUpdateInputProcessor.ts

@@ -2,32 +2,35 @@ import { Input, Model, Value } from '@contember/schema'
 import { Mapper } from '../Mapper'
 import { UpdateBuilder } from './UpdateBuilder'
 import { hasManyProcessor, hasOneProcessor } from '../MutationProcessorHelper'
-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 { OneHasOneInverseUpdateInputProcessor } from './relations/OneHasOneInverseUpdateInputProcessor'
+import { OneHasOneOwningUpdateInputProcessor } from './relations/OneHasOneOwningUpdateInputProcessor'
+import { OneHasManyUpdateInputProcessor } from './relations/OneHasManyUpdateInputProcessor'
+import { ManyHasManyUpdateInputProcessor } from './relations/ManyHasManyUpdateInputProcessor'
 import { UpdateInputProcessor } from '../../inputProcessing'
 import { MutationResultList } from '../Result'
+import { ManyHasOneUpdateInputProcessor } from './relations/ManyHasOneUpdateInputProcessor'
+import { MapperInput } from '../types'
 
-export class SqlUpdateInputProcessor implements UpdateInputProcessor<MutationResultList> {
+export type SqlUpdateInputProcessorResult = MutationResultList | ((ctx: { primary: Input.PrimaryValue}) => Promise<MutationResultList>)
+
+export class SqlUpdateInputProcessor implements UpdateInputProcessor<SqlUpdateInputProcessorResult> {
 	private oneHasOneInverseUpdateInputProcessor: OneHasOneInverseUpdateInputProcessor
 	private oneHasOneOwningUpdateInputProcessor: OneHasOneOwningUpdateInputProcessor
-	private oneHasManyUpdateInputProcessor: OneHasManyInputProcessor
-	private manyHasOneUpdateInputProcessor: ManyHasOneInputProcessor
-	private manyHasManyUpdateInputProcessor: ManyHasManyInputProcessor
+	private oneHasManyUpdateInputProcessor: OneHasManyUpdateInputProcessor
+	private manyHasOneUpdateInputProcessor: ManyHasOneUpdateInputProcessor
+	private manyHasManyUpdateInputProcessor: ManyHasManyUpdateInputProcessor
 
 	constructor(
 		private readonly primaryValue: Input.PrimaryValue,
-		private readonly data: Input.UpdateDataInput,
+		private readonly data: MapperInput.UpdateDataInput,
 		private readonly updateBuilder: UpdateBuilder,
 		private readonly mapper: Mapper,
 	) {
 		this.oneHasOneInverseUpdateInputProcessor = new OneHasOneInverseUpdateInputProcessor(this.primaryValue, this.mapper)
 		this.oneHasOneOwningUpdateInputProcessor = new OneHasOneOwningUpdateInputProcessor(this.primaryValue, this.mapper, this.updateBuilder)
-		this.oneHasManyUpdateInputProcessor = new OneHasManyInputProcessor(this.mapper)
-		this.manyHasOneUpdateInputProcessor = new ManyHasOneInputProcessor(this.mapper)
-		this.manyHasManyUpdateInputProcessor = new ManyHasManyInputProcessor(this.mapper)
+		this.oneHasManyUpdateInputProcessor = new OneHasManyUpdateInputProcessor(this.mapper)
+		this.manyHasOneUpdateInputProcessor = new ManyHasOneUpdateInputProcessor(this.mapper, this.updateBuilder, this.primaryValue)
+		this.manyHasManyUpdateInputProcessor = new ManyHasManyUpdateInputProcessor(this.mapper)
 	}
 
 	public column({ entity, column }: Model.ColumnContext) {
@@ -37,47 +40,47 @@ export class SqlUpdateInputProcessor implements UpdateInputProcessor<MutationRes
 		return Promise.resolve([])
 	}
 
-	manyHasManyInverse: UpdateInputProcessor<MutationResultList>['manyHasManyInverse'] = {
-		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)),
+	manyHasManyInverse: UpdateInputProcessor<SqlUpdateInputProcessorResult>['manyHasManyInverse'] = {
+		connect: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.connect(ctx)),
+		create: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.create(ctx)),
+		connectOrCreate: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.connectOrCreate(ctx)),
+		update: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.update(ctx)),
+		upsert: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.upsert(ctx)),
+		delete: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.delete(ctx)),
+		disconnect: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.disconnect(ctx)),
 	}
 
-	manyHasManyOwning: UpdateInputProcessor<MutationResultList>['manyHasManyOwning'] = {
-		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<SqlUpdateInputProcessorResult>['manyHasManyOwning'] = {
+		connect: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.connect(ctx)),
+		create: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.create(ctx)),
+		connectOrCreate: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.connectOrCreate(ctx)),
+		update: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.update(ctx)),
+		upsert: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.upsert(ctx)),
+		delete: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.delete(ctx)),
+		disconnect: hasManyProcessor(ctx => this.manyHasManyUpdateInputProcessor.disconnect(ctx)),
 	}
 
-	manyHasOne: UpdateInputProcessor<MutationResultList>['manyHasOne'] = {
-		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)),
+	manyHasOne: UpdateInputProcessor<SqlUpdateInputProcessorResult>['manyHasOne'] = {
+		connect: hasOneProcessor(ctx => this.manyHasOneUpdateInputProcessor.connect(ctx)),
+		create: hasOneProcessor(ctx => this.manyHasOneUpdateInputProcessor.create(ctx)),
+		connectOrCreate: hasOneProcessor(ctx => this.manyHasOneUpdateInputProcessor.connectOrCreate(ctx)),
+		update: hasOneProcessor(ctx => this.manyHasOneUpdateInputProcessor.update(ctx)),
+		upsert: hasOneProcessor(ctx => this.manyHasOneUpdateInputProcessor.upsert(ctx)),
+		delete: hasOneProcessor(ctx => this.manyHasOneUpdateInputProcessor.delete(ctx)),
+		disconnect: hasOneProcessor(ctx => this.manyHasOneUpdateInputProcessor.disconnect(ctx)),
 	}
 
-	oneHasMany: UpdateInputProcessor<MutationResultList>['oneHasMany'] = {
-		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)),
+	oneHasMany: UpdateInputProcessor<SqlUpdateInputProcessorResult>['oneHasMany'] = {
+		connect: hasManyProcessor(ctx => this.oneHasManyUpdateInputProcessor.connect(ctx)),
+		create: hasManyProcessor(ctx => this.oneHasManyUpdateInputProcessor.create(ctx)),
+		connectOrCreate: hasManyProcessor(ctx => this.oneHasManyUpdateInputProcessor.connectOrCreate(ctx)),
+		update: hasManyProcessor(ctx => this.oneHasManyUpdateInputProcessor.update(ctx)),
+		upsert: hasManyProcessor(ctx => this.oneHasManyUpdateInputProcessor.upsert(ctx)),
+		delete: hasManyProcessor(ctx => this.oneHasManyUpdateInputProcessor.delete(ctx)),
+		disconnect: hasManyProcessor(ctx => this.oneHasManyUpdateInputProcessor.disconnect(ctx)),
 	}
 
-	oneHasOneInverse: UpdateInputProcessor<MutationResultList>['oneHasOneInverse'] = {
+	oneHasOneInverse: UpdateInputProcessor<SqlUpdateInputProcessorResult>['oneHasOneInverse'] = {
 		connect: hasOneProcessor(ctx => this.oneHasOneInverseUpdateInputProcessor.connect(ctx)),
 		create: hasOneProcessor(ctx => this.oneHasOneInverseUpdateInputProcessor.create(ctx)),
 		connectOrCreate: hasOneProcessor(ctx => this.oneHasOneInverseUpdateInputProcessor.connectOrCreate(ctx)),
@@ -87,7 +90,7 @@ export class SqlUpdateInputProcessor implements UpdateInputProcessor<MutationRes
 		disconnect: hasOneProcessor(ctx => this.oneHasOneInverseUpdateInputProcessor.disconnect(ctx)),
 	}
 
-	oneHasOneOwning: UpdateInputProcessor<MutationResultList>['oneHasOneOwning'] = {
+	oneHasOneOwning: UpdateInputProcessor<SqlUpdateInputProcessorResult>['oneHasOneOwning'] = {
 		connect: hasOneProcessor(ctx => this.oneHasOneOwningUpdateInputProcessor.connect(ctx)),
 		create: hasOneProcessor(ctx => this.oneHasOneOwningUpdateInputProcessor.create(ctx)),
 		connectOrCreate: hasOneProcessor(ctx => this.oneHasOneOwningUpdateInputProcessor.connectOrCreate(ctx)),

package/src/mapper/update/UpdateBuilder.ts

@@ -1,28 +1,21 @@
 import { tuple } from '../../utils'
 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 { Operator, QueryBuilder, UpdateBuilder as DbUpdateBuilder, Value as DbValue } from '@contember/database'
 import { PathFactory, WhereBuilder } from '../select'
-import { ColumnValue, ResolvedColumnValue, resolveGenericValue, resolveRowData } from '../ColumnValue'
+import { ColumnValue, normalizeDbValue } from '../ColumnValue'
 import { PredicateFactory } from '../../acl'
-import { AbortDataManipulation, DataManipulationBuilder } from '../DataManipulationBuilder'
-import { AfterUpdateEvent, BeforeUpdateEvent, EventManager } from '../EventManager'
+import { AfterUpdateEvent, BeforeUpdateEvent } from '../EventManager'
 import { Mapper } from '../Mapper'
 
 export interface UpdateResult {
-	values: ResolvedColumnValue[]
+	values: ColumnValue[]
 	executed: boolean
-	aborted: boolean
 	affectedRows: number | null
 }
 
-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: Map<string, ColumnValue<AbortDataManipulation>> = new Map()
+export class UpdateBuilder {
+	private rowData: Map<string, ColumnValue> = new Map()
 
 	private newWhere: { and: Input.OptionalWhere[] } = { and: [] }
 	private oldWhere: { and: Input.OptionalWhere[] } = { and: [] }
@@ -38,13 +31,15 @@ export class UpdateBuilder implements DataManipulationBuilder {
 
 	public addFieldValue(
 		fieldName: string,
-		value: Value.GenericValueLike<Value.AtomicValue<AbortDataManipulation | undefined>>,
-	): Promise<Value.AtomicValue<AbortDataManipulation | undefined>> {
+		value: Value.FieldValue | undefined,
+	): void {
+		if (value === undefined) {
+			return
+		}
 		const columnName = getColumnName(this.schema, this.entity, fieldName)
 		const columnType = getColumnType(this.schema, this.entity, fieldName)
-		const resolvedValue = resolveGenericValue(value)
-		this.rowData.set(columnName, { columnName, value: resolvedValue, columnType, fieldName })
-		return resolvedValue
+
+		this.rowData.set(columnName, { columnName, value, columnType, fieldName })
 	}
 
 	public addNewWhere(where: Input.OptionalWhere): void {
@@ -63,14 +58,9 @@ export class UpdateBuilder implements DataManipulationBuilder {
 
 	public async execute(mapper: Mapper): Promise<UpdateResult> {
 		try {
-			const resolvedData = await resolveRowData<AbortDataManipulation>([...this.rowData.values()])
+			const resolvedData = [...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 === AbortDataManipulation)) {
-				this.resolver(null)
-				return { values: [], affectedRows: null, executed: false, aborted: true }
+				return { values: [], affectedRows: null, executed: false }
 			}
 			const oldColSuffix = '_old__'
 
@@ -79,7 +69,13 @@ export class UpdateBuilder implements DataManipulationBuilder {
 					qb = resolvedData.reduce(
 						(qb, value) =>
 							qb
-								.select(expr => expr.selectValue(value.resolvedValue as DbValue, value.columnType), value.columnName)
+								.select(
+									expr => expr.selectValue(
+										normalizeDbValue(value.value, value.columnType),
+										value.columnType,
+									),
+									value.columnName,
+								)
 								.select(['root_', value.columnName], value.columnName + oldColSuffix),
 						qb,
 					)
@@ -130,14 +126,13 @@ export class UpdateBuilder implements DataManipulationBuilder {
 				})
 
 
-			const beforeEvent = new BeforeUpdateEvent(this.entity, resolvedData as ResolvedColumnValue[], this.primary)
+			const beforeEvent = new BeforeUpdateEvent(this.entity, resolvedData, this.primary)
 			await mapper.eventManager.fire(beforeEvent)
 
 			const result = await qb.execute(mapper.db)
-			this.resolver(result.length)
 
 			if (result.length === 1) {
-				const eventData = (resolvedData as ResolvedColumnValue[]).map(it => ({
+				const eventData = (resolvedData).map(it => ({
 					...it,
 					old: result[0][it.columnName + oldColSuffix],
 				}))
@@ -146,9 +141,8 @@ export class UpdateBuilder implements DataManipulationBuilder {
 				await mapper.eventManager.fire(afterUpdateEvent)
 			}
 
-			return { values: resolvedData as ResolvedColumnValue[], affectedRows: result.length, executed: true, aborted: false }
+			return { values: resolvedData, affectedRows: result.length, executed: true }
 		} catch (e) {
-			this.resolver(null)
 			throw e
 		}
 	}

package/src/mapper/update/Updater.ts

@@ -1,23 +1,15 @@
-import { SqlUpdateInputProcessor } from './SqlUpdateInputProcessor'
+import { SqlUpdateInputProcessor, SqlUpdateInputProcessorResult } from './SqlUpdateInputProcessor'
 import { UpdateInputVisitor } from '../../inputProcessing'
 import { Input, Model } from '@contember/schema'
 import { PredicateFactory } from '../../acl'
 import { UpdateBuilderFactory } from './UpdateBuilderFactory'
 import { Mapper } from '../Mapper'
-import { acceptEveryFieldVisitor } from '@contember/schema-utils'
-import {
-	collectResults,
-	MutationNoResultError,
-	MutationNothingToDo,
-	MutationResultList,
-	MutationUpdateOk,
-	NothingToDoReason,
-	ResultListNotFlatten,
-	RowValues,
-} from '../Result'
+import { acceptFieldVisitor } from '@contember/schema-utils'
+import { MutationNoResultError, MutationNothingToDo, MutationResultList, MutationUpdateOk, NothingToDoReason } from '../Result'
 import { UpdateBuilder } from './UpdateBuilder'
 import { rowDataToFieldValues } from '../ColumnValue'
 import { DatabaseMetadata } from '@contember/database'
+import { MapperInput } from '../types'
 
 export class Updater {
 	constructor(
@@ -31,7 +23,7 @@ export class Updater {
 		mapper: Mapper,
 		entity: Model.Entity,
 		primaryValue: Input.PrimaryValue,
-		data: Input.UpdateDataInput,
+		data: MapperInput.UpdateDataInput,
 		filter?: Input.OptionalWhere,
 	): Promise<MutationResultList> {
 		const updateBuilder = this.updateBuilderFactory.create(entity, primaryValue)
@@ -42,18 +34,57 @@ export class Updater {
 			updateBuilder.addOldWhere(filter)
 		}
 
-		const updateVisitor = new SqlUpdateInputProcessor(primaryValue, data, updateBuilder, mapper)
-		const visitor = new UpdateInputVisitor<MutationResultList>(updateVisitor, this.schema, data)
-		const promises = acceptEveryFieldVisitor<Promise<ResultListNotFlatten | undefined>>(this.schema, entity, visitor)
+		const visitor = new UpdateInputVisitor<SqlUpdateInputProcessorResult>(
+			new SqlUpdateInputProcessor(primaryValue, data, updateBuilder, mapper),
+			this.schema,
+			data,
+		)
+		const resultList: MutationResultList = []
+		const postUpdates: Exclude<SqlUpdateInputProcessorResult, MutationResultList>[] = []
 
-		const okResultFactory = (values: RowValues) => new MutationUpdateOk([], entity, primaryValue, data, values)
-		const mutationResultPromise = Updater.executeUpdate(updateBuilder, mapper, okResultFactory)
-		const otherPromises = Object.values(promises)
-		if (otherPromises.length === 0) {
-			return await mutationResultPromise
+		for (const key of Object.keys(data)) {
+			const resultSet = await acceptFieldVisitor(
+				this.schema,
+				entity,
+				key,
+				visitor,
+			)
+			for (const result of resultSet) {
+				if (typeof result === 'function') {
+					postUpdates.push(result)
+				} else {
+					for (const resultItem of await result) {
+						resultList.push(resultItem)
+						if (resultItem.error) {
+							return resultList
+						}
+					}
+				}
+			}
+		}
+
+		const result = await updateBuilder.execute(mapper)
+
+		if (!result.executed) {
+			resultList.unshift(new MutationNothingToDo([], NothingToDoReason.noData))
+		} else if (result.affectedRows !== 1) {
+			return [new MutationNoResultError([])]
 		} else {
-			return await collectResults(this.schema, this.schemaDatabaseMetadata, mutationResultPromise, otherPromises)
+			const okResult = new MutationUpdateOk([], entity, primaryValue, data, rowDataToFieldValues(result.values))
+			resultList.unshift(okResult)
+		}
+
+		for (const postUpdate of postUpdates) {
+			const postInsertResult = await postUpdate({ primary: primaryValue })
+			for (const result of postInsertResult) {
+				resultList.push(result)
+				if (result.error) {
+					return resultList
+				}
+			}
 		}
+
+		return resultList
 	}
 
 	public async updateCb(
@@ -64,27 +95,16 @@ export class Updater {
 	): Promise<MutationResultList> {
 		const updateBuilder = this.updateBuilderFactory.create(entity, primaryValue)
 
-		const okResultFactory = (values: RowValues) => new MutationUpdateOk([], entity, primaryValue, {}, values)
 		builderCb(updateBuilder)
 
-		return Updater.executeUpdate(updateBuilder, mapper, okResultFactory)
-	}
-
-	private static async executeUpdate(
-		updateBuilder: UpdateBuilder,
-		mapper: Mapper,
-		okResultFactory: (values: RowValues) => MutationUpdateOk,
-	): Promise<MutationResultList> {
 		const result = await updateBuilder.execute(mapper)
-		if (result.aborted) {
-			return [new MutationNothingToDo([], NothingToDoReason.aborted)]
-		}
+
 		if (!result.executed) {
 			return [new MutationNothingToDo([], NothingToDoReason.noData)]
 		}
 		if (result.affectedRows !== 1) {
 			return [new MutationNoResultError([])]
 		}
-		return [okResultFactory(rowDataToFieldValues(result.values))]
+		return [new MutationUpdateOk([], entity, primaryValue, {}, rowDataToFieldValues(result.values))]
 	}
 }

package/src/mapper/update/relations/ManyHasManyUpdateInputProcessor.ts

@@ -0,0 +1,112 @@
+import { UpdateInputProcessor } from '../../../inputProcessing'
+import { Input, Model } from '@contember/schema'
+import { getInsertPrimary, MutationEntryNotFoundError } from '../../Result'
+import { Mapper } from '../../Mapper'
+import { SqlUpdateInputProcessorResult } from '../../update'
+import { CheckedPrimary } from '../../CheckedPrimary'
+import { MapperInput } from '../../types'
+
+type Context = Model.ManyHasManyOwningContext | Model.ManyHasManyInverseContext
+
+export class ManyHasManyUpdateInputProcessor implements UpdateInputProcessor.HasManyRelationInputProcessor<Context, SqlUpdateInputProcessorResult> {
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect(
+		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere | CheckedPrimary },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const [otherPrimary, err] = await this.mapper.getPrimaryValue(targetEntity, input)
+			if (err) return [err]
+			return await this.mapper.connectJunction(entity, relation, primary, otherPrimary)
+		}
+	}
+
+	public async create(
+		{ entity, targetEntity, relation, input }: Context & { input: MapperInput.CreateDataInput },
+	) {
+		return async ({ primary }: { 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: Context & { input: MapperInput.ConnectOrCreateInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			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 } }: Context & { input: UpdateInputProcessor.UpdateManyInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const [otherPrimary, err] = await this.mapper.getPrimaryValue(targetEntity, where)
+			if (err) return [err]
+			return [
+				...(await this.mapper.update(targetEntity, new CheckedPrimary(otherPrimary), data)),
+				...(await this.mapper.connectJunction(entity, relation, primary, otherPrimary)),
+			]
+		}
+	}
+
+	public async upsert(
+		{ entity, relation, targetEntity, input: { create, update, where } }: Context & { input: UpdateInputProcessor.UpsertManyInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const [otherPrimary] = await this.mapper.getPrimaryValue(targetEntity, where)
+			if (otherPrimary) {
+				const updateResult = await this.mapper.update(targetEntity, new CheckedPrimary(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 }: Context & { input: Input.UniqueWhere },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const [otherPrimary, err] = await this.mapper.getPrimaryValue(targetEntity, input)
+			if (err) return [err]
+
+			return await this.mapper.disconnectJunction(entity, relation, primary, otherPrimary)
+		}
+	}
+
+	public async delete(
+		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.delete(targetEntity, input)
+		}
+	}
+}

package/src/mapper/update/relations/ManyHasOneUpdateInputProcessor.ts

@@ -0,0 +1,125 @@
+import { UpdateInputProcessor } from '../../../inputProcessing'
+import { Input, Model } from '@contember/schema'
+import {
+	ConstraintType,
+	getInsertPrimary,
+	MutationConstraintViolationError,
+	MutationEntryNotFoundError,
+	MutationNothingToDo,
+	NothingToDoReason,
+} from '../../Result'
+import { Mapper } from '../../Mapper'
+import { SqlUpdateInputProcessorResult } from '../SqlUpdateInputProcessor'
+import { UpdateBuilder } from '../UpdateBuilder'
+import { CheckedPrimary } from '../../CheckedPrimary'
+import { MapperInput } from '../../types'
+
+type Context = Model.ManyHasOneContext
+
+export class ManyHasOneUpdateInputProcessor implements UpdateInputProcessor.HasOneRelationInputProcessor<Context, SqlUpdateInputProcessorResult>{
+
+	constructor(
+		private readonly mapper: Mapper,
+		private readonly builder: UpdateBuilder,
+		private readonly primary: Input.PrimaryValue,
+	) {
+	}
+
+	public async connect(
+		{ targetEntity, relation, input }: Context & { input: Input.UniqueWhere | CheckedPrimary },
+	) {
+		const [value, err] = await this.mapper.getPrimaryValue(targetEntity, input)
+		if (err) return [err]
+		this.builder.addFieldValue(relation.name, value)
+		return []
+	}
+
+	public async create(
+		{ relation, targetEntity, input }: Context & { input: MapperInput.CreateDataInput },
+	) {
+		const insertResult = await this.mapper.insert(targetEntity, input)
+		const value = getInsertPrimary(insertResult)
+		if (!value) {
+			return insertResult
+		}
+		this.builder.addFieldValue(relation.name, value)
+		return []
+	}
+
+	public async connectOrCreate(
+		{ input: { connect, create }, relation, targetEntity }: Context & { input: MapperInput.ConnectOrCreateInput },
+	) {
+		const [value] = await this.mapper.getPrimaryValue(targetEntity, connect)
+		if (value) {
+			this.builder.addFieldValue(relation.name, value)
+		} else {
+			const insertResult = await this.mapper.insert(targetEntity, create)
+			const primary = getInsertPrimary(insertResult)
+			if (!primary) {
+				return insertResult
+			}
+
+			this.builder.addFieldValue(relation.name, primary)
+		}
+		return []
+	}
+
+	public async update(
+		{ entity, relation, targetEntity, targetRelation, input }: Context & { input: MapperInput.UpdateDataInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const inversePrimary = await this.mapper.selectField(
+				entity,
+				{ [entity.primary]: primary },
+				relation.name,
+			)
+			if (!inversePrimary) {
+				return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
+			}
+			return await this.mapper.update(targetEntity, new CheckedPrimary(inversePrimary), input)
+		}
+	}
+
+	public async upsert(
+		{ entity, relation, targetEntity, input: { create, update } }: Context & { input: UpdateInputProcessor.UpsertInput },
+	) {
+		const inversePrimary = await this.mapper.selectField(entity, { [entity.primary]: this.primary }, relation.name)
+		if (!inversePrimary) {
+			const insertResult = await this.mapper.insert(targetEntity, create)
+			const insertPrimary = getInsertPrimary(insertResult)
+			if (insertPrimary) {
+				this.builder.addFieldValue(relation.name, insertPrimary)
+			}
+			return insertResult
+		}
+
+		return async () =>
+			await this.mapper.update(targetEntity, new CheckedPrimary(inversePrimary), update)
+	}
+
+	public async disconnect(
+		{ entity, targetEntity, relation, targetRelation }: Context & { input: undefined },
+	) {
+		if (!relation.nullable) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+		this.builder.addFieldValue(relation.name, null)
+		return []
+	}
+
+	public async delete(
+		{ entity, targetEntity, relation, targetRelation }: Context & { input: undefined },
+	) {
+		if (!relation.nullable && relation.joiningColumn.onDelete !== Model.OnDelete.cascade) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const inversePrimary = await this.mapper.selectField(
+				entity,
+				{ [entity.primary]: primary },
+				relation.name,
+			)
+			return await this.mapper.delete(targetEntity, { [targetEntity.primary]: inversePrimary })
+		}
+	}
+}