@contember/engine-content-api 2.0.0-alpha.20 → 2.0.0-alpha.22

package/src/mapper/insert/SqlCreateInputProcessor.ts

@@ -2,37 +2,38 @@ import { Input, Model, Value } from '@contember/schema'
 import { Mapper } from '../Mapper'
 import { InsertBuilder } from './InsertBuilder'
 import { Providers, resolveColumnValue } from '@contember/schema-utils'
-import * as Context from '../../inputProcessing'
 import { CreateInputProcessor } from '../../inputProcessing'
 import { MutationResultList } from '../Result'
 import { hasManyProcessor, hasOneProcessor } from '../MutationProcessorHelper'
-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'
+import { OneHasOneInverseCreateInputProcessor } from './relations/OneHasOneInverseCreateInputProcessor'
+import { OneHasOneOwningCreateInputProcessor } from './relations/OneHasOneOwningCreateInputProcessor'
+import { OneHasManyCreateInputProcessor } from './relations/OneHasManyCreateInputProcessor'
+import { ManyHasOneCreateInputProcessor } from './relations/ManyHasOneCreateInputProcessor'
+import { ManyHasManyCreateInputProcessor } from './relations/ManyHasManyCreateInputProcessor'
 
-export class SqlCreateInputProcessor implements CreateInputProcessor<MutationResultList> {
+
+export type SqlCreateInputProcessorResult = MutationResultList | ((ctx: { primary: Input.PrimaryValue }) => Promise<MutationResultList>)
+export class SqlCreateInputProcessor implements CreateInputProcessor<SqlCreateInputProcessorResult> {
 
 	private oneHasOneInverseCreateInputProcessor:  OneHasOneInverseCreateInputProcessor
 	private oneHasOneOwningCreateInputProcessor:  OneHasOneOwningCreateInputProcessor
-	private oneHasManyCreateInputProcessor:  OneHasManyInputProcessor
-	private manyHasOneCreateInputProcessor:  ManyHasOneInputProcessor
-	private manyHasManyCreateInputProcessor:  ManyHasManyInputProcessor
+	private oneHasManyCreateInputProcessor:  OneHasManyCreateInputProcessor
+	private manyHasOneCreateInputProcessor: ManyHasOneCreateInputProcessor
+	private manyHasManyCreateInputProcessor: ManyHasManyCreateInputProcessor
 
 	constructor(
 		private readonly insertBuilder: InsertBuilder,
 		private readonly mapper: Mapper,
 		private readonly providers: Providers,
 	) {
-		this.oneHasOneInverseCreateInputProcessor = new OneHasOneInverseCreateInputProcessor(this.insertBuilder, this.mapper)
-		this.oneHasOneOwningCreateInputProcessor = new OneHasOneOwningCreateInputProcessor(this.insertBuilder, this.mapper)
-		this.oneHasManyCreateInputProcessor = new OneHasManyInputProcessor(this.mapper)
-		this.manyHasOneCreateInputProcessor = new ManyHasOneInputProcessor(this.mapper)
-		this.manyHasManyCreateInputProcessor = new ManyHasManyInputProcessor(this.mapper)
+		this.oneHasOneInverseCreateInputProcessor = new OneHasOneInverseCreateInputProcessor(this.mapper)
+		this.oneHasOneOwningCreateInputProcessor = new OneHasOneOwningCreateInputProcessor(this.mapper, this.insertBuilder)
+		this.oneHasManyCreateInputProcessor = new OneHasManyCreateInputProcessor(this.mapper)
+		this.manyHasOneCreateInputProcessor = new ManyHasOneCreateInputProcessor(this.mapper, this.insertBuilder)
+		this.manyHasManyCreateInputProcessor = new ManyHasManyCreateInputProcessor(this.mapper)
 	}
 
-	public async column(context: Model.ColumnContext & { input: Input.ColumnValue | undefined }): Promise<MutationResultList> {
+	public async column(context: Model.ColumnContext & { input: Input.ColumnValue | undefined }): Promise<SqlCreateInputProcessorResult> {
 		this.insertBuilder.addFieldValue(
 			context.column.name,
 			((): Value.GenericValueLike<Value.AtomicValue | undefined> => {
@@ -42,90 +43,36 @@ export class SqlCreateInputProcessor implements CreateInputProcessor<MutationRes
 		return []
 	}
 
-	manyHasManyInverse: CreateInputProcessor<MutationResultList>['manyHasManyInverse'] = {
-		connect: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.manyHasManyCreateInputProcessor.connect(ctx, primary)
-		}),
-		create: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.manyHasManyCreateInputProcessor.create(ctx, primary)
-		}),
-		connectOrCreate: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.manyHasManyCreateInputProcessor.connectOrCreate(ctx, primary)
-		}),
+	manyHasManyInverse: CreateInputProcessor<SqlCreateInputProcessorResult>['manyHasManyInverse'] = {
+		connect: hasManyProcessor(ctx => this.manyHasManyCreateInputProcessor.connect(ctx)),
+		create: hasManyProcessor(ctx => this.manyHasManyCreateInputProcessor.create(ctx)),
+		connectOrCreate: hasManyProcessor(ctx => this.manyHasManyCreateInputProcessor.connectOrCreate(ctx)),
 	}
 
-	manyHasManyOwning: CreateInputProcessor<MutationResultList>['manyHasManyOwning'] = {
-		connect: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.manyHasManyCreateInputProcessor.connect(ctx, primary)
-		}),
-		create: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.manyHasManyCreateInputProcessor.create(ctx, primary)
-		}),
-		connectOrCreate: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.manyHasManyCreateInputProcessor.connectOrCreate(ctx, primary)
-		}),
+	manyHasManyOwning: CreateInputProcessor<SqlCreateInputProcessorResult>['manyHasManyOwning'] = {
+		connect: hasManyProcessor(ctx => this.manyHasManyCreateInputProcessor.connect(ctx)),
+		create: hasManyProcessor(ctx => this.manyHasManyCreateInputProcessor.create(ctx)),
+		connectOrCreate: hasManyProcessor(ctx => this.manyHasManyCreateInputProcessor.connectOrCreate(ctx)),
 	}
 
-	manyHasOne: CreateInputProcessor<MutationResultList>['manyHasOne'] = {
+	manyHasOne: CreateInputProcessor<SqlCreateInputProcessorResult>['manyHasOne'] = {
 		nothing: async ctx => {
 			this.insertBuilder.addFieldValue(ctx.relation.name, null)
 			return []
 		},
-		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)),
+		connect: hasOneProcessor(ctx => this.manyHasOneCreateInputProcessor.connect(ctx)),
+		create: hasOneProcessor(ctx => this.manyHasOneCreateInputProcessor.create(ctx)),
+		connectOrCreate: hasOneProcessor(ctx => this.manyHasOneCreateInputProcessor.connectOrCreate(ctx)),
 	}
 
-	oneHasMany: CreateInputProcessor<MutationResultList>['oneHasMany'] = {
-		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 this.oneHasManyCreateInputProcessor.create(ctx, primary)
-		}),
-		connectOrCreate: hasManyProcessor(async ctx => {
-			const primary = await this.insertBuilder.insert
-			if (!primary) {
-				return []
-			}
-			return this.oneHasManyCreateInputProcessor.connectOrCreate(ctx, primary)
-		}),
+	oneHasMany: CreateInputProcessor<SqlCreateInputProcessorResult>['oneHasMany'] = {
+		connect: hasManyProcessor(ctx => this.oneHasManyCreateInputProcessor.connect(ctx)),
+		create: hasManyProcessor(ctx => this.oneHasManyCreateInputProcessor.create(ctx)),
+		connectOrCreate: hasManyProcessor(ctx => this.oneHasManyCreateInputProcessor.connectOrCreate(ctx)),
 	}
 
 
-	oneHasOneOwning: CreateInputProcessor<MutationResultList>['oneHasOneOwning'] = {
+	oneHasOneOwning: CreateInputProcessor<SqlCreateInputProcessorResult>['oneHasOneOwning'] = {
 		nothing: async ctx => {
 			this.insertBuilder.addFieldValue(ctx.relation.name, null)
 			return []
@@ -135,7 +82,7 @@ export class SqlCreateInputProcessor implements CreateInputProcessor<MutationRes
 		connectOrCreate: hasOneProcessor(ctx => this.oneHasOneOwningCreateInputProcessor.connectOrCreate(ctx)),
 	}
 
-	oneHasOneInverse: CreateInputProcessor<MutationResultList>['oneHasOneInverse'] = {
+	oneHasOneInverse: CreateInputProcessor<SqlCreateInputProcessorResult>['oneHasOneInverse'] = {
 		connect: hasOneProcessor(ctx => this.oneHasOneInverseCreateInputProcessor.connect(ctx)),
 		create: hasOneProcessor(ctx => this.oneHasOneInverseCreateInputProcessor.create(ctx)),
 		connectOrCreate: hasOneProcessor(ctx => this.oneHasOneInverseCreateInputProcessor.connectOrCreate(ctx)),

package/src/mapper/insert/relations/ManyHasManyCreateInputProcessor.ts

@@ -0,0 +1,59 @@
+import { Input, Model } from '@contember/schema'
+import { getInsertPrimary, MutationEntryNotFoundError } from '../../Result'
+import { Mapper } from '../../Mapper'
+import { CreateInputProcessor } from '../../../inputProcessing'
+import { SqlCreateInputProcessorResult } from '../SqlCreateInputProcessor'
+
+type Context = Model.ManyHasManyOwningContext | Model.ManyHasManyInverseContext
+
+export class ManyHasManyCreateInputProcessor implements CreateInputProcessor.HasManyRelationProcessor<Context, SqlCreateInputProcessorResult> {
+
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect(
+		{ entity, targetEntity, relation, targetRelation, input }: Context & { input: Input.UniqueWhere },
+	): Promise<SqlCreateInputProcessorResult> {
+		return async ({ primary }) => {
+			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 }: Context & { input: Input.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: Input.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)
+		}
+	}
+}

package/src/mapper/insert/relations/ManyHasOneCreateInputProcessor.ts

@@ -0,0 +1,57 @@
+import { Input, Model } from '@contember/schema'
+import { getInsertPrimary, MutationEntryNotFoundError } from '../../Result'
+import { Mapper } from '../../Mapper'
+import { CreateInputProcessor } from '../../../inputProcessing'
+import { SqlCreateInputProcessorResult } from '../SqlCreateInputProcessor'
+import { InsertBuilder } from '../InsertBuilder'
+
+type Context = Model.ManyHasOneContext
+
+export class ManyHasOneCreateInputProcessor implements CreateInputProcessor.HasManyRelationProcessor<Context, SqlCreateInputProcessorResult>  {
+
+	constructor(
+		private readonly mapper: Mapper,
+		private readonly insertBuilder: InsertBuilder,
+	) {
+	}
+	public async connect(
+		{ targetEntity, relation, input }: Context & { input: Input.UniqueWhere },
+	) {
+		const value = await this.mapper.getPrimaryValue(targetEntity, input)
+		if (!value) {
+			return [new MutationEntryNotFoundError([], input)]
+		}
+		this.insertBuilder.addFieldValue(relation.name, value)
+		return []
+	}
+
+	public async create(
+		{ relation, targetEntity, input }: Context & { input: Input.CreateDataInput },
+	) {
+		const insertResult = await this.mapper.insert(targetEntity, input)
+		const value = getInsertPrimary(insertResult)
+		if (!value) {
+			return insertResult
+		}
+		this.insertBuilder.addFieldValue(relation.name, value)
+		return []
+	}
+
+	public async connectOrCreate(
+		{ input: { connect, create }, relation, targetEntity }: Context & { input: Input.ConnectOrCreateInput },
+	) {
+		const value = await this.mapper.getPrimaryValue(targetEntity, connect)
+		if (value) {
+			this.insertBuilder.addFieldValue(relation.name, value)
+		} else {
+			const insertResult = await this.mapper.insert(targetEntity, create)
+			const primary = getInsertPrimary(insertResult)
+			if (!primary) {
+				return insertResult
+			}
+
+			this.insertBuilder.addFieldValue(relation.name, primary)
+		}
+		return []
+	}
+}

package/src/mapper/insert/relations/OneHasManyCreateInputProcessor.ts

@@ -0,0 +1,50 @@
+import { Input, Model } from '@contember/schema'
+import { Mapper } from '../../Mapper'
+import { CreateInputProcessor } from '../../../inputProcessing'
+import { SqlCreateInputProcessorResult } from '../SqlCreateInputProcessor'
+
+type Context = Model.OneHasManyContext
+
+export class OneHasManyCreateInputProcessor implements CreateInputProcessor.HasManyRelationProcessor<Context, SqlCreateInputProcessorResult> {
+
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+	public async connect(
+		{ entity, targetEntity, targetRelation, input }: Context & { input: Input.UniqueWhere },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.update(targetEntity, input, {
+				[targetRelation.name]: { connect: { [entity.primary]: primary } },
+			})
+		}
+	}
+
+	public async create(
+		{ entity, targetEntity, targetRelation, input }: Context & { input: Input.CreateDataInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.insert(targetEntity, {
+				...input,
+				[targetRelation.name]: { connect: { [entity.primary]: primary } },
+			})
+		}
+	}
+
+	public async connectOrCreate(
+		{ entity, targetRelation, targetEntity, input: { connect, create } }: Context & { input: Input.ConnectOrCreateInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const connectData = {
+				[targetRelation.name]: {
+					connect: { [entity.primary]: primary },
+				},
+			}
+			return await this.mapper.upsert(targetEntity, connect, connectData, {
+				...create,
+				...connectData,
+			})
+		}
+	}
+}

package/src/mapper/insert/relations/OneHasOneInverseCreateInputProcessor.ts

@@ -0,0 +1,91 @@
+import { Mapper } from '../../Mapper'
+import { ConstraintType, MutationConstraintViolationError, MutationEntryNotFoundError, MutationResultList } from '../../Result'
+import { CheckedPrimary } from '../../CheckedPrimary'
+import { Input, Model } from '@contember/schema'
+import { CreateInputProcessor } from '../../../inputProcessing'
+import { SqlCreateInputProcessorResult } from '../SqlCreateInputProcessor'
+
+type Context = Model.OneHasOneInverseContext
+
+export class OneHasOneInverseCreateInputProcessor implements CreateInputProcessor.HasOneRelationProcessor<Context, SqlCreateInputProcessorResult>  {
+
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect(context: Context & { input: Input.UniqueWhere }) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const { targetEntity, input } = context
+			const owner = await this.mapper.getPrimaryValue(targetEntity, input)
+			if (!owner) {
+				return [new MutationEntryNotFoundError([], input)]
+			}
+
+			return await this.connectInternal({ ...context, input: new CheckedPrimary(owner) }, primary)
+		}
+	}
+
+
+	public async create(
+		{ input, targetRelation, targetEntity }: Context & { input: Input.CreateDataInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			return await this.mapper.insert(targetEntity, input, builder => {
+				builder.addPredicates([targetRelation.name])
+				builder.addFieldValue(targetRelation.name, primary)
+			})
+		}
+	}
+
+	public async connectOrCreate(
+		{ input, ...context }: Context & { input: Input.ConnectOrCreateInput },
+	) {
+		return async ({ primary }: { primary: Input.PrimaryValue }) => {
+			const owner = await this.mapper.getPrimaryValue(context.targetEntity, input.connect)
+			if (owner) {
+				return await this.connectInternal({ ...context, input: new CheckedPrimary(owner) }, primary)
+			}
+
+			return await this.createInternal({ input: input.create, ...context }, primary)
+		}
+	}
+
+	private async connectInternal(
+		{ entity, targetEntity, targetRelation, relation, input }: Context & { input: CheckedPrimary },
+		primary: Input.PrimaryValue,
+	) {
+
+		const currentInverseSideOfOwner = await this.mapper.selectField(targetEntity, input, targetRelation.name)
+		const orphanResult: MutationResultList = []
+		if (currentInverseSideOfOwner) {
+			if (targetRelation.orphanRemoval) {
+				const orphanUnique = { [entity.primary]: currentInverseSideOfOwner }
+				const orphanDelete = await this.mapper.delete(entity, orphanUnique)
+				orphanResult.push(...orphanDelete)
+			} else if (!relation.nullable) {
+				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+			}
+		}
+
+		const connectResult = await this.mapper.updateInternal(targetEntity, input, update => {
+			update.addPredicates([targetRelation.name])
+			update.addFieldValue(targetRelation.name, primary)
+		})
+
+		return [
+			...connectResult,
+			...orphanResult,
+		]
+	}
+
+	private async createInternal(
+		context: Context & { input: Input.CreateDataInput },
+		primary: Input.PrimaryValue,
+	) {
+		return await this.mapper.insert(context.targetEntity, context.input, builder => {
+			builder.addPredicates([context.targetRelation.name])
+			builder.addFieldValue(context.targetRelation.name, primary)
+		})
+	}
+}

package/src/mapper/insert/relations/OneHasOneOwningCreateInputProcessor.ts

@@ -0,0 +1,87 @@
+import {
+	ConstraintType,
+	getInsertPrimary,
+	MutationConstraintViolationError,
+	MutationEntryNotFoundError,
+	MutationResultList,
+} from '../../Result'
+import { InsertBuilder } from '../../insert'
+import { Mapper } from '../../Mapper'
+import { Input, Model } from '@contember/schema'
+import { CreateInputProcessor } from '../../../inputProcessing'
+import { SqlCreateInputProcessorResult } from '../SqlCreateInputProcessor'
+
+type Context = Model.OneHasOneOwningContext
+
+export class OneHasOneOwningCreateInputProcessor implements CreateInputProcessor.HasOneRelationProcessor<Context, SqlCreateInputProcessorResult>{
+	constructor(
+		private readonly mapper: Mapper,
+		private readonly insertBuilder: InsertBuilder,
+	) {
+	}
+
+	public async connect(context: Context & { input: Input.UniqueWhere }) {
+		const { input, relation, targetEntity } = context
+		const inverseSide = await this.mapper.getPrimaryValue(targetEntity, input)
+		if (!inverseSide) {
+			return [new MutationEntryNotFoundError([], input)]
+		}
+		const disconnectResult = await this.disconnectCurrentOwner({ ...context, input: inverseSide })
+		if (disconnectResult.some(it => it.error)) {
+			return disconnectResult
+		}
+		this.insertBuilder.addFieldValue(relation.name, inverseSide)
+		return disconnectResult
+	}
+
+	public async create(context: Context & { input: Input.CreateDataInput }) {
+		const insertResult = await this.mapper.insert(context.targetEntity, context.input)
+		const primary = getInsertPrimary(insertResult)
+		if (!primary) {
+			return insertResult
+		}
+		this.insertBuilder.addFieldValue(context.relation.name, primary)
+		return []
+	}
+
+	public async connectOrCreate({ input, ...context }: Context & { input: Input.ConnectOrCreateInput }) {
+		const inverseSide = await this.mapper.getPrimaryValue(context.targetEntity, input.connect)
+		if (inverseSide) {
+			this.insertBuilder.addFieldValue(context.relation.name, inverseSide)
+			const disconnectResult = await this.disconnectCurrentOwner({ ...context, input: inverseSide })
+			if (disconnectResult.some(it => it.error)) {
+				return disconnectResult
+			}
+			return []
+
+		} else {
+			const insertResult = await this.mapper.insert(context.targetEntity, input.create)
+			const primary = getInsertPrimary(insertResult)
+			if (primary) {
+				this.insertBuilder.addFieldValue(context.relation.name, primary)
+			}
+			return insertResult
+		}
+	}
+
+	private async disconnectCurrentOwner(
+		{ entity, relation, targetEntity, input }: Context & { input: Input.PrimaryValue },
+	): Promise<MutationResultList> {
+		const currentOwnerOfInverseSide = await this.mapper.getPrimaryValue(entity, {
+			[relation.name]: { [targetEntity.primary]: input },
+		})
+		if (!currentOwnerOfInverseSide) {
+			return []
+		}
+
+		if (!relation.nullable) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+
+		const currentOwnerUnique = { [entity.primary]: currentOwnerOfInverseSide }
+		return await this.mapper.updateInternal(entity, currentOwnerUnique, builder => {
+			builder.addPredicates([relation.name])
+			builder.addFieldValue(relation.name, null)
+		})
+	}
+}

package/src/mapper/update/SqlUpdateInputProcessor.ts

@@ -2,20 +2,22 @@ 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'
 
-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,
@@ -25,9 +27,9 @@ export class SqlUpdateInputProcessor implements UpdateInputProcessor<MutationRes
 	) {
 		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 +39,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 +89,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)),