@contember/engine-content-api 2.0.0-alpha.19 → 2.0.0-alpha.21

package/dist/types/mapper/relations/OneHasOneOwningCreateInputProcessor.d.ts

@@ -1,21 +0,0 @@
-import { MutationResultList } from '../Result';
-import { InsertBuilder } from '../insert';
-import { Mapper } from '../Mapper';
-import { Input, Model } from '@contember/schema';
-export declare class OneHasOneOwningCreateInputProcessor {
-    private readonly insertBuilder;
-    private readonly mapper;
-    constructor(insertBuilder: InsertBuilder, mapper: Mapper);
-    connect(context: Model.OneHasOneOwningContext & {
-        input: Input.UniqueWhere;
-    }): Promise<MutationResultList>;
-    create(context: Model.OneHasOneOwningContext & {
-        input: Input.CreateDataInput;
-    }): Promise<MutationResultList>;
-    connectOrCreate({ input, ...context }: Model.OneHasOneOwningContext & {
-        input: Input.ConnectOrCreateInput;
-    }): Promise<MutationResultList>;
-    private createInternal;
-    private connectInternal;
-}
-//# sourceMappingURL=OneHasOneOwningCreateInputProcessor.d.ts.map

package/dist/types/mapper/relations/OneHasOneOwningCreateInputProcessor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"OneHasOneOwningCreateInputProcessor.d.ts","sourceRoot":"","sources":["../../../../src/mapper/relations/OneHasOneOwningCreateInputProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,EAKN,kBAAkB,EAClB,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAClC,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAGhD,qBAAa,mCAAmC;IAE9C,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM;gBADN,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,MAAM;IAInB,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,sBAAsB,GAAG;QAAE,KAAK,EAAE,KAAK,CAAC,WAAW,CAAA;KAAE;IAc5E,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,sBAAsB,GAAG;QAAE,KAAK,EAAE,KAAK,CAAC,eAAe,CAAA;KAAE;IAQ/E,eAAe,CAAC,EAAE,KAAK,EAAE,GAAG,OAAO,EAAE,EAAE,KAAK,CAAC,sBAAsB,GAAG;QAAE,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAA;KAAE;YAY1G,cAAc;YAad,eAAe;CAyB7B"}

package/dist/types/mapper/relations/OneHasOneOwningUpdateInputProcessor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"OneHasOneOwningUpdateInputProcessor.d.ts","sourceRoot":"","sources":["../../../../src/mapper/relations/OneHasOneOwningUpdateInputProcessor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AAC5D,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAMN,kBAAkB,EAElB,MAAM,WAAW,CAAA;AAClB,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAClC,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAIvD,qBAAa,mCAAmC;IAE9C,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAFb,YAAY,EAAE,KAAK,CAAC,YAAY,EAChC,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,aAAa;IAIjC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,sBAAsB,GAAG;QAAE,KAAK,EAAE,KAAK,CAAC,WAAW,CAAA;KAAE;IAsB5E,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,sBAAsB,GAAG;QAAE,KAAK,EAAE,KAAK,CAAC,eAAe,CAAA;KAAE;IAc/E,eAAe,CAAC,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,KAAK,CAAC,sBAAsB,GAAG;QAAE,KAAK,EAAE,KAAK,CAAC,oBAAoB,CAAA;KAAE;YAqB/H,cAAc;YAmBd,eAAe;YAgDf,qBAAqB;YAOrB,aAAa;IAQd,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,sBAAsB,GAAG;QAAE,KAAK,EAAE,KAAK,CAAC,eAAe,CAAA;KAAE;IAYjH,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,CAAC,sBAAsB,GAAG;QAAE,KAAK,EAAE,oBAAoB,CAAC,WAAW,CAAA;KAAE;IA0BhJ,UAAU,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,EAAE,KAAK,CAAC,sBAAsB,GAAG;QAAE,KAAK,EAAE,SAAS,CAAA;KAAE;IA6BlH,MAAM,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,EAAE,KAAK,CAAC,sBAAsB,GAAG;QAAE,KAAK,EAAE,SAAS,CAAA;KAAE;CAsB3H"}

package/src/mapper/DataManipulationBuilder.ts

@@ -1,12 +0,0 @@
-import { Value } from '@contember/schema'
-
-export interface DataManipulationBuilder {
-	addFieldValue(
-		fieldName: string,
-		value: Value.GenericValueLike<Value.AtomicValue<AbortDataManipulation | undefined>>,
-	): Promise<Value.AtomicValue<AbortDataManipulation | undefined>>
-}
-
-
-export const AbortDataManipulation = Symbol('AbortDataManipulation')
-export type AbortDataManipulation = typeof AbortDataManipulation

package/src/mapper/relations/ManyHasManyInputProcessor.ts

@@ -1,108 +0,0 @@
-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

@@ -1,158 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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 },
-		})
-	}
-}

package/src/mapper/relations/OneHasOneInverseCreateInputProcessor.ts

@@ -1,99 +0,0 @@
-import { InsertBuilder } from '../insert'
-import { Mapper } from '../Mapper'
-import {
-	ConstraintType,
-	MutationConstraintViolationError,
-	MutationEntryNotFoundError,
-	MutationResultList,
-} from '../Result'
-import { CheckedPrimary } from '../CheckedPrimary'
-import { Input, Model } from '@contember/schema'
-
-export class OneHasOneInverseCreateInputProcessor {
-	constructor(
-		private readonly insertBuilder: InsertBuilder,
-		private readonly mapper: Mapper,
-	) {
-	}
-
-	public async connect(context: Model.OneHasOneInverseContext & { input: Input.UniqueWhere }) {
-		const { targetEntity, input } = context
-		const primary = await this.insertBuilder.insert
-		if (!primary) {
-			return []
-		}
-		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(
-		context: Model.OneHasOneInverseContext & { input: Input.CreateDataInput },
-	) {
-		const primary = await this.insertBuilder.insert
-		if (!primary) {
-			return []
-		}
-		return await this.mapper.insert(context.targetEntity, context.input, builder => {
-			builder.addPredicates([context.targetRelation.name])
-			builder.addFieldValue(context.targetRelation.name, primary)
-		})
-	}
-
-	public async connectOrCreate(
-		{ input, ...context }: Model.OneHasOneInverseContext & { input: Input.ConnectOrCreateInput },
-	) {
-		const primary = await this.insertBuilder.insert
-		if (!primary) {
-			return []
-		}
-		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 }: Model.OneHasOneInverseContext & { 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: Model.OneHasOneInverseContext & { 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/relations/OneHasOneOwningCreateInputProcessor.ts

@@ -1,92 +0,0 @@
-import {
-	ConstraintType,
-	getInsertPrimary,
-	MutationConstraintViolationError,
-	MutationEntryNotFoundError,
-	MutationResultList,
-} from '../Result'
-import { InsertBuilder } from '../insert'
-import { Mapper } from '../Mapper'
-import { Input, Model } from '@contember/schema'
-import { AbortDataManipulation } from '../DataManipulationBuilder'
-
-export class OneHasOneOwningCreateInputProcessor {
-	constructor(
-		private readonly insertBuilder: InsertBuilder,
-		private readonly mapper: Mapper,
-	) {
-	}
-
-	public async connect(context: Model.OneHasOneOwningContext & { input: Input.UniqueWhere }) {
-		const { input, relation, targetEntity } = context
-		const result: MutationResultList = []
-		await this.insertBuilder.addFieldValue(relation.name, async () => {
-			const inverseSide = await this.mapper.getPrimaryValue(targetEntity, input)
-			if (!inverseSide) {
-				result.push(new MutationEntryNotFoundError([], input))
-				return AbortDataManipulation
-			}
-			return this.connectInternal({ ...context, input: inverseSide }, result)
-		})
-		return result
-	}
-
-	public async create(context: Model.OneHasOneOwningContext & { input: Input.CreateDataInput }) {
-		const result: MutationResultList = []
-		await this.insertBuilder.addFieldValue(context.relation.name, async () => {
-			return await this.createInternal(context, result)
-		})
-		return result
-	}
-
-	public async connectOrCreate({ input, ...context }: Model.OneHasOneOwningContext & { input: Input.ConnectOrCreateInput }) {
-		const result: MutationResultList = []
-		await this.insertBuilder.addFieldValue(context.relation.name, async () => {
-			const inverseSide = await this.mapper.getPrimaryValue(context.targetEntity, input.connect)
-			if (inverseSide) {
-				return await this.connectInternal({ ...context, input: inverseSide }, result)
-			}
-			return await this.createInternal({ ...context, input: input.create }, result)
-		})
-		return result
-	}
-
-	private async createInternal(
-		context: Model.OneHasOneOwningContext & { input: Input.CreateDataInput },
-		result: MutationResultList,
-	) {
-		const insertResult = await this.mapper.insert(context.targetEntity, context.input)
-		result.push(...insertResult)
-		const primary = getInsertPrimary(insertResult)
-		if (!primary) {
-			return AbortDataManipulation
-		}
-		return primary
-	}
-
-	private async connectInternal(
-		{ entity, relation, targetEntity, input }: Model.OneHasOneOwningContext & { input: Input.PrimaryValue },
-		result: MutationResultList,
-	) {
-		const currentOwnerOfInverseSide = await this.mapper.getPrimaryValue(entity, {
-			[relation.name]: { [targetEntity.primary]: input },
-		})
-		if (!currentOwnerOfInverseSide) {
-			return input
-		}
-
-		if (!relation.nullable) {
-			result.push(new MutationConstraintViolationError([], ConstraintType.notNull))
-			return AbortDataManipulation
-		}
-
-		const currentOwnerUnique = { [entity.primary]: currentOwnerOfInverseSide }
-		const currentOwnerDisconnectResult = await this.mapper.updateInternal(entity, currentOwnerUnique, builder => {
-			builder.addPredicates([relation.name])
-			builder.addFieldValue(relation.name, null)
-		})
-		result.push(...currentOwnerDisconnectResult)
-
-		return input
-	}
-}