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

package/src/mapper/Mapper.ts

@@ -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,22 @@ 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 predicatesInjector: PredicatesInjector,
 		private readonly selectBuilderFactory: SelectBuilderFactory,
 		private readonly uniqueWhereExpander: UniqueWhereExpander,
@@ -44,6 +49,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 +128,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 +180,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
-		}
+		await this.setupSystemVariables()
 		return tryMutation(this.schema, () =>
-			this.inserter.insert(this, entity, data, pushId, builderCb),
+			this.insertInternal(entity, data, builderCb),
 		)
 	}
 
@@ -192,6 +195,7 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
+		await this.setupSystemVariables()
 		return tryMutation(this.schema, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
@@ -209,6 +213,7 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
+		await this.setupSystemVariables()
 		return tryMutation(this.schema, async () => {
 			const primaryValue = await this.getPrimaryValue(entity, by)
 			if (primaryValue === undefined) {
@@ -227,19 +232,23 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
+		await this.setupSystemVariables()
 		return tryMutation(this.schema, 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,6 +257,7 @@ export class Mapper {
 		if (entity.view) {
 			throw new ImplementationException()
 		}
+		await this.setupSystemVariables()
 		return tryMutation(this.schema, () => this.deleteExecutor.execute(this, entity, by, filter))
 	}
 
@@ -257,15 +267,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 +292,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 +335,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,67 @@
+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 } 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 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.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

@@ -50,7 +50,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 +63,7 @@ export class MutationUpdateOk implements MutationResultInterface {
 		public readonly primary: Value.PrimaryValue,
 		public readonly input: Input.UpdateDataInput,
 		public readonly values: RowValues,
+		public readonly oldValues?: RowValues,
 	) {}
 }
 

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
 		}
 

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'

package/src/mapper/insert/InsertBuilder.ts

@@ -6,6 +6,8 @@ import { ColumnValue, ResolvedColumnValue, resolveGenericValue, resolveRowData }
 import { ImplementationException } from '../../exception'
 import { PredicateFactory } from '../../acl'
 import { AbortDataManipulation, DataManipulationBuilder } from '../DataManipulationBuilder'
+import { AfterInsertEvent, BeforeInsertEvent, EventManager } from '../EventManager'
+import { Mapper } from '../Mapper'
 
 export interface InsertResult {
 	values: ResolvedColumnValue[]
@@ -55,7 +57,7 @@ export class InsertBuilder implements DataManipulationBuilder {
 		return resolveRowData([...this.rowData.values()])
 	}
 
-	public async execute(db: Client): Promise<InsertResult> {
+	public async execute(mapper: Mapper): Promise<InsertResult> {
 		try {
 			const resolvedData = await this.getResolvedData()
 			if (resolvedData.find(it => it.resolvedValue === AbortDataManipulation)) {
@@ -83,8 +85,16 @@ export class InsertBuilder implements DataManipulationBuilder {
 				})
 				.returning(this.entity.primaryColumn)
 
-			const returning = (await qb.execute(db)).map(it => it[this.entity.primaryColumn])
+			const beforeInsertEvent = new BeforeInsertEvent(this.entity, resolvedData as ResolvedColumnValue[])
+			await mapper.eventManager.fire(beforeInsertEvent)
+
+			const returning = (await qb.execute(mapper.db)).map(it => it[this.entity.primaryColumn])
 			const result = returning.length === 1 ? returning[0] : null
+
+			const afterInsertEvent = new AfterInsertEvent(this.entity, resolvedData as ResolvedColumnValue[], result)
+			beforeInsertEvent.afterEvent = afterInsertEvent
+			await mapper.eventManager.fire(afterInsertEvent)
+
 			this.resolver(result)
 			return { values: resolvedData as ResolvedColumnValue[], executed: true, primaryValue: result, aborted: false }
 		} catch (e) {

package/src/mapper/insert/Inserter.ts

@@ -51,18 +51,18 @@ export class Inserter {
 
 		const okResultFactory = (primary: Value.PrimaryValue, values: RowValues) =>
 			new MutationCreateOk([], entity, primary, data, values)
-		const insertPromise = this.executeInsert(insertBuilder, mapper.db, okResultFactory)
+		const insertPromise = this.executeInsert(insertBuilder, mapper, okResultFactory)
 
 		return await collectResults(this.schema, insertPromise, Object.values(promises))
 	}
 
 	private async executeInsert(
 		insertBuilder: InsertBuilder,
-		db: Client,
+		mapper: Mapper,
 		okResultFactory: (primary: Value.PrimaryValue, values: RowValues) => MutationCreateOk,
 	): Promise<MutationResultList> {
 		return tryMutation(this.schema, async () => {
-			const result = await insertBuilder.execute(db)
+			const result = await insertBuilder.execute(mapper)
 			if (result.aborted) {
 				return [new MutationNothingToDo([], NothingToDoReason.aborted)]
 			}

package/src/mapper/select/OrderByHelper.ts

@@ -5,10 +5,11 @@ export class OrderByHelper {
 	public static appendDefaultOrderBy(
 		entity: Model.Entity,
 		objectNode: ObjectNode<Input.ListQueryInput>,
-		defaultOrderBy: readonly Model.OrderBy[],
+		relationOrderBy: readonly Model.OrderBy[] | undefined,
 	): ObjectNode<Input.ListQueryInput> {
 		const inputOrder = objectNode.args.orderBy || []
 		const hasOrderBy = inputOrder.length > 0
+		const defaultOrderBy = relationOrderBy ?? entity.orderBy ?? []
 		if (!hasOrderBy && defaultOrderBy.length > 0) {
 			const defaultOrderByWithPrimary = [...defaultOrderBy, ...this.getPrimaryOrderBy(inputOrder, entity)]
 			return objectNode.withArg('orderBy', this.buildOrderBy(defaultOrderByWithPrimary))

package/src/mapper/select/RelationFetcher.ts

@@ -83,7 +83,7 @@ export class RelationFetcher {
 		const objectNodeWithOrder = OrderByHelper.appendDefaultOrderBy(
 			targetEntity,
 			objectNodeWithWhere,
-			relation.orderBy || [],
+			relation.orderBy,
 		)
 
 		return mapper.selectGrouped(targetEntity, objectNodeWithOrder, targetRelation, [
@@ -144,7 +144,7 @@ export class RelationFetcher {
 	}: FetchManyHasManyGroupsArgs): Promise<SelectGroupedObjects> {
 		const owningRelation = relationContext.type === 'manyHasManyInverse' ? relationContext.targetRelation : relationContext.relation
 		const joiningColumns = this.resolveJoiningColumns({ relationType: relationContext.type, joiningTable: owningRelation.joiningTable })
-		const defaultOrderBy = relationContext.relation.orderBy || []
+		const defaultOrderBy = relationContext.relation.orderBy
 		const objectNode = OrderByHelper.appendDefaultOrderBy(relationContext.targetEntity, field, defaultOrderBy)
 		const { targetEntity } = relationContext
 		const junctionValues = await this.fetchJunction(

package/src/mapper/update/UpdateBuilder.ts

@@ -6,6 +6,8 @@ import { PathFactory, WhereBuilder } from '../select'
 import { ColumnValue, ResolvedColumnValue, resolveGenericValue, resolveRowData } from '../ColumnValue'
 import { PredicateFactory } from '../../acl'
 import { AbortDataManipulation, DataManipulationBuilder } from '../DataManipulationBuilder'
+import { AfterUpdateEvent, BeforeUpdateEvent, EventManager } from '../EventManager'
+import { Mapper } from '../Mapper'
 
 export interface UpdateResult {
 	values: ResolvedColumnValue[]
@@ -29,7 +31,7 @@ export class UpdateBuilder implements DataManipulationBuilder {
 		private readonly schema: Model.Schema,
 		private readonly entity: Model.Entity,
 		private readonly whereBuilder: WhereBuilder,
-		private readonly uniqueWhere: Input.Where,
+		private readonly primary: Input.PrimaryValue,
 		private readonly pathFactory: PathFactory,
 		private readonly predicateFactory: PredicateFactory,
 	) {}
@@ -59,7 +61,7 @@ export class UpdateBuilder implements DataManipulationBuilder {
 		this.addOldWhere(predicate)
 	}
 
-	public async execute(db: Client): Promise<UpdateResult> {
+	public async execute(mapper: Mapper): Promise<UpdateResult> {
 		try {
 			const resolvedData = await resolveRowData<AbortDataManipulation>([...this.rowData.values()])
 			if (Object.keys(resolvedData).length === 0) {
@@ -70,12 +72,15 @@ export class UpdateBuilder implements DataManipulationBuilder {
 				this.resolver(null)
 				return { values: [], affectedRows: null, executed: false, aborted: true }
 			}
+			const oldColSuffix = '_old__'
 
 			const qb = DbUpdateBuilder.create()
 				.with('newData_', qb => {
 					qb = resolvedData.reduce(
 						(qb, value) =>
-							qb.select(expr => expr.selectValue(value.resolvedValue as DbValue, value.columnType), value.columnName),
+							qb
+								.select(expr => expr.selectValue(value.resolvedValue as DbValue, value.columnType), value.columnName)
+								.select(['root_', value.columnName], value.columnName + oldColSuffix),
 						qb,
 					)
 					const columns = new Set(resolvedData.map(it => it.columnName))
@@ -97,7 +102,9 @@ export class UpdateBuilder implements DataManipulationBuilder {
 					qb = remainingColumns.reduce((qb, columnName) => qb.select(['root_', columnName]), qb)
 
 					qb = this.whereBuilder.build(qb, this.entity, this.pathFactory.create([]), {
-						and: [this.uniqueWhere, this.oldWhere],
+						and: [{
+							[this.entity.primary]: { eq: this.primary },
+						}, this.oldWhere],
 					})
 
 					return qb
@@ -112,6 +119,7 @@ export class UpdateBuilder implements DataManipulationBuilder {
 						{},
 					),
 				)
+				.returning(...resolvedData.map(it => it.columnName + oldColSuffix))
 				.from(qb => {
 					qb = qb.from('newData_')
 					const col1 = tuple(this.entity.tableName, this.entity.primaryColumn)
@@ -121,9 +129,24 @@ export class UpdateBuilder implements DataManipulationBuilder {
 					return qb
 				})
 
-			const result = await qb.execute(db)
-			this.resolver(result)
-			return { values: resolvedData as ResolvedColumnValue[], affectedRows: result, executed: true, aborted: false }
+
+			const beforeEvent = new BeforeUpdateEvent(this.entity, resolvedData as ResolvedColumnValue[], this.primary)
+			await mapper.eventManager.fire(beforeEvent)
+
+			const result = await qb.execute(mapper.db)
+			this.resolver(result.length)
+
+			if (result.length === 1) {
+				const eventData = (resolvedData as ResolvedColumnValue[]).map(it => ({
+					...it,
+					old: result[0][it.columnName + oldColSuffix],
+				}))
+				const afterUpdateEvent = new AfterUpdateEvent(this.entity, eventData, this.primary)
+				beforeEvent.afterEvent = afterUpdateEvent
+				await mapper.eventManager.fire(afterUpdateEvent)
+			}
+
+			return { values: resolvedData as ResolvedColumnValue[], affectedRows: result.length, executed: true, aborted: false }
 		} catch (e) {
 			this.resolver(null)
 			throw e

package/src/mapper/update/UpdateBuilderFactory.ts

@@ -11,12 +11,12 @@ export class UpdateBuilderFactory {
 		private readonly predicateFactory: PredicateFactory,
 	) {}
 
-	public create(entity: Model.Entity, uniqueWhere: Input.Where): UpdateBuilder {
+	public create(entity: Model.Entity, primary: Input.PrimaryValue): UpdateBuilder {
 		return new UpdateBuilder(
 			this.schema,
 			entity,
 			this.whereBuilder,
-			uniqueWhere,
+			primary,
 			this.pathFactory,
 			this.predicateFactory,
 		)

package/src/mapper/update/Updater.ts

@@ -5,7 +5,6 @@ import { PredicateFactory } from '../../acl'
 import { UpdateBuilderFactory } from './UpdateBuilderFactory'
 import { Mapper } from '../Mapper'
 import { acceptEveryFieldVisitor } from '@contember/schema-utils'
-import { Client } from '@contember/database'
 import {
 	collectResults,
 	MutationNoResultError,
@@ -33,9 +32,7 @@ export class Updater {
 		data: Input.UpdateDataInput,
 		filter?: Input.OptionalWhere,
 	): Promise<MutationResultList> {
-		const updateBuilder = this.updateBuilderFactory.create(entity, {
-			[entity.primary]: { eq: primaryValue },
-		})
+		const updateBuilder = this.updateBuilderFactory.create(entity, primaryValue)
 
 		const predicateFields = Object.keys(data)
 		updateBuilder.addPredicates(predicateFields)
@@ -48,7 +45,7 @@ export class Updater {
 		const promises = acceptEveryFieldVisitor<Promise<ResultListNotFlatten | undefined>>(this.schema, entity, visitor)
 
 		const okResultFactory = (values: RowValues) => new MutationUpdateOk([], entity, primaryValue, data, values)
-		const mutationResultPromise = Updater.executeUpdate(updateBuilder, mapper.db, okResultFactory)
+		const mutationResultPromise = Updater.executeUpdate(updateBuilder, mapper, okResultFactory)
 		const otherPromises = Object.values(promises)
 		if (otherPromises.length === 0) {
 			return await mutationResultPromise
@@ -63,22 +60,20 @@ export class Updater {
 		primaryValue: Input.PrimaryValue,
 		builderCb: (builder: UpdateBuilder) => void,
 	): Promise<MutationResultList> {
-		const updateBuilder = this.updateBuilderFactory.create(entity, {
-			[entity.primary]: { eq: primaryValue },
-		})
+		const updateBuilder = this.updateBuilderFactory.create(entity, primaryValue)
 
 		const okResultFactory = (values: RowValues) => new MutationUpdateOk([], entity, primaryValue, {}, values)
 		builderCb(updateBuilder)
 
-		return Updater.executeUpdate(updateBuilder, mapper.db, okResultFactory)
+		return Updater.executeUpdate(updateBuilder, mapper, okResultFactory)
 	}
 
 	private static async executeUpdate(
 		updateBuilder: UpdateBuilder,
-		db: Client,
+		mapper: Mapper,
 		okResultFactory: (values: RowValues) => MutationUpdateOk,
 	): Promise<MutationResultList> {
-		const result = await updateBuilder.execute(db)
+		const result = await updateBuilder.execute(mapper)
 		if (result.aborted) {
 			return [new MutationNothingToDo([], NothingToDoReason.aborted)]
 		}

package/src/resolvers/GraphQlQueryAstFactory.ts

@@ -19,7 +19,6 @@ type NodeFilter = (node: GraphQlFieldNode, path: string[]) => boolean
 type AnyNode = ObjectNode | FieldNode
 
 export class GraphQlQueryAstFactory {
-	constructor(private readonly argumentValuesResolver: typeof getArgumentValues) {}
 
 	public create<Args = any>(info: GraphQLResolveInfo, filter?: NodeFilter): ObjectNode<Args> {
 		const node = ResolveInfoUtils.extractFieldNode(info)
@@ -53,7 +52,7 @@ export class GraphQlQueryAstFactory {
 			name,
 			alias,
 			fields,
-			this.argumentValuesResolver(field, node, info.variableValues),
+			getArgumentValues(field, node, info.variableValues),
 			field.extensions || {},
 			path,
 		)

package/src/resolvers/MutationResolver.ts

@@ -1,5 +1,7 @@
 import { Input, Model, Result, Value } from '@contember/schema'
 import {
+	AfterCommitEvent,
+	BeforeCommitEvent,
 	ConstraintType,
 	getInsertPrimary,
 	InputErrorKind,
@@ -14,7 +16,7 @@ import { ValidationResolver } from './ValidationResolver'
 import { GraphQLResolveInfo } from 'graphql'
 import { GraphQlQueryAstFactory } from './GraphQlQueryAstFactory'
 import { ImplementationException } from '../exception'
-import { Client, Connection, retryTransaction } from '@contember/database'
+import { retryTransaction } from '@contember/database'
 import { Operation, readOperationMeta } from '../schema'
 import { assertNever } from '../utils'
 import { InputPreValidator } from '../input-validation'
@@ -29,9 +31,7 @@ type TransactionOptions = { deferForeignKeyConstraints?: boolean }
 export class MutationResolver {
 	constructor(
 		private readonly schema: Model.Schema,
-		private readonly db: Client,
 		private readonly mapperFactory: MapperFactory,
-		private readonly systemVariablesSetup: (db: Client) => Promise<void>,
 		private readonly inputValidator: InputPreValidator,
 		private readonly graphqlQueryAstFactory: GraphQlQueryAstFactory,
 	) {}
@@ -60,7 +60,7 @@ export class MutationResolver {
 					: undefined,
 			}))
 
-		return this.transaction(async (mapper, trx) => {
+		return this.transaction(async mapper => {
 			if (options?.deferForeignKeyConstraints) {
 				logger.debug('MutationResolver: deferring foreign constraints')
 				await mapper.constraintHelper.setFkConstraintsDeferred()
@@ -468,25 +468,24 @@ export class MutationResolver {
 	}
 
 	private async transaction<R extends { ok: boolean }>(
-		cb: (mapper: Mapper, db: Client<Connection.TransactionLike>) => Promise<R>,
+		cb: (mapper: Mapper) => Promise<R>,
 	): Promise<R> {
 		return await retryTransaction(
 			async () => {
-				return await this.db.transaction(async trx => {
+				const [result, mapper] = await this.mapperFactory.transaction(async mapper => {
 					logger.debug('MutationResolver: Starting mutation transaction')
-					await trx.connection.query(Connection.REPEATABLE_READ)
-					await this.systemVariablesSetup(trx)
-					const mapper = this.mapperFactory(trx)
-
-					const result = await cb(mapper, trx)
+					const result = await cb(mapper)
 					if (!result.ok) {
 						logger.debug('MutationResolver: Transaction failed, rolling back', { result })
-						await trx.connection.rollback()
+						await mapper.db.connection.rollback()
 					} else {
 						logger.debug('MutationResolver: Transaction ok, committing')
 					}
-					return result
+					await mapper.eventManager.fire(new BeforeCommitEvent())
+					return [result, mapper]
 				})
+				await mapper.eventManager.fire(new AfterCommitEvent())
+				return result
 			},
 			message => logger.warn(message),
 			{