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

package/src/mapper/delete/DeleteExecutor.ts

@@ -1,24 +1,37 @@
 import { Acl, Input, Model } from '@contember/schema'
 import { assertNever } from '../../utils'
-import { acceptEveryFieldVisitor } from '@contember/schema-utils'
-import { Client, DeleteBuilder, ForeignKeyViolationError, SelectBuilder } from '@contember/database'
+import { Client, DeleteBuilder, Literal, SelectBuilder } from '@contember/database'
 import { PathFactory, WhereBuilder } from '../select'
 import { PredicateFactory } from '../../acl'
 import { UpdateBuilderFactory } from '../update'
 import {
+	ConstraintType,
+	MutationConstraintViolationError,
 	MutationDeleteOk,
 	MutationEntryNotFoundError,
 	MutationNoResultError,
 	MutationNothingToDo,
-	MutationResultHint,
 	MutationResultList,
+	MutationUpdateOk,
 	NothingToDoReason,
 } from '../Result'
 import { Mapper } from '../Mapper'
 import { CheckedPrimary } from '../CheckedPrimary'
+import { DeleteState } from './DeleteState'
+import {
+	EntityReferenceRow,
+	findOwningRelations,
+	findRelationsWithOrphanRemoval,
+	formatConstraintViolationMessage,
+	OneHasOneOwningRelationTuple,
+} from './helpers'
+import { getEntity } from '@contember/schema-utils'
+import { AfterUpdateEvent, BeforeDeleteEvent, BeforeUpdateEvent, EventManager } from '../EventManager'
+import { ImplementationException } from '../../exception'
+
+type DeleteQueue = [entity: Model.Entity, ids: Input.PrimaryValue[]][]
 
-type EntityOwningRelationTuple = [Model.Entity, Model.ManyHasOneRelation | Model.OneHasOneOwningRelation]
-type OneHasOneOwningRelationTuple = [Model.Entity, Model.OneHasOneOwningRelation]
+type DeleteInfoRow = { allowed: boolean; id: Input.PrimaryValue } & { [K in `_${string}`]: Input.PrimaryValue }
 
 export class DeleteExecutor {
 	constructor(
@@ -27,7 +40,8 @@ export class DeleteExecutor {
 		private readonly whereBuilder: WhereBuilder,
 		private readonly updateBuilderFactory: UpdateBuilderFactory,
 		private readonly pathFactory: PathFactory,
-	) {}
+	) {
+	}
 
 	public async execute(
 		mapper: Mapper,
@@ -40,125 +54,278 @@ export class DeleteExecutor {
 			if (!primaryValue) {
 				return [new MutationEntryNotFoundError([], by as Input.UniqueWhere)]
 			}
+
 			if (mapper.deletedEntities.isDeleted(entity.name, primaryValue)) {
 				return [new MutationNothingToDo([], NothingToDoReason.alreadyDeleted)]
 			}
-			await mapper.constraintHelper.setFkConstraintsDeferred()
+
 			const primaryWhere = { [entity.primary]: { eq: primaryValue } }
-			const result = await this.delete(mapper, entity, filter ? { and: [primaryWhere, filter] } : primaryWhere)
-			await mapper.constraintHelper.setFkConstraintsImmediate()
-			if (result.length === 0) {
-				return [new MutationNoResultError([])]
+			const where = filter ? { and: [primaryWhere, filter] } : primaryWhere
+			const state = new DeleteState(mapper.deletedEntities)
+			const deletePrimary = await this.collectDeleteInfo(state, mapper, entity, where)
+
+			const deleteQueue: DeleteQueue = [[entity, deletePrimary]]
+			await this.collectOrphanRemovals(state, mapper, deleteQueue)
+			if (!state.isOk()) {
+				return state.getResult()
 			}
+			const result = state.getResult()
+			const entryToEventMap = new Map<MutationUpdateOk, BeforeUpdateEvent>()
+			for (const entry of result) {
+				if (entry instanceof MutationDeleteOk) {
+					await mapper.eventManager.fire(new BeforeDeleteEvent(entry.entity, entry.primary))
+				} else if (entry instanceof MutationUpdateOk) {
+					const beforeUpdateEvent = new BeforeUpdateEvent(entry.entity, [{
+						columnName: Object.keys(entry.values)[0],
+						fieldName: Object.keys(entry.input)[0],
+						columnType: 'text',
+						resolvedValue: null,
+						value: Promise.resolve(null),
+					}], entry.primary)
+					entryToEventMap.set(entry, beforeUpdateEvent)
+					await mapper.eventManager.fire(beforeUpdateEvent)
+				}
+			}
+
+			await this.executeDeletes(deleteQueue, mapper.db)
+
+			for (const entry of result) {
+				if (entry instanceof MutationUpdateOk) {
+					const beforeEvent = entryToEventMap.get(entry)
+					if (!beforeEvent) {
+						throw new ImplementationException()
+					}
+					const data = [{
+						columnName: Object.keys(entry.values)[0],
+						fieldName: Object.keys(entry.input)[0],
+						columnType: 'text',
+						resolvedValue: null,
+						value: Promise.resolve(null),
+						old: Object.values(entry.oldValues ?? {})[0],
+					}]
+					const afterEvent = new AfterUpdateEvent(entry.entity, data, entry.primary)
+					beforeEvent.afterEvent = afterEvent
+					await mapper.eventManager.fire(afterEvent)
+				}
+			}
+
+			state.confirmDeleted()
 
-			return [new MutationDeleteOk([], entity, primaryValue)]
+			return state.getResult()
 		})
 	}
 
-	private async delete(mapper: Mapper, entity: Model.Entity, where: Input.OptionalWhere): Promise<string[]> {
-		const db = mapper.db
+	private async executeDeletes(deleteQueue: DeleteQueue, db: Client): Promise<void> {
+		for (const [entity, ids] of deleteQueue) {
+			if (ids.length === 0) {
+				continue
+			}
+			await DeleteBuilder.create()
+				.from(entity.tableName)
+				.where(expr => expr.in(entity.primaryColumn, ids))
+				.execute(db)
+		}
+	}
+
+	private async collectDeleteInfo(
+		state: DeleteState,
+		mapper: Mapper,
+		entity: Model.Entity,
+		where: Input.OptionalWhere,
+	): Promise<Input.PrimaryValue[]> {
 		const predicate = this.predicateFactory.createDeletePredicate(entity)
-		const inQb = SelectBuilder.create() //
+		const orphanRemovals = findRelationsWithOrphanRemoval(this.schema, entity)
+
+		const qb = SelectBuilder.create<DeleteInfoRow>()
 			.from(entity.tableName, 'root_')
-			.select(['root_', entity.primaryColumn])
-		const inQbWithWhere = this.whereBuilder.build(inQb, entity, this.pathFactory.create([]), {
-			and: [where, predicate],
-		})
-		const orphanRemovals = this.findRelationsWithOrphanRemoval(entity)
-		const orphanColumns = orphanRemovals.map(([, rel]) => rel.joiningColumn.columnName)
-		const qb = DeleteBuilder.create()
-			.from(entity.tableName)
-			.where(condition => condition.in(entity.primaryColumn, inQbWithWhere))
-			.returning(entity.primaryColumn, ...orphanColumns)
-		const result = await qb.execute(db)
-		const ids = result.map(it => it[entity.primaryColumn]) as string[]
-		for (const id of ids) {
-			mapper.deletedEntities.markDeleted(entity.name, id)
+			.select(['root_', entity.primaryColumn], 'id')
+
+		const qbWithOrphanColumns = this.qbOrphanColumns(qb, orphanRemovals)
+		const qbWithAllowedFlag = this.qbWithAllowed(entity, predicate, qbWithOrphanColumns)
+		const qbWithWhere = this.whereBuilder.build(qbWithAllowedFlag, entity, this.pathFactory.create([]), where)
+
+		const fullResult = await qbWithWhere.getResult(mapper.db)
+
+		if (fullResult.length === 0) {
+			state.pushFailResult(new MutationNoResultError([]))
+			return []
 		}
-		await this.executeOnDelete(mapper, entity, ids)
 
-		for (const [entity, relation] of orphanRemovals) {
-			const ids = result.map(it => it[relation.joiningColumn.columnName]).filter(it => it !== null)
-			const where: Input.Where = { [entity.primary]: { in: ids } }
-			await this.delete(mapper, entity, where)
+		const result = this.filterPlannedForDelete(state, entity, fullResult)
+
+		const disallowed: Input.PrimaryValue[] = result.filter(it => !it.allowed).map(it => it.id)
+		if (disallowed.length) {
+			state.pushFailResult(new MutationEntryNotFoundError([], { [entity.primary]: { in: disallowed } }))
+			return []
 		}
 
-		return ids as string[]
+		return await this.processDeleteResult(state, mapper, entity, result, orphanRemovals)
 	}
 
-	private async executeOnDelete(mapper: Mapper, entity: Model.Entity, values: Input.PrimaryValue[]): Promise<void> {
+
+	private async collectOnDeleteInfo(state: DeleteState, mapper: Mapper, entity: Model.Entity, values: Input.PrimaryValue[]): Promise<void> {
 		if (values.length === 0) {
 			return
 		}
-		const owningRelations = this.findOwningRelations(entity)
+		const owningRelations = findOwningRelations(this.schema, entity)
 		for (const [owningEntity, relation] of owningRelations) {
-			const relationWhere: Input.Where = { [relation.name]: { [entity.primary]: { in: values } } }
-			switch (relation.joiningColumn.onDelete) {
-				case Model.OnDelete.restrict:
-					break
-				case Model.OnDelete.cascade:
-					await this.delete(mapper, owningEntity, relationWhere)
-					break
-				case Model.OnDelete.setNull:
-					await this.setNull(mapper.db, owningEntity, relation, relationWhere)
-					break
-				default:
-					assertNever(relation.joiningColumn.onDelete)
+			if (relation.joiningColumn.onDelete === Model.OnDelete.restrict) {
+				await this.collectRestrictResult(state, mapper, owningEntity, relation, values)
+			} else if (relation.joiningColumn.onDelete === Model.OnDelete.cascade) {
+				await this.collectCascadeResult(state, mapper, owningEntity, relation, values)
+			} else if (relation.joiningColumn.onDelete === Model.OnDelete.setNull) {
+				await this.collectSetNullResult(state, mapper, owningEntity, relation, values)
+			} else {
+				assertNever(relation.joiningColumn.onDelete)
 			}
 		}
 	}
 
-	private async setNull(
-		db: Client,
+	private async collectCascadeResult(
+		state: DeleteState,
+		mapper: Mapper,
 		entity: Model.Entity,
-		relation: Model.Relation & Model.JoiningColumnRelation,
-		where: Input.Where,
+		relation: Model.ManyHasOneRelation | Model.OneHasOneOwningRelation,
+		values: Input.PrimaryValue[],
 	): Promise<void> {
-		const updateBuilder = this.updateBuilderFactory.create(entity, where)
-		const predicateWhere = this.predicateFactory.create(entity, Acl.Operation.update, [relation.name])
-		updateBuilder.addOldWhere(predicateWhere)
-		updateBuilder.addNewWhere(predicateWhere)
-		updateBuilder.addFieldValue(relation.name, null)
-		await updateBuilder.execute(db)
+		const predicate = this.predicateFactory.createDeletePredicate(entity)
+		const orphanRemovals = findRelationsWithOrphanRemoval(this.schema, entity)
+
+		const qb = this.createFetchByIdQueryBuilder(entity, relation, values)
+		const qbWithOrphanColumns = this.qbOrphanColumns(qb, orphanRemovals)
+		const qbWithAllowed = this.qbWithAllowed(entity, predicate, qbWithOrphanColumns)
+
+		const result = this.filterPlannedForDelete(state, entity, await qbWithAllowed.getResult(mapper.db))
+
+		const disallowed = result.filter(it => !it.allowed)
+
+		if (disallowed.length > 0) {
+			const message = formatConstraintViolationMessage(disallowed, entity, relation)
+				+ ' OnDelete behaviour of this relation is set to "cascade". This is possibly caused by ACL denial.'
+
+			state.pushFailResult(new MutationConstraintViolationError([], ConstraintType.foreignKey, message))
+			return
+		}
+
+		this.processDeleteResult(state, mapper, entity, result, orphanRemovals)
 	}
 
-	private findOwningRelations(entity: Model.Entity): EntityOwningRelationTuple[] {
-		return Object.values(this.schema.entities)
-			.map(entity =>
-				acceptEveryFieldVisitor<null | EntityOwningRelationTuple>(this.schema, entity, {
-					visitColumn: () => null,
-					visitManyHasManyInverse: () => null,
-					visitManyHasManyOwning: () => null,
-					visitOneHasOneInverse: () => null,
-					visitOneHasMany: () => null,
-					visitOneHasOneOwning: ({ relation }): EntityOwningRelationTuple => [entity, relation],
-					visitManyHasOne: ({ relation }): EntityOwningRelationTuple => [entity, relation],
-				}),
-			)
-			.reduce<EntityOwningRelationTuple[]>(
-				(acc, value) => [
-					...acc,
-					...Object.values(value).filter<EntityOwningRelationTuple>(
-						(it): it is EntityOwningRelationTuple => it !== null,
-					),
-				],
-				[],
-			)
-			.filter(([{}, relation]) => relation.target === entity.name)
+
+	private async collectSetNullResult(
+		state: DeleteState,
+		mapper: Mapper,
+		entity: Model.Entity,
+		relation: Model.ManyHasOneRelation | Model.OneHasOneOwningRelation,
+		values: Input.PrimaryValue[],
+	): Promise<void> {
+		const predicate = this.predicateFactory.create(entity, Acl.Operation.update, [relation.name])
+
+		const qb = this.createFetchByIdQueryBuilder(entity, relation, values)
+		const qbWithAllowed = this.qbWithAllowed(entity, predicate, qb)
+
+		const result = this.filterPlannedForDelete(state, entity, await qbWithAllowed.getResult(mapper.db))
+
+		const disallowed = result.filter(it => !it.allowed)
+
+		if (disallowed.length === 0) {
+			const input = { [relation.name]: { disconnect: true } }
+			const values = { [relation.joiningColumn.columnName]: null }
+
+			state.pushOkResult(result.map(it => new MutationUpdateOk([], entity, it.id, input, values, { [relation.joiningColumn.columnName]: it.ref })))
+			return
+		}
+
+		const message = formatConstraintViolationMessage(disallowed, entity, relation)
+			+ ' OnDelete behaviour of this relation is set to "set null". This is possibly caused by ACL denial.'
+		state.pushFailResult(new MutationConstraintViolationError([], ConstraintType.foreignKey, message))
+	}
+
+
+	private async collectRestrictResult(
+		state: DeleteState,
+		mapper: Mapper,
+		entity: Model.Entity,
+		relation: Model.ManyHasOneRelation | Model.OneHasOneOwningRelation,
+		values: Input.PrimaryValue[],
+	): Promise<void> {
+		if (mapper.constraintHelper.areFkConstraintsDeferred()) {
+			return
+		}
+		const qb = this.createFetchByIdQueryBuilder(entity, relation, values)
+		const result = this.filterPlannedForDelete(state, entity, await qb.getResult(mapper.db))
+
+		if (result.length === 0) {
+			return
+		}
+
+		const message = formatConstraintViolationMessage(result, entity, relation)
+			+ ' OnDelete behaviour of this relation is set to "restrict". You might consider changing it to "setNull" or "cascade".'
+
+		state.pushFailResult(new MutationConstraintViolationError([], ConstraintType.foreignKey, message))
 	}
 
-	private findRelationsWithOrphanRemoval(entity: Model.Entity): OneHasOneOwningRelationTuple[] {
-		return Object.values(
-			acceptEveryFieldVisitor<OneHasOneOwningRelationTuple | null>(this.schema, entity, {
-				visitColumn: () => null,
-				visitManyHasManyInverse: () => null,
-				visitManyHasManyOwning: () => null,
-				visitOneHasOneInverse: () => null,
-				visitOneHasMany: () => null,
-				visitOneHasOneOwning: ({ relation, targetEntity }) =>
-					relation.orphanRemoval ? [targetEntity, relation] : null,
-				visitManyHasOne: () => null,
-			}),
-		).filter((it): it is OneHasOneOwningRelationTuple => it !== null)
+	private async collectOrphanRemovals(state: DeleteState, mapper: Mapper, deleteQueue: DeleteQueue) {
+		do {
+			if (!state.isOk()) {
+				return
+			}
+
+			const orphanRemoval = state.fetchOrphanRemovals()
+			if (orphanRemoval === null) {
+				break
+			}
+
+			const entity = getEntity(this.schema, orphanRemoval[0])
+			const orphanResult = await this.collectDeleteInfo(state, mapper, entity, { [entity.primary]: { in: orphanRemoval[1] } })
+			deleteQueue.push([entity, orphanResult])
+
+		} while (true)
+	}
+
+	private qbWithAllowed<R>(entity: Model.Entity, predicate: Input.OptionalWhere, selectQb: SelectBuilder<R>): SelectBuilder<R & { allowed: boolean }> {
+		return this.whereBuilder.buildAdvanced<R & { allowed: boolean }>(entity, this.pathFactory.create([]), predicate, cb => {
+			const qb = selectQb.select(expr => expr.selectCondition(cb), 'allowed')
+			return (qb === selectQb ? qb.select(new Literal('true'), 'allowed') : qb) as SelectBuilder<R & { allowed: boolean }>
+		})
+	}
+
+	private qbOrphanColumns<R>(qb: SelectBuilder<R>, orphanRemovals: OneHasOneOwningRelationTuple[]): SelectBuilder<R> {
+		const orphanColumns = orphanRemovals.map(([, rel]) => rel.joiningColumn.columnName)
+		return orphanColumns.reduce((qb, column) => qb.select(['root_', column], `_${column}`), qb)
+	}
+
+	private createFetchByIdQueryBuilder(entity: Model.Entity, relation: Model.ManyHasOneRelation | Model.OneHasOneOwningRelation, values: Input.PrimaryValue[]) {
+		return SelectBuilder.create<EntityReferenceRow>()
+			.from(entity.tableName, 'root_')
+			.select(['root_', entity.primaryColumn], 'id')
+			.select(['root_', relation.joiningColumn.columnName], 'ref')
+			.where(expr => expr.in(relation.joiningColumn.columnName, values))
+	}
+
+	private filterPlannedForDelete<R extends {id: Input.PrimaryValue}>(state: DeleteState, entity: Model.Entity, values: R[]): R[] {
+		return values.filter(it => !state.isPlannedDelete(entity.name, it.id))
+	}
+
+
+	private async processDeleteResult(
+		state: DeleteState,
+		mapper: Mapper,
+		entity: Model.Entity,
+		result: DeleteInfoRow[],
+		orphanRemovals: OneHasOneOwningRelationTuple[],
+	): Promise<Input.PrimaryValue[]> {
+		const ids = result.map(it => it.id)
+		state.markPlannedDelete(entity.name, ids)
+		state.pushOkResult(ids.map(id => new MutationDeleteOk([], entity, id)))
+
+		await this.collectOnDeleteInfo(state, mapper, entity, ids)
+
+		for (const [entity, relation] of orphanRemovals) {
+			const ids = result.map(it => it[`_${relation.joiningColumn.columnName}`]).filter(it => it !== null)
+			if (ids.length) {
+				state.addOrphanRemoval(entity.name, ids)
+			}
+		}
+		return ids
 	}
 }

package/src/mapper/delete/DeleteState.ts

@@ -0,0 +1,80 @@
+import { DeletedEntitiesStorage } from './DeletedEntitiesStorage'
+import { Input } from '@contember/schema'
+import { ImplementationException } from '../../exception'
+import { MutationResult, MutationResultList } from '../Result'
+
+export class DeleteState {
+	private plannedDelete = new DeletedEntitiesStorage()
+
+	private plannedOrphanRemovals = new Map<string, Set<Input.PrimaryValue>>()
+	private plannedOrphanRemovalsEntityQueue: string[] = []
+
+	public result: MutationResultList = []
+	public failResult: MutationResultList = []
+
+	constructor(
+		private alreadyDeleted: DeletedEntitiesStorage,
+	) {
+	}
+
+	public isOk() {
+		return this.failResult.length === 0
+	}
+
+	public getResult(): MutationResultList {
+		return this.failResult.length > 0 ? this.failResult : this.result
+	}
+
+	public pushOkResult(result: MutationResultList | MutationResult) {
+		this.result.push(...Array.isArray(result) ? result : [result])
+	}
+
+	public pushFailResult(result: MutationResultList | MutationResult) {
+		this.failResult.push(...Array.isArray(result) ? result : [result])
+	}
+
+
+	public isPlannedDelete(entityName: string, primary: Input.PrimaryValue): boolean {
+		return this.plannedDelete.isDeleted(entityName, primary)
+	}
+
+	public confirmDeleted() {
+		this.alreadyDeleted.merge(this.plannedDelete)
+		this.plannedDelete = new DeletedEntitiesStorage()
+	}
+
+	public markPlannedDelete(entityName: string, primaryValues: Input.PrimaryValue[]): void {
+		for (const primary of primaryValues) {
+			this.plannedDelete.markDeleted(entityName, primary)
+		}
+	}
+
+	public addOrphanRemoval(entityName: string, primaryValues: Input.PrimaryValue[]): void {
+		let entityIds = this.plannedOrphanRemovals.get(entityName)
+		if (!entityIds) {
+			entityIds = new Set()
+			this.plannedOrphanRemovals.set(entityName, entityIds)
+			this.plannedOrphanRemovalsEntityQueue.push(entityName)
+		}
+		for (const primary of primaryValues) {
+			entityIds.add(primary)
+		}
+	}
+
+	public fetchOrphanRemovals(): [entityName: string, ids: Input.PrimaryValue[]] | null {
+		const entityName = this.plannedOrphanRemovalsEntityQueue.shift()
+		if (!entityName) {
+			return null
+		}
+		const ids = this.plannedOrphanRemovals.get(entityName)
+		if (!ids) {
+			throw new ImplementationException(`DeleteState.plannedOrphanRemovals is expected to have ${entityName}`)
+		}
+		this.plannedOrphanRemovals.delete(entityName)
+		const idsToRemove = [...ids.values()].filter(it => !this.isPlannedDelete(entityName, it))
+		if (idsToRemove.length > 0) {
+			return [entityName, idsToRemove]
+		}
+		return this.fetchOrphanRemovals()
+	}
+}

package/src/mapper/delete/DeletedEntitiesStorage.ts

@@ -7,6 +7,12 @@ export class DeletedEntitiesStorage {
 		this.deleted.add(this.getKey(entityName, primary))
 	}
 
+	public merge(storage: DeletedEntitiesStorage) {
+		for (const key of storage.deleted) {
+			this.deleted.add(key)
+		}
+	}
+
 	public isDeleted(entityName: string, primary: Input.PrimaryValue): boolean {
 		return this.deleted.has(this.getKey(entityName, primary))
 	}

package/src/mapper/delete/helpers.ts

@@ -0,0 +1,68 @@
+import { Input, Model } from '@contember/schema'
+import { acceptEveryFieldVisitor } from '@contember/schema-utils'
+
+export type OneHasOneOwningRelationTuple = [Model.Entity, Model.OneHasOneOwningRelation]
+
+export const findRelationsWithOrphanRemoval = (schema: Model.Schema, entity: Model.Entity): OneHasOneOwningRelationTuple[] => {
+	return Object.values(
+		acceptEveryFieldVisitor<OneHasOneOwningRelationTuple | null>(schema, entity, {
+			visitColumn: () => null,
+			visitManyHasManyInverse: () => null,
+			visitManyHasManyOwning: () => null,
+			visitOneHasOneInverse: () => null,
+			visitOneHasMany: () => null,
+			visitOneHasOneOwning: ({ relation, targetEntity }) =>
+				relation.orphanRemoval ? [targetEntity, relation] : null,
+			visitManyHasOne: () => null,
+		}),
+	).filter((it): it is OneHasOneOwningRelationTuple => it !== null)
+}
+
+export type EntityOwningRelationTuple = [Model.Entity, Model.ManyHasOneRelation | Model.OneHasOneOwningRelation]
+
+export const findOwningRelations = (schema: Model.Schema, entity: Model.Entity): EntityOwningRelationTuple[] => {
+	return Object.values(schema.entities)
+		.map(entity =>
+			acceptEveryFieldVisitor<null | EntityOwningRelationTuple>(schema, entity, {
+				visitColumn: () => null,
+				visitManyHasManyInverse: () => null,
+				visitManyHasManyOwning: () => null,
+				visitOneHasOneInverse: () => null,
+				visitOneHasMany: () => null,
+				visitOneHasOneOwning: ({ relation }): EntityOwningRelationTuple => [entity, relation],
+				visitManyHasOne: ({ relation }): EntityOwningRelationTuple => [entity, relation],
+			}),
+		)
+		.reduce<EntityOwningRelationTuple[]>(
+			(acc, value) => [
+				...acc,
+				...Object.values(value).filter<EntityOwningRelationTuple>(
+					(it): it is EntityOwningRelationTuple => it !== null,
+				),
+			],
+			[],
+		)
+		.filter(([{}, relation]) => relation.target === entity.name)
+}
+
+export type EntityReferenceRow = { id: Input.PrimaryValue; ref: Input.PrimaryValue }
+
+export const formatConstraintViolationMessage = (
+	rows: Pick<EntityReferenceRow, 'id' | 'ref'>[],
+	entity: Model.Entity,
+	relation: Model.ManyHasOneRelation | Model.OneHasOneOwningRelation,
+) => {
+	const referencedRows = [...new Set(rows.map(it => it.ref))]
+	const referencedRowsSample = referencedRows.slice(0, 10)
+	const referencedRowsRemaining = referencedRows.length - referencedRowsSample.length
+
+	const referencingRowsSample = rows.slice(0, 10).map(it => it.id)
+	const referencingRowsRemaining = rows.length - referencingRowsSample.length
+
+	return 'Cannot delete ' + referencedRowsSample.join(', ')
+		+ (referencedRowsRemaining > 0 ? ` and ${referencedRowsRemaining} more` : '')
+		+ ` row(s) of entity ${relation.target}, `
+		+ `because it is still referenced from ` + referencingRowsSample.join(', ')
+		+ (referencingRowsRemaining > 0 ? ` and ${referencingRowsRemaining} more` : '')
+		+ ` row(s) of entity ${entity.name} in relation ${relation.name}.`
+}

package/src/mapper/index.ts

@@ -5,9 +5,11 @@ export * from './update'
 export * from './ColumnValue'
 export * from './Constraints'
 export * from './ErrorUtils'
+export * from './EventManager'
 export * from './JunctionTableManager'
 export * from './Mapper'
-export * from './MapperContainer'
+export * from '../ExecutionContainer'
+export * from './MapperFactory'
 export * from './MutationProcessorHelper'
 export * from './Result'
 export * from './types'