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

package/src/mapper/EventManager.ts

@@ -0,0 +1,158 @@
+import { Input, Model, Value } from '@contember/schema'
+import { ResolvedColumnValue } from './ColumnValue'
+import { Mapper } from './Mapper'
+import { logger } from '@contember/logger'
+
+export class BeforeInsertEvent {
+	public type = 'BeforeInsertEvent' as const
+
+	public afterEvent: AfterInsertEvent | undefined = undefined
+
+	constructor(
+		public readonly entity: Model.Entity,
+		public readonly data: ResolvedColumnValue[],
+	) {
+	}
+}
+
+export class AfterInsertEvent {
+	public type = 'AfterInsertEvent' as const
+
+	constructor(
+		public readonly entity: Model.Entity,
+		public readonly data: ResolvedColumnValue[],
+		public readonly id: Input.PrimaryValue,
+	) {
+	}
+}
+
+
+export class BeforeUpdateEvent {
+	public type = 'BeforeUpdateEvent' as const
+
+	public afterEvent: AfterUpdateEvent | undefined = undefined
+
+	constructor(
+		public readonly entity: Model.Entity,
+		public readonly data: ResolvedColumnValue[],
+		public readonly id: Input.PrimaryValue,
+	) {
+	}
+}
+
+export class AfterUpdateEvent {
+	public type = 'AfterUpdateEvent' as const
+
+	private _hasChanges: boolean | undefined
+
+	constructor(
+		public readonly entity: Model.Entity,
+		public readonly data: (ResolvedColumnValue & { old: Value.FieldValue })[],
+		public readonly id: Input.PrimaryValue,
+	) {
+	}
+	get hasChanges() {
+		// todo: deep equals
+		return this._hasChanges = this.data.some(it => it.resolvedValue !== it.old)
+	}
+}
+
+export class BeforeDeleteEvent {
+	public type = 'BeforeDeleteEvent' as const
+
+	constructor(
+		public readonly entity: Model.Entity,
+		public readonly id: Input.PrimaryValue,
+	) {
+	}
+}
+
+export class BeforeJunctionUpdateEvent {
+	public type = 'BeforeJunctionUpdateEvent' as const
+
+	public afterEvent: AfterJunctionUpdateEvent | undefined = undefined
+
+	constructor(
+		public readonly owningEntity: Model.Entity,
+		public readonly owningRelation: Model.ManyHasManyOwningRelation,
+		public readonly owningId: Input.PrimaryValue,
+		public readonly inverseId: Input.PrimaryValue,
+		public readonly operation: 'connect' | 'disconnect',
+	) {
+	}
+}
+
+
+export class AfterJunctionUpdateEvent {
+	public type = 'AfterJunctionUpdateEvent' as const
+
+	constructor(
+		public readonly owningEntity: Model.Entity,
+		public readonly owningRelation: Model.ManyHasManyOwningRelation,
+		public readonly owningId: Input.PrimaryValue,
+		public readonly inverseId: Input.PrimaryValue,
+		public readonly operation: 'connect' | 'disconnect',
+		public readonly hasChanges: boolean,
+	) {
+	}
+}
+
+export class BeforeCommitEvent {
+	public type = 'BeforeCommitEvent' as const
+}
+
+export class AfterCommitEvent {
+	public type = 'AfterCommitEvent' as const
+}
+
+export type DataModificationEvent =
+	| BeforeInsertEvent
+	| AfterInsertEvent
+	| BeforeUpdateEvent
+	| AfterUpdateEvent
+	| BeforeJunctionUpdateEvent
+	| AfterJunctionUpdateEvent
+	| BeforeDeleteEvent
+
+export type AnyEvent =
+	| DataModificationEvent
+	| BeforeCommitEvent
+	| AfterCommitEvent
+
+export type EventMap<E extends AnyEvent = AnyEvent> = {
+	[K in E['type']]: E extends { type: K } ? E : never
+}
+
+export type EventListener<K extends keyof EventMap> = (event: EventMap[K], mapper: Mapper) => Promise<void>
+
+export class EventManager {
+	private listeners: { [K in keyof EventMap]: EventListener<K>[] } = {
+		BeforeInsertEvent: [],
+		AfterInsertEvent: [],
+		BeforeUpdateEvent: [],
+		AfterUpdateEvent: [],
+		BeforeDeleteEvent: [],
+		BeforeCommitEvent: [],
+		AfterCommitEvent: [],
+		BeforeJunctionUpdateEvent: [],
+		AfterJunctionUpdateEvent: [],
+	}
+
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public listen<K extends keyof EventMap>(type: K, cb: EventListener<K>) {
+		this.listeners[type].push(cb)
+	}
+
+	public async fire<K extends keyof EventMap>(event: EventMap[K]) {
+		(await Promise.allSettled(this.listeners[event.type].map(it => (it as EventListener<K>)(event, this.mapper))))
+			.map(it => {
+				if (it.status === 'rejected') {
+					logger.error(it.reason)
+				}
+			})
+	}
+}

package/src/mapper/JunctionTableManager.ts

@@ -1,6 +1,5 @@
 import { getEntity } from '@contember/schema-utils'
-import { PathFactory } from './select'
-import { WhereBuilder } from './select'
+import { PathFactory, WhereBuilder } from './select'
 import { PredicateFactory } from '../acl'
 import {
 	Client,
@@ -16,14 +15,21 @@ import {
 	MutationJunctionUpdateOk,
 	MutationNoResultError,
 	MutationNothingToDo,
-	MutationResult,
 	MutationResultList,
+	MutationResultType,
 	NothingToDoReason,
 } from './Result'
 import { ImplementationException } from '../exception'
+import { AfterJunctionUpdateEvent, BeforeJunctionUpdateEvent } from './EventManager'
+import { Mapper } from './Mapper'
 
 type OkResultFactory = () => MutationJunctionUpdateOk
 
+type JunctionMutationResult =
+	| MutationJunctionUpdateOk
+	| MutationNothingToDo
+	| MutationNoResultError
+
 export class JunctionTableManager {
 	constructor(
 		private readonly schema: Model.Schema,
@@ -35,43 +41,55 @@ export class JunctionTableManager {
 	) {}
 
 	public async connectJunction(
-		db: Client,
+		mapper: Mapper,
 		owningEntity: Model.Entity,
 		relation: Model.ManyHasManyOwningRelation,
 		owningUnique: Input.PrimaryValue,
 		inverseUnique: Input.PrimaryValue,
 	): Promise<MutationResultList> {
-		return [
-			await this.executeJunctionModification(
-				db,
-				owningEntity,
-				relation,
-				owningUnique,
-				inverseUnique,
-				this.connectJunctionHandler,
-			),
-		]
+		const beforeEvent = new BeforeJunctionUpdateEvent(owningEntity, relation, owningUnique, inverseUnique, 'connect')
+		await mapper.eventManager.fire(beforeEvent)
+		const result = await this.executeJunctionModification(
+			mapper.db,
+			owningEntity,
+			relation,
+			owningUnique,
+			inverseUnique,
+			this.connectJunctionHandler,
+		)
+		if (result.result !== MutationResultType.noResultError) {
+			const afterEvent = new AfterJunctionUpdateEvent(owningEntity, relation, owningUnique, inverseUnique, 'connect', result.result === MutationResultType.ok)
+			await mapper.eventManager.fire(afterEvent)
+		}
+		return [result]
 	}
 
 	public async disconnectJunction(
-		db: Client,
+		mapper: Mapper,
 		owningEntity: Model.Entity,
 		relation: Model.ManyHasManyOwningRelation,
 		owningUnique: Input.PrimaryValue,
 		inverseUnique: Input.PrimaryValue,
 	): Promise<MutationResultList> {
-		return [
-			await this.executeJunctionModification(
-				db,
-				owningEntity,
-				relation,
-				owningUnique,
-				inverseUnique,
-				this.disconnectJunctionHandler,
-			),
-		]
+		const beforeEvent = new BeforeJunctionUpdateEvent(owningEntity, relation, owningUnique, inverseUnique, 'connect')
+		await mapper.eventManager.fire(beforeEvent)
+		const result = await this.executeJunctionModification(
+			mapper.db,
+			owningEntity,
+			relation,
+			owningUnique,
+			inverseUnique,
+			this.disconnectJunctionHandler,
+		)
+		if (result.result !== MutationResultType.noResultError) {
+			const afterEvent = new AfterJunctionUpdateEvent(owningEntity, relation, owningUnique, inverseUnique, 'disconnect', result.result === MutationResultType.ok)
+			beforeEvent.afterEvent = afterEvent
+			await mapper.eventManager.fire(afterEvent)
+		}
+		return [result]
 	}
 
+
 	private async executeJunctionModification(
 		db: Client,
 		owningEntity: Model.Entity,
@@ -79,7 +97,7 @@ export class JunctionTableManager {
 		owningPrimary: Input.PrimaryValue,
 		inversePrimary: Input.PrimaryValue,
 		handler: JunctionHandler,
-	): Promise<MutationResult> {
+	): Promise<JunctionMutationResult> {
 		const joiningTable = relation.joiningTable
 		const inverseEntity = getEntity(this.schema, relation.target)
 		if (inverseEntity.view || owningEntity.view) {
@@ -145,9 +163,9 @@ interface JunctionComplexExecutionArgs {
 }
 
 interface JunctionHandler {
-	executeSimple(args: JunctionSimpleExecutionArgs): Promise<MutationResult>
+	executeSimple(args: JunctionSimpleExecutionArgs): Promise<JunctionMutationResult>
 
-	executeComplex(args: JunctionComplexExecutionArgs): Promise<MutationResult>
+	executeComplex(args: JunctionComplexExecutionArgs): Promise<JunctionMutationResult>
 }
 
 export class JunctionConnectHandler implements JunctionHandler {
@@ -157,7 +175,7 @@ export class JunctionConnectHandler implements JunctionHandler {
 		owningPrimary,
 		inversePrimary,
 		okResultFactory,
-	}: JunctionSimpleExecutionArgs): Promise<MutationResult> {
+	}: JunctionSimpleExecutionArgs): Promise<JunctionMutationResult> {
 		const result = await InsertBuilder.create()
 			.into(joiningTable.tableName)
 			.values({
@@ -177,7 +195,7 @@ export class JunctionConnectHandler implements JunctionHandler {
 		joiningTable,
 		dataCallback,
 		okResultFactory,
-	}: JunctionComplexExecutionArgs): Promise<MutationResult> {
+	}: JunctionComplexExecutionArgs): Promise<JunctionMutationResult> {
 		const insert = InsertBuilder.create()
 			.into(joiningTable.tableName)
 			.values({
@@ -216,7 +234,7 @@ export class JunctionDisconnectHandler implements JunctionHandler {
 		owningPrimary,
 		inversePrimary,
 		okResultFactory,
-	}: JunctionSimpleExecutionArgs): Promise<MutationResult> {
+	}: JunctionSimpleExecutionArgs): Promise<JunctionMutationResult> {
 		const qb = DeleteBuilder.create()
 			.from(joiningTable.tableName)
 			.where(cond => cond.compare(joiningTable.joiningColumn.columnName, Operator.eq, owningPrimary))
@@ -234,7 +252,7 @@ export class JunctionDisconnectHandler implements JunctionHandler {
 		joiningTable,
 		dataCallback,
 		okResultFactory,
-	}: JunctionComplexExecutionArgs): Promise<MutationResult> {
+	}: JunctionComplexExecutionArgs): Promise<JunctionMutationResult> {
 		const deleteQb = DeleteBuilder.create()
 			.from(joiningTable.tableName)
 			.using('data')

package/src/mapper/Mapper.ts

@@ -1,5 +1,5 @@
 import { Input, Model } from '@contember/schema'
-import { acceptFieldVisitor, getColumnName } from '@contember/schema-utils'
+import { acceptFieldVisitor, getColumnName, SchemaDatabaseMetadata } from '@contember/schema-utils'
 import {
 	OrderByHelper,
 	PathFactory,
@@ -10,8 +10,7 @@ import {
 	SelectResultObject,
 	WhereBuilder,
 } from './select'
-import * as database from '@contember/database'
-import { Client, ConstraintHelper, SelectBuilder } from '@contember/database'
+import { Client, Connection, ConstraintHelper, SelectBuilder } from '@contember/database'
 import { PredicatesInjector } from '../acl'
 import { JunctionTableManager } from './JunctionTableManager'
 import { DeletedEntitiesStorage, DeleteExecutor } from './delete'
@@ -23,16 +22,23 @@ import { ObjectNode, UniqueWhereExpander } from '../inputProcessing'
 import { Mutex } from '../utils'
 import { CheckedPrimary } from './CheckedPrimary'
 import { ImplementationException } from '../exception'
+import { EventManager } from './EventManager'
 
-export class Mapper {
+export class Mapper<ConnectionType extends Connection.ConnectionLike = Connection.ConnectionLike> {
 	private primaryKeyCache: Record<string, Promise<string> | string> = {}
+	private systemVariablesSetupDone: Promise<void> | undefined
 	public readonly deletedEntities = new DeletedEntitiesStorage()
 	public readonly mutex = new Mutex()
 	public readonly constraintHelper: ConstraintHelper
 
+	public readonly eventManager: EventManager
+
 	constructor(
+		public readonly db: Client<ConnectionType>,
+		public readonly identityId: string,
+		public readonly transactionId: string,
 		private readonly schema: Model.Schema,
-		public readonly db: database.Client,
+		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
 		private readonly predicatesInjector: PredicatesInjector,
 		private readonly selectBuilderFactory: SelectBuilderFactory,
 		private readonly uniqueWhereExpander: UniqueWhereExpander,
@@ -44,6 +50,7 @@ export class Mapper {
 		private readonly pathFactory: PathFactory,
 	) {
 		this.constraintHelper = new ConstraintHelper(db)
+		this.eventManager = new EventManager(this)
 	}
 
 	public async selectField(entity: Model.Entity, where: Input.UniqueWhere | CheckedPrimary, fieldName: string) {
@@ -122,7 +129,7 @@ export class Mapper {
 		relationPath: Model.AnyRelationContext[],
 		groupBy?: string,
 	) {
-		const inputWithOrder = OrderByHelper.appendDefaultOrderBy(entity, input, [])
+		const inputWithOrder = OrderByHelper.appendDefaultOrderBy(entity, input, undefined)
 		const path = this.pathFactory.create([])
 		const augmentedBuilder = qb.from(entity.tableName, path.alias).meta('path', [...input.path, input.alias])
 
@@ -174,12 +181,9 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
-		const pushId = (id: string) => {
-			const where = { [entity.primary]: id }
-			this.primaryKeyCache[this.hashWhere(entity.name, where)] = id
-		}
-		return tryMutation(this.schema, () =>
-			this.inserter.insert(this, entity, data, pushId, builderCb),
+		await this.setupSystemVariables()
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, () =>
+			this.insertInternal(entity, data, builderCb),
 		)
 	}
 
@@ -192,7 +196,8 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
-		return tryMutation(this.schema, async () => {
+		await this.setupSystemVariables()
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
 				return [new MutationEntryNotFoundError([], by)]
@@ -209,7 +214,8 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
-		return tryMutation(this.schema, async () => {
+		await this.setupSystemVariables()
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
 				return [new MutationEntryNotFoundError([], by as Input.UniqueWhere)]
@@ -227,19 +233,23 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
-		return tryMutation(this.schema, async () => {
+		await this.setupSystemVariables()
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
-				const pushIdCallback = (id: string) => {
-					const where = { [entity.primary]: id }
-					this.primaryKeyCache[this.hashWhere(entity.name, where)] = id
-				}
-				return await this.inserter.insert(this, entity, create, pushIdCallback, () => {})
+				return await this.insertInternal(entity, create)
 			}
 			return await this.updater.update(this, entity, primaryValue, update, filter)
 		})
 	}
 
+	private insertInternal(entity: Model.Entity, data: Input.CreateDataInput, builderCb: (builder: InsertBuilder) => void = () => {}) {
+		return this.inserter.insert(this, entity, data, id => {
+			const where = { [entity.primary]: id }
+			this.primaryKeyCache[this.hashWhere(entity.name, where)] = id
+		}, builderCb)
+	}
+
 	public async delete(
 		entity: Model.Entity,
 		by: Input.UniqueWhere | CheckedPrimary,
@@ -248,7 +258,10 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
-		return tryMutation(this.schema, () => this.deleteExecutor.execute(this, entity, by, filter))
+		await this.setupSystemVariables()
+		return tryMutation(this.schema, this.schemaDatabaseMetadata, () => {
+			return this.deleteExecutor.execute(this, entity, by, filter)
+		})
 	}
 
 	public async connectJunction(
@@ -257,15 +270,16 @@ export class Mapper {
 		thisPrimary: Input.PrimaryValue,
 		otherPrimary: Input.PrimaryValue,
 	): Promise<MutationResultList> {
+		await this.setupSystemVariables()
 		const err = () => {
 			throw new ImplementationException()
 		}
 		return await acceptFieldVisitor(this.schema, entity, relation, {
 			visitManyHasManyOwning: ({ entity, relation }) => {
-				return this.junctionTableManager.connectJunction(this.db, entity, relation, thisPrimary, otherPrimary)
+				return this.junctionTableManager.connectJunction(this, entity, relation, thisPrimary, otherPrimary)
 			},
 			visitManyHasManyInverse: ({ targetEntity, targetRelation }) => {
-				return this.junctionTableManager.connectJunction(this.db, targetEntity, targetRelation, otherPrimary, thisPrimary)
+				return this.junctionTableManager.connectJunction(this, targetEntity, targetRelation, otherPrimary, thisPrimary)
 			},
 			visitColumn: err,
 			visitOneHasMany: err,
@@ -281,15 +295,16 @@ export class Mapper {
 		thisPrimary: Input.PrimaryValue,
 		otherPrimary: Input.PrimaryValue,
 	): Promise<MutationResultList> {
+		await this.setupSystemVariables()
 		const err = () => {
 			throw new ImplementationException()
 		}
 		return await acceptFieldVisitor(this.schema, entity, relation, {
 			visitManyHasManyOwning: ({ entity, relation }) => {
-				return this.junctionTableManager.disconnectJunction(this.db, entity, relation, thisPrimary, otherPrimary)
+				return this.junctionTableManager.disconnectJunction(this, entity, relation, thisPrimary, otherPrimary)
 			},
 			visitManyHasManyInverse: ({ targetEntity, targetRelation }) => {
-				return this.junctionTableManager.disconnectJunction(this.db, targetEntity, targetRelation, otherPrimary, thisPrimary)
+				return this.junctionTableManager.disconnectJunction(this, targetEntity, targetRelation, otherPrimary, thisPrimary)
 			},
 			visitColumn: err,
 			visitOneHasMany: err,
@@ -323,6 +338,12 @@ export class Mapper {
 	private hashWhere(entityName: string, where: Input.UniqueWhere): string {
 		return JSON.stringify([entityName, where])
 	}
-}
 
-export type MapperFactory = (db: Client) => Mapper
+	private async setupSystemVariables() {
+		this.systemVariablesSetupDone ??= (async () => {
+			await this.db.query('SELECT set_config(?, ?, false)', ['tenant.identity_id', this.identityId]) // todo rename to system.identity_id
+			await this.db.query('SELECT set_config(?, ?, false)', ['system.transaction_id', this.transactionId])
+		})()
+		await this.systemVariablesSetupDone
+	}
+}

package/src/mapper/MapperFactory.ts

@@ -0,0 +1,69 @@
+import { PredicatesInjector } from '../acl'
+import { PathFactory, SelectBuilderFactory, WhereBuilder } from './select'
+import { UniqueWhereExpander } from '../inputProcessing'
+import { JunctionTableManager } from './JunctionTableManager'
+import { DeleteExecutor } from './delete'
+import { Updater } from './update'
+import { Inserter } from './insert'
+import { Model } from '@contember/schema'
+import { Client, Connection } from '@contember/database'
+import { Mapper } from './Mapper'
+import { Providers, SchemaDatabaseMetadata } from '@contember/schema-utils'
+
+export type MapperFactoryHook = (mapper: Mapper) => void
+
+export class MapperFactory {
+
+	public readonly hooks: MapperFactoryHook[] = []
+
+	constructor(
+		private readonly db: Client,
+		private readonly identityId: string,
+		private readonly schema: Model.Schema,
+		private readonly schemaDatabaseMetadata: SchemaDatabaseMetadata,
+		private readonly predicatesInjector: PredicatesInjector,
+		private readonly selectBuilderFactory: SelectBuilderFactory,
+		private readonly uniqueWhereExpander: UniqueWhereExpander,
+		private readonly whereBuilder: WhereBuilder,
+		private readonly junctionTableManager: JunctionTableManager,
+		private readonly deleteExecutor: DeleteExecutor,
+		private readonly updater: Updater,
+		private readonly inserter: Inserter,
+		private readonly pathFactory: PathFactory,
+		private readonly providers: Providers,
+	) {
+	}
+
+	public create() {
+		return this.createInternal(this.db)
+	}
+
+	public transaction<T>(cb: (mapper: Mapper<Connection.TransactionLike>) => Promise<T>): Promise<T> {
+		return this.db.transaction(async trx => {
+			await trx.connection.query(Connection.REPEATABLE_READ)
+			const mapper = this.createInternal(trx)
+			return await cb(mapper)
+		})
+	}
+
+	private createInternal<T extends Connection.ConnectionLike>(db: Client<T>) {
+		const mapper = new Mapper<T>(
+			db,
+			this.identityId,
+			this.providers.uuid(),
+			this.schema,
+			this.schemaDatabaseMetadata,
+			this.predicatesInjector,
+			this.selectBuilderFactory,
+			this.uniqueWhereExpander,
+			this.whereBuilder,
+			this.junctionTableManager,
+			this.deleteExecutor,
+			this.updater,
+			this.inserter,
+			this.pathFactory,
+		)
+		this.hooks.forEach(it => it(mapper))
+		return mapper
+	}
+}

package/src/mapper/Result.ts

@@ -3,6 +3,7 @@ import { convertError } from './ErrorUtils'
 import { getFulfilledValues, getRejections } from '../utils'
 import { SerializationFailureError } from '@contember/database'
 import { logger } from '@contember/logger'
+import { SchemaDatabaseMetadata } from '@contember/schema-utils'
 
 export enum MutationResultType {
 	ok = 'ok',
@@ -50,7 +51,7 @@ interface MutationResultInterface {
 	hints: MutationResultHint[]
 }
 
-export type RowValues = { [fieldName: string]: Value.AtomicValue }
+export type RowValues = { [fieldName: string]: Value.FieldValue }
 
 export class MutationUpdateOk implements MutationResultInterface {
 	result = MutationResultType.ok as const
@@ -63,6 +64,7 @@ export class MutationUpdateOk implements MutationResultInterface {
 		public readonly primary: Value.PrimaryValue,
 		public readonly input: Input.UpdateDataInput,
 		public readonly values: RowValues,
+		public readonly oldValues?: RowValues,
 	) {}
 }
 
@@ -211,6 +213,7 @@ export type ResultListNotFlatten = MutationResultList | MutationResultList[]
 
 export const collectResults = async (
 	schema: Model.Schema,
+	schemaDatabaseMetadata: SchemaDatabaseMetadata,
 	mainPromise: Promise<ResultListNotFlatten | undefined> | undefined,
 	otherPromises: (Promise<ResultListNotFlatten | undefined> | undefined)[],
 ): Promise<MutationResultList> => {
@@ -219,7 +222,7 @@ export const collectResults = async (
 		.filter((it): it is Promise<ResultListNotFlatten> => !!it)
 		.map(it =>
 			it //
-				.catch(e => [convertError(schema, e)])
+				.catch(e => [convertError(schema, schemaDatabaseMetadata, e)])
 				.then(value => ({ value, index: index++ })),
 		)
 	const results = await Promise.allSettled(allPromises)

package/src/mapper/delete/DeleteExecutor.ts

@@ -26,6 +26,8 @@ import {
 	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[]][]
 
@@ -67,7 +69,46 @@ export class DeleteExecutor {
 			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 state.getResult()
@@ -190,7 +231,7 @@ export class DeleteExecutor {
 			const input = { [relation.name]: { disconnect: true } }
 			const values = { [relation.joiningColumn.columnName]: null }
 
-			state.pushOkResult(result.map(it => it.id).map(id => new MutationUpdateOk([], entity, id, input, values)))
+			state.pushOkResult(result.map(it => new MutationUpdateOk([], entity, it.id, input, values, { [relation.joiningColumn.columnName]: it.ref })))
 			return
 		}