@contember/engine-content-api 1.2.1 → 1.3.0-alpha.13

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

package/src/mapper/relations/OneHasOneInverseCreateInputProcessor.ts

@@ -0,0 +1,99 @@
+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/OneHasOneInverseUpdateInputProcessor.ts

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

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