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

package/src/mapper/insert/Inserter.ts

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

package/src/mapper/insert/SqlCreateInputProcessor.ts

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

package/src/mapper/relations/ManyHasManyInputProcessor.ts

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

package/src/mapper/relations/ManyHasOneInputProcessor.ts

@@ -0,0 +1,158 @@
+import { UpdateInputProcessor } from '../../inputProcessing'
+import { Input, Model } from '@contember/schema'
+import {
+	ConstraintType,
+	getInsertPrimary,
+	MutationConstraintViolationError,
+	MutationEntryNotFoundError,
+	MutationNothingToDo,
+	MutationResultList,
+	NothingToDoReason,
+} from '../Result'
+import { Mapper } from '../Mapper'
+import { AbortDataManipulation, DataManipulationBuilder } from '../DataManipulationBuilder'
+import { UpdateBuilder } from '../update'
+
+export class ManyHasOneInputProcessor {
+
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect(
+		{ targetEntity, relation, input }: Model.ManyHasOneContext & { input: Input.UniqueWhere },
+		builder: DataManipulationBuilder,
+	) {
+		const result: MutationResultList = []
+		await builder.addFieldValue(relation.name, async () => {
+			const value = await this.mapper.getPrimaryValue(targetEntity, input)
+			if (!value) {
+				result.push(new MutationEntryNotFoundError([], input))
+				return AbortDataManipulation
+			}
+			return value
+		})
+		return result
+	}
+
+	public async create(
+		{ relation, targetEntity, input }: Model.ManyHasOneContext & { input: Input.CreateDataInput },
+		builder: DataManipulationBuilder,
+	) {
+		const result: MutationResultList = []
+		await builder.addFieldValue(relation.name, async () => {
+			const insertResult = await this.mapper.insert(targetEntity, input)
+			const value = getInsertPrimary(insertResult)
+			if (!value) {
+				result.push(...insertResult)
+				return AbortDataManipulation
+			}
+			return value
+		})
+		return result
+	}
+
+	public async connectOrCreate(
+		{ input: { connect, create }, relation, targetEntity }: Model.ManyHasOneContext & { input: Input.ConnectOrCreateInput },
+		builder: DataManipulationBuilder,
+	) {
+		const result: MutationResultList = []
+		await builder.addFieldValue(relation.name, async () => {
+			const value = await this.mapper.getPrimaryValue(targetEntity, connect)
+			if (value) {
+				return value
+			}
+			const insertPromise = this.mapper.insert(targetEntity, create)
+			const insertResult = await insertPromise
+			const primary = getInsertPrimary(insertResult)
+			if (!primary) {
+				result.push(...insertResult)
+				return AbortDataManipulation
+			}
+			return primary
+		})
+		return result
+	}
+
+	public async update(
+		{ entity, relation, targetEntity, targetRelation, input }: Model.ManyHasOneContext & { input: Input.UpdateDataInput },
+		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, { [targetEntity.primary]: inversePrimary }, input)
+	}
+
+	public async upsert(
+		{ entity, relation, targetEntity, input: { create, update } }: Model.ManyHasOneContext & { input: UpdateInputProcessor.UpsertInput },
+		builder: DataManipulationBuilder,
+		primary: Input.PrimaryValue,
+	) {
+		const select = this.mapper.selectField(entity, { [entity.primary]: primary }, relation.name)
+
+		const result: MutationResultList = []
+		// addFieldValue has to be called immediately
+		await builder.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 AbortDataManipulation
+		})
+
+		const inversePrimary = await select
+		if (inversePrimary) {
+			return await this.mapper.update(targetEntity, { [targetEntity.primary]: inversePrimary }, update)
+		} else {
+			return result
+		}
+	}
+
+	public async disconnect(
+		{ entity, targetEntity, relation, targetRelation }: Model.ManyHasOneContext & { input: undefined },
+		builder: DataManipulationBuilder,
+	) {
+		if (!relation.nullable) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+		builder.addFieldValue(relation.name, null)
+		return []
+	}
+
+	public async delete(
+		{ entity, targetEntity, relation, targetRelation }: Model.ManyHasOneContext & { input: undefined },
+		builder: UpdateBuilder,
+		primary: Input.PrimaryValue,
+	) {
+		if (!relation.nullable && relation.joiningColumn.onDelete !== Model.OnDelete.cascade) {
+			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
+		}
+		if (relation.joiningColumn.onDelete === Model.OnDelete.restrict) {
+			// eslint-disable-next-line no-console
+			console.error(
+				'[DEPRECATED] You are deleting an entity over the relation where onDelete behaviour is set to restrict. This will fail in next version.',
+			)
+			builder.addFieldValue(relation.name, null)
+		}
+		const inversePrimary = await this.mapper.selectField(
+			entity,
+			{ [entity.primary]: primary },
+			relation.name,
+		)
+		await builder.update
+		return await this.mapper.delete(targetEntity, { [targetEntity.primary]: inversePrimary })
+	}
+}

package/src/mapper/relations/OneHasManyInputProcessor.ts

@@ -0,0 +1,101 @@
+import { UpdateInputProcessor } from '../../inputProcessing'
+import { Input, Model } from '@contember/schema'
+import { Mapper } from '../Mapper'
+import { MutationResultType } from '../Result'
+
+export class OneHasManyInputProcessor {
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async connect(
+		{ entity, targetEntity, targetRelation, input }: Model.OneHasManyContext & { input: Input.UniqueWhere },
+		primary: Input.PrimaryValue,
+	) {
+		return await this.mapper.update(targetEntity, input, {
+			[targetRelation.name]: { connect: { [entity.primary]: primary } },
+		})
+	}
+
+	public async create(
+		{ entity, targetEntity, targetRelation, input }: Model.OneHasManyContext & { input: Input.CreateDataInput },
+		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 } }: Model.OneHasManyContext & { input: Input.ConnectOrCreateInput },
+		primary: Input.PrimaryValue,
+	) {
+		const connectData = {
+			[targetRelation.name]: {
+				connect: { [entity.primary]: primary },
+			},
+		}
+		return await this.mapper.upsert(targetEntity, connect, connectData, {
+			...create,
+			...connectData,
+		})
+	}
+
+	public async update(
+		{ entity, targetEntity, targetRelation, input: { data, where } }: Model.OneHasManyContext & { input: UpdateInputProcessor.UpdateManyInput },
+		primary: Input.PrimaryValue,
+	) {
+		return await this.mapper.update(
+			targetEntity,
+			{ ...where, [targetRelation.name]: { [entity.primary]: primary } },
+			{
+				...data,
+				// [targetRelation.name]: {connect: thisPrimary}
+			},
+		)
+	}
+
+	public async upsert(
+		{ entity, targetEntity, targetRelation, input: { create, update, where } }: Model.OneHasManyContext & { input: UpdateInputProcessor.UpsertManyInput },
+		primary: Input.PrimaryValue,
+	) {
+		const result = await this.mapper.update(
+			targetEntity,
+			{ ...where, [targetRelation.name]: { [entity.primary]: primary } },
+			{
+				...update,
+				// [targetRelation.name]: {connect: thisPrimary}
+			},
+		)
+		if (result[0].result === MutationResultType.notFoundError) {
+			return await this.mapper.insert(targetEntity, {
+				...create,
+				[targetRelation.name]: { connect: { [entity.primary]: primary } },
+			})
+		}
+		return result
+	}
+
+	public async disconnect(
+		{ entity, targetEntity, relation, targetRelation, input }: Model.OneHasManyContext & { input: Input.UniqueWhere },
+		primary: Input.PrimaryValue,
+	) {
+		return await this.mapper.update(
+			targetEntity,
+			{ ...input, [targetRelation.name]: { [entity.primary]: primary } },
+			{ [targetRelation.name]: { disconnect: true } },
+		)
+	}
+
+	public async delete(
+		{ entity, targetEntity, relation, targetRelation, input }: Model.OneHasManyContext & { input: Input.UniqueWhere },
+		primary: Input.PrimaryValue,
+	) {
+		return await this.mapper.delete(targetEntity, {
+			...input,
+			[targetRelation.name]: { [entity.primary]: primary },
+		})
+	}
+}