@contember/engine-content-api 2.0.0-alpha.9 → 2.0.0-beta.2

package/src/mapper/relations/OneHasOneInverseUpdateInputProcessor.ts

@@ -1,164 +0,0 @@
-import {
-	ConstraintType,
-	MutationConstraintViolationError,
-	MutationEntryNotFoundError,
-	MutationNothingToDo,
-	MutationResultList,
-	MutationResultType,
-	NothingToDoReason,
-} from '../Result'
-import { UpdateInputProcessor } from '../../inputProcessing'
-import { Input, Model } from '@contember/schema'
-import { Mapper } from '../Mapper'
-
-export class OneHasOneInverseUpdateInputProcessor {
-	constructor(
-		private readonly primaryValue: Input.PrimaryValue,
-		private readonly mapper: Mapper,
-	) {
-	}
-
-	public async connect({ input, ...ctx  }: Model.OneHasOneInverseContext & { input: Input.UniqueWhere }) {
-		const newOwner = await this.mapper.getPrimaryValue(ctx.targetEntity, input)
-		if (!newOwner) {
-			return [new MutationEntryNotFoundError([], input)]
-		}
-		return await this.connectInternal(ctx, newOwner)
-	}
-
-	public async connectOrCreate(
-		{ input, ...ctx }: Model.OneHasOneInverseContext & { input: Input.ConnectOrCreateInput },
-	) {
-		const newOwner = await this.mapper.getPrimaryValue(ctx.targetEntity, input.connect)
-		if (newOwner) {
-			return await this.connectInternal(ctx, newOwner)
-		}
-		return await this.create({ ...ctx, input: input.create })
-	}
-
-
-	private async connectInternal(
-		{ entity, targetEntity, targetRelation }: Model.OneHasOneInverseContext,
-		newOwner: Input.PrimaryValue,
-	) {
-		const currentOwner = await this.mapper.getPrimaryValue(targetEntity, {
-			[targetRelation.name]: { [entity.primary]: this.primaryValue },
-		})
-		if (newOwner === currentOwner) {
-			return [new MutationNothingToDo([], NothingToDoReason.alreadyExists)]
-		}
-		const result: MutationResultList = []
-		if (currentOwner) {
-			if (!targetRelation.nullable) {
-				// todo cascade delete support?
-				return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-			}
-			const disconnectFromCurrentOwner = await this.mapper.updateInternal(targetEntity, { [targetEntity.primary]: currentOwner }, builder => {
-				builder.addPredicates([targetRelation.name])
-				builder.addFieldValue(targetRelation.name, null)
-			})
-			result.push(...disconnectFromCurrentOwner)
-		}
-		const orphanedInverseSide = targetRelation.orphanRemoval
-			? await this.mapper.selectField(targetEntity, { [targetEntity.primary]: newOwner }, targetRelation.name)
-			: null
-
-		const connectToNewOwner = await this.mapper.updateInternal(targetEntity, { [targetEntity.primary]: newOwner }, builder => {
-			builder.addPredicates([targetRelation.name])
-			builder.addFieldValue(targetRelation.name, this.primaryValue)
-		})
-		result.push(...connectToNewOwner)
-
-		if (orphanedInverseSide) {
-			const deleteOrphanedInverseSide = await this.mapper.delete(entity, { [entity.primary]: orphanedInverseSide })
-			result.push(...deleteOrphanedInverseSide)
-		}
-		return result
-	}
-
-	public async create({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: Input.CreateDataInput }) {
-		const currentOwner = await this.mapper.getPrimaryValue(targetEntity, {
-			[targetRelation.name]: { [entity.primary]: this.primaryValue },
-		})
-		if (currentOwner && !targetRelation.nullable) {
-			// todo cascade delete support?
-			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-		}
-		const result: MutationResultList = []
-		if (currentOwner) {
-			const disconnectFromCurrentOwner = await this.mapper.updateInternal(targetEntity, { [targetEntity.primary]: currentOwner }, builder => {
-				builder.addPredicates([targetRelation.name])
-				builder.addFieldValue(targetRelation.name, null)
-			})
-			result.push(...disconnectFromCurrentOwner)
-		}
-
-		const connectToNewlyCreatedOwner = await this.mapper.insert(targetEntity, input, builder => {
-			builder.addFieldValue(targetRelation.name, this.primaryValue)
-			builder.addPredicates([targetRelation.name])
-		})
-		result.push(...connectToNewlyCreatedOwner)
-
-		return result
-	}
-
-	public async update({ entity, targetEntity, targetRelation, input }: Model.OneHasOneInverseContext & { input: Input.UpdateDataInput }) {
-		return await this.mapper.update(
-			targetEntity,
-			{ [targetRelation.name]: { [entity.primary]: this.primaryValue } },
-			input,
-		)
-	}
-
-	public async upsert(context: Model.OneHasOneInverseContext & { input: UpdateInputProcessor.UpsertInput }) {
-		const { targetEntity, targetRelation, entity, input: { update, create } } = context
-		const result = await this.mapper.update(
-			targetEntity,
-			{ [targetRelation.name]: { [entity.primary]: this.primaryValue } },
-			update,
-		)
-		if (result[0].result === MutationResultType.notFoundError) {
-			return await this.create({
-				...context,
-				input: create,
-			})
-		}
-		return result
-	}
-
-	public async disconnect({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneInverseContext & { input: undefined }) {
-		if (!relation.nullable && !targetRelation.orphanRemoval) {
-			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-		}
-		const currentOwner = await this.mapper.getPrimaryValue(targetEntity, {
-			[targetRelation.name]: { [entity.primary]: this.primaryValue },
-		})
-		if (!currentOwner) {
-			return [new MutationNothingToDo([], NothingToDoReason.emptyRelation)]
-		}
-		if (currentOwner && !targetRelation.nullable) {
-			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-		}
-
-		const result = await this.mapper.updateInternal(
-			targetEntity,
-			{ [targetEntity.primary]: currentOwner },
-			builder => {
-				builder.addPredicates([targetRelation.name])
-				builder.addFieldValue(targetRelation.name, null)
-			},
-		)
-		if (targetRelation.orphanRemoval) {
-			result.push(...(await this.mapper.delete(entity, { [entity.primary]: this.primaryValue })))
-		}
-		return result
-	}
-
-	public async delete({ entity, targetEntity, relation, targetRelation }: Model.OneHasOneInverseContext & { input: undefined }) {
-		if (!relation.nullable && !targetRelation.orphanRemoval) {
-			return [new MutationConstraintViolationError([], ConstraintType.notNull)]
-		}
-		// orphan removal is handled in mapper.delete
-		return await this.mapper.delete(targetEntity, { [targetRelation.name]: { [entity.primary]: this.primaryValue } })
-	}
-}

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