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

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

package/src/mapper/relations/OneHasOneOwningUpdateInputProcessor.ts

@@ -1,253 +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 { UpdateBuilder } from '../update/UpdateBuilder'
-import { CheckedPrimary } from '../CheckedPrimary'
-import { AbortDataManipulation } from '../DataManipulationBuilder'
-
-export class OneHasOneOwningUpdateInputProcessor {
-	constructor(
-		private readonly primaryValue: Input.PrimaryValue,
-		private readonly mapper: Mapper,
-		private readonly updateBuilder: UpdateBuilder,
-	) {
-	}
-
-	public async connect(context: Model.OneHasOneOwningContext & { input: Input.UniqueWhere }) {
-		const result: MutationResultList = []
-		let currentInverseSide: Input.PrimaryValue | undefined
-
-		const { entity, relation, targetEntity, targetRelation, input } = context
-		const newInverseSide = await this.updateBuilder.addFieldValue(relation.name, async () => {
-			const newInverseSide = await this.mapper.getPrimaryValue(targetEntity, input)
-			if (!newInverseSide) {
-				result.push(new MutationEntryNotFoundError([], input))
-				return AbortDataManipulation
-			}
-			currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
-			return await this.connectInternal(context, currentInverseSide, newInverseSide, result)
-		})
-
-		if (newInverseSide) {
-			result.push(...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)))
-		}
-
-		return result
-	}
-
-	public async create(context: Model.OneHasOneOwningContext & { input: Input.CreateDataInput }) {
-		const result: MutationResultList = []
-		let currentInverseSide: Input.PrimaryValue | undefined
-		const { entity, relation, targetEntity, targetRelation } = context
-		await this.updateBuilder.addFieldValue(relation.name, async () => {
-			currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
-			// orphan removal handled bellow
-			return await this.createInternal(context, currentInverseSide, result)
-		})
-
-		result.push(...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)))
-		return result
-	}
-
-	public async connectOrCreate({ input: { connect, create }, ...context }: Model.OneHasOneOwningContext & { input: Input.ConnectOrCreateInput }) {
-		const result: MutationResultList = []
-		let currentInverseSide: Input.PrimaryValue | undefined
-
-		const { relation, targetRelation, targetEntity, entity } = context
-		const newInverseSide = await this.updateBuilder.addFieldValue(relation.name, async () => {
-			const newInverseSide = await this.mapper.getPrimaryValue(targetEntity, connect)
-			currentInverseSide = await this.getCurrentInverseSide(targetRelation, relation, entity)
-			if (newInverseSide) {
-				return await this.connectInternal(context, currentInverseSide, newInverseSide, result)
-			}
-			return await this.createInternal({ ...context, input: create }, currentInverseSide, result)
-		})
-
-		if (newInverseSide) {
-			result.push(...(await this.cleanupOrphan(relation, targetEntity, currentInverseSide)))
-		}
-
-		return result
-	}
-
-	private async createInternal(
-		{ targetEntity, targetRelation, relation, input }: Model.OneHasOneOwningContext & { input: Input.CreateDataInput },
-		currentInverseSide: Input.PrimaryValue | undefined,
-		result: MutationResultList,
-	) {
-		if (targetRelation && !targetRelation.nullable && !relation.orphanRemoval && currentInverseSide) {
-			result.push(new MutationConstraintViolationError([], ConstraintType.notNull))
-			return AbortDataManipulation
-		}
-
-		const insertResult = await this.mapper.insert(targetEntity, input)
-		result.push(...insertResult)
-		const newInverseSide = getInsertPrimary(insertResult)
-		if (newInverseSide) {
-			return newInverseSide
-		}
-		return AbortDataManipulation
-	}
-
-	private async connectInternal(
-		{ targetEntity, targetRelation, relation, entity }: Model.OneHasOneOwningContext,
-		currentInverseSide: Input.PrimaryValue | undefined,
-		newInverseSide: Input.PrimaryValue,
-		result: MutationResultList,
-	) {
-
-		if (currentInverseSide === newInverseSide) {
-			result.push(new MutationNothingToDo([], NothingToDoReason.alreadyExists))
-			return undefined
-		}
-
-		const currentOwnerOfNewInverseSide = await this.mapper.getPrimaryValue(entity, {
-			[relation.name]: { [targetEntity.primary]: newInverseSide },
-		})
-
-		if (currentOwnerOfNewInverseSide === this.primaryValue) {
-			result.push(new MutationNothingToDo([], NothingToDoReason.alreadyExists))
-			return undefined
-		}
-
-		// orphan removal handled bellow
-		if (targetRelation && !targetRelation.nullable && !relation.orphanRemoval && currentInverseSide) {
-			result.push(new MutationConstraintViolationError([], ConstraintType.notNull))
-			return AbortDataManipulation
-		}
-
-		if (currentOwnerOfNewInverseSide) {
-			if (!relation.nullable) {
-				result.push(new MutationConstraintViolationError([], ConstraintType.notNull))
-				return AbortDataManipulation
-			}
-
-			const currentOwnerDisconnect = await this.mapper.updateInternal(
-				entity,
-				{
-					[entity.primary]: currentOwnerOfNewInverseSide,
-				},
-				builder => {
-					builder.addPredicates([relation.name])
-					builder.addFieldValue(relation.name, null)
-				},
-			)
-			result.push(...currentOwnerDisconnect)
-		}
-		return newInverseSide
-	}
-
-	private async getCurrentInverseSide(targetRelation: Model.OneHasOneInverseRelation | null, relation: Model.OneHasOneOwningRelation, entity: Model.Entity) {
-		if ((targetRelation && !targetRelation.nullable) || relation.orphanRemoval) {
-			return this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
-		}
-		return undefined
-	}
-
-	private async cleanupOrphan(relation: Model.OneHasOneOwningRelation, targetEntity: Model.Entity, currentInverseSide: Input.PrimaryValue | undefined) {
-		if (relation.orphanRemoval && currentInverseSide) {
-			await this.updateBuilder.update
-			return await this.mapper.delete(targetEntity, { [targetEntity.primary]: currentInverseSide })
-		}
-		return []
-	}
-
-	public async update({ entity, relation, targetEntity, input }: Model.OneHasOneOwningContext & { input: Input.UpdateDataInput }) {
-		const inversePrimary = await this.mapper.selectField(
-			entity,
-			{ [entity.primary]: this.primaryValue },
-			relation.name,
-		)
-		if (!inversePrimary) {
-			return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
-		}
-		return await this.mapper.update(targetEntity, { [targetEntity.primary]: inversePrimary }, input)
-	}
-
-	public async upsert({ entity, relation, targetEntity, input: { create, update } }: Model.OneHasOneOwningContext & { input: UpdateInputProcessor.UpsertInput }) {
-		const select = this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
-
-		const result: MutationResultList = []
-		//addColumnData has to be called synchronously
-		await this.updateBuilder.addFieldValue(relation.name, async () => {
-			const primary = await select
-			if (primary) {
-				return undefined
-			}
-			const insertResult = await this.mapper.insert(targetEntity, create)
-			const insertPrimary = getInsertPrimary(insertResult)
-			if (insertPrimary) {
-				return insertPrimary
-			}
-			result.push(...insertResult)
-			return AbortDataManipulation
-		})
-
-		const inversePrimary = await select
-		if (inversePrimary) {
-			return await this.mapper.update(targetEntity, { [targetEntity.primary]: inversePrimary }, update)
-		}
-		return result
-	}
-
-	public async disconnect({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneOwningContext & { input: undefined }) {
-		if (!relation.nullable) {
-			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-		}
-		const result: MutationResultList = []
-
-		const currentInverseSide = (targetRelation && !targetRelation.nullable) || relation.orphanRemoval
-			? this.mapper.selectField(entity, { [entity.primary]: this.primaryValue }, relation.name)
-			: Promise.resolve(undefined)
-
-		this.updateBuilder.addFieldValue(relation.name, async () => {
-			const inversePrimary = await currentInverseSide
-			if (inversePrimary && targetRelation && !targetRelation.nullable && !relation.orphanRemoval) {
-				result.push(new MutationConstraintViolationError([], ConstraintType.notNull))
-				return AbortDataManipulation
-			}
-			return null
-		})
-		if (relation.orphanRemoval) {
-			const inversePrimary = await currentInverseSide
-			if (inversePrimary) {
-				await this.updateBuilder.update
-				const deleteOrphanedInverseSide = await this.mapper.delete(targetEntity, { [targetEntity.primary]: inversePrimary })
-				result.push(...deleteOrphanedInverseSide)
-			}
-		}
-		return result
-	}
-
-	public async delete({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneOwningContext & { input: undefined }) {
-		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.',
-			)
-			this.updateBuilder.addFieldValue(relation.name, null)
-		}
-		const targetPrimary = await this.mapper.selectField(
-			entity,
-			{ [entity.primary]: this.primaryValue },
-			relation.name,
-		)
-		if (!targetPrimary) {
-			return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
-		}
-		await this.updateBuilder.update
-		return await this.mapper.delete(targetEntity, new CheckedPrimary(targetPrimary))
-	}
-}