@contember/engine-actions 2.1.0-alpha.9 → 2.1.0-beta.2

package/src/index.ts

@@ -7,7 +7,13 @@ import { MasterContainerBuilder, MasterContainerHook } from '@contember/engine-h
 import { ActionsApiMiddlewareFactory } from './graphql/http/ActionsApiMiddlewareFactory'
 import { ActionsGraphQLHandlerFactory } from './graphql/http/ActionsGraphQLHandlerFactory'
 import { ResolversFactory } from './graphql/resolvers/ResolversFactory'
-import { EventsQueryResolver, ProcessBatchMutationResolver, SetVariablesMutationResolver } from './graphql/resolvers'
+import {
+	EventsQueryResolver,
+	ProcessBatchMutationResolver,
+	RetryEventMutationResolver,
+	SetVariablesMutationResolver,
+	StopEventMutationResolver,
+} from './graphql/resolvers'
 import { EventDispatcher } from './dispatch/EventDispatcher'
 import { EventsRepository } from './dispatch/EventsRepository'
 import { TargetHandlerResolver } from './dispatch/TargetHandlerResolver'
@@ -15,6 +21,7 @@ import { WebhookTargetHandler } from './dispatch/WebhookTargetHandler'
 import { ActionsContextResolver } from './graphql/http/ActionsContextResolver'
 import { ActionsWebsocketControllerFactory } from './graphql/http/ActionsWebsocketControllerFactory'
 import { DispatchWorkerSupervisorFactory } from './dispatch/DispatchWorkerSupervisor'
+import { LazyDispatchWorker } from './dispatch/LazyDispatchWorker'
 import { ProjectDispatcherFactory } from './dispatch/ProjectDispatcher'
 import { VariablesQueryResolver } from './graphql/resolvers/query/VariablesQueryResolver'
 import { VariablesManager } from './model/VariablesManager'
@@ -22,13 +29,7 @@ import { AccessEvaluator, Authorizator } from '@contember/authorization'
 import { ActionsPermissionsFactory } from './authorization'
 import { WebhookFetcherNative } from './dispatch/WebhookFetcher'
 
-export {
-	TriggerListenersFactory,
-	TriggerListenersStore,
-	TriggerHandler,
-	TriggerPayloadManager,
-	TriggerIndirectChangesFetcher,
-} from './triggers'
+export { TriggerHandler, TriggerIndirectChangesFetcher, TriggerListenersFactory, TriggerListenersStore, TriggerPayloadManager } from './triggers'
 export { ActionsExecutionContainerHookFactory } from './ActionsExecutionContainerHookFactory'
 export { ListenerStoreProvider } from './ListenerStoreProvider'
 
@@ -50,11 +51,13 @@ export default class ActionsPlugin implements Plugin {
 				.addService('actions_variableManager', () => {
 					return new VariablesManager()
 				})
-				.addService('actions_eventDispatcher', ({ actions_variableManager }) => {
-					const eventsRepository = new EventsRepository()
+				.addService('actions_eventRepository', () => {
+					return new EventsRepository()
+				})
+				.addService('actions_eventDispatcher', ({ actions_eventRepository, actions_variableManager }) => {
 					const webhookTargetHandler = new WebhookTargetHandler(new WebhookFetcherNative())
 					const targetHandlerResolver = new TargetHandlerResolver(webhookTargetHandler)
-					return new EventDispatcher(eventsRepository, actions_variableManager, targetHandlerResolver)
+					return new EventDispatcher(actions_eventRepository, actions_variableManager, targetHandlerResolver)
 				})
 				.addService('actions_dispatchWorkerSupervisorFactory', ({ actions_eventDispatcher }) => {
 					const projectDispatcherFactory = new ProjectDispatcherFactory(actions_eventDispatcher)
@@ -63,31 +66,59 @@ export default class ActionsPlugin implements Plugin {
 				.addService('actions_authorizator', () => {
 					return new Authorizator.Default(new AccessEvaluator.PermissionEvaluator(new ActionsPermissionsFactory().create()))
 				})
-				.setupService('application', (it, { projectContextResolver, debugMode, actions_eventDispatcher, actions_dispatchWorkerSupervisorFactory, actions_variableManager, actions_authorizator }) => {
-					const handlerFactory = new ActionsGraphQLHandlerFactory()
-					const eventsQueryResolver = new EventsQueryResolver()
-					const processBatchMutationResolver = new ProcessBatchMutationResolver(actions_eventDispatcher)
-					const variablesQueryResolver = new VariablesQueryResolver(actions_variableManager)
-					const setVariablesMutationResolver = new SetVariablesMutationResolver(actions_variableManager)
-					const resolversFactory = new ResolversFactory(
-						eventsQueryResolver,
-						processBatchMutationResolver,
-						variablesQueryResolver,
-						setVariablesMutationResolver,
-					)
-
-					const actionsContextResolver = new ActionsContextResolver(debugMode, projectContextResolver)
-					const actionsMiddlewareFactory = new ActionsApiMiddlewareFactory(actionsContextResolver, handlerFactory.create(resolversFactory), actions_authorizator)
-					const actionsWebsocketMiddlewareFactory = new ActionsWebsocketControllerFactory(debugMode, actionsContextResolver, actions_dispatchWorkerSupervisorFactory)
-					it.addRoute('actions', '/actions/:projectSlug', actionsMiddlewareFactory.create())
-					it.addWebsocketRoute('actions', '/actions/_worker', actionsWebsocketMiddlewareFactory.create())
-				})
-				.setupService('applicationWorkers', (it, { actions_dispatchWorkerSupervisorFactory, projectGroupContainer, serverConfig }) => {
-					if (!(serverConfig as any).projectGroup) {
-						it.registerWorker(this.name, actions_dispatchWorkerSupervisorFactory.create(projectGroupContainer))
-					}
-				}) as unknown as MasterContainerBuilder
+				.setupService(
+					'application',
+					(
+						it,
+						{
+							projectContextResolver,
+							debugMode,
+							actions_eventRepository,
+							actions_eventDispatcher,
+							actions_dispatchWorkerSupervisorFactory,
+							actions_variableManager,
+							actions_authorizator,
+						},
+					) => {
+						const handlerFactory = new ActionsGraphQLHandlerFactory()
+						const eventsQueryResolver = new EventsQueryResolver()
+						const processBatchMutationResolver = new ProcessBatchMutationResolver(actions_eventDispatcher)
+						const variablesQueryResolver = new VariablesQueryResolver(actions_variableManager)
+						const setVariablesMutationResolver = new SetVariablesMutationResolver(actions_variableManager)
+						const resolversFactory = new ResolversFactory(
+							eventsQueryResolver,
+							processBatchMutationResolver,
+							variablesQueryResolver,
+							setVariablesMutationResolver,
+							new RetryEventMutationResolver(actions_eventRepository),
+							new StopEventMutationResolver(actions_eventRepository),
+						)
 
+						const actionsContextResolver = new ActionsContextResolver(debugMode, projectContextResolver)
+						const actionsMiddlewareFactory = new ActionsApiMiddlewareFactory(
+							actionsContextResolver,
+							handlerFactory.create(resolversFactory),
+							actions_authorizator,
+						)
+						const actionsWebsocketMiddlewareFactory = new ActionsWebsocketControllerFactory(
+							debugMode,
+							actionsContextResolver,
+							actions_dispatchWorkerSupervisorFactory,
+						)
+						it.addRoute('actions', '/actions/:projectSlug', actionsMiddlewareFactory.create())
+						it.addWebsocketRoute('actions', '/actions/_worker', actionsWebsocketMiddlewareFactory.create())
+					},
+				)
+				.setupService(
+					'applicationWorkers',
+					(it, { actions_dispatchWorkerSupervisorFactory, projectGroupContainer, projectGroupContainerResolver, serverConfig }) => {
+						if (!(serverConfig as any).projectGroup) {
+							it.registerWorker(this.name, actions_dispatchWorkerSupervisorFactory.create(projectGroupContainer))
+						} else {
+							it.registerWorker(this.name, new LazyDispatchWorker(projectGroupContainerResolver, actions_dispatchWorkerSupervisorFactory))
+						}
+					},
+				) as unknown as MasterContainerBuilder
 		}
 		return hook
 	}

package/src/migrations/2023-03-10-145000-actions-variables.ts

@@ -11,6 +11,6 @@ const sql = `
     )
 `
 
-export default async function (builder: MigrationBuilder) {
+export default async function(builder: MigrationBuilder) {
 	builder.sql(sql)
 }

package/src/migrations/2025-05-28-160000-action-event-user.ts

@@ -0,0 +1,16 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
+ALTER TABLE actions_event
+ADD COLUMN IF NOT EXISTS identity_id UUID DEFAULT NULL;
+
+ALTER TABLE actions_event
+ADD COLUMN IF NOT EXISTS ip_address INET DEFAULT NULL;
+
+ALTER TABLE actions_event
+ADD COLUMN IF NOT EXISTS user_agent TEXT DEFAULT NULL;
+`
+
+export default async function(builder: MigrationBuilder) {
+	builder.sql(sql)
+}

package/src/migrations/index.ts

@@ -1,7 +1,9 @@
 import snapshot from './snapshot'
 import { MigrationGroup } from '@contember/database-migrations'
 import _20230310145000actionsvariables from './2023-03-10-145000-actions-variables'
+import _20250528160000actioneventuser from './2025-05-28-160000-action-event-user'
 
 export const migrationsGroup = new MigrationGroup(snapshot, {
 	'2023-03-10-145000-actions-variables': _20230310145000actionsvariables,
+	'2025-05-28-160000-action-event-user': _20250528160000actioneventuser,
 })

package/src/migrations/snapshot.ts

@@ -1,6 +1,6 @@
 import { MigrationBuilder } from '@contember/database-migrations'
 
-export default async function (builder: MigrationBuilder) {
+export default async function(builder: MigrationBuilder) {
 	builder.sql(`
 		CREATE TYPE ACTIONS_TRIGGER_STATE AS ENUM (
 			'created' ,
@@ -30,11 +30,14 @@ export default async function (builder: MigrationBuilder) {
 			trigger         TEXT                NOT NULL,
 			priority        INT                 NOT NULL DEFAULT 0,
 			payload         JSONB               NOT NULL,
-			log             JSONB               NOT NULL DEFAULT '[]'
+			log             JSONB               NOT NULL DEFAULT '[]',
+			identity_id     UUID                DEFAULT NULL,
+			ip_address      INET                DEFAULT NULL,
+			user_agent      TEXT                DEFAULT NULL
 		);
 
 		CREATE INDEX ON actions_event (priority DESC, visible_at) WHERE state IN ('created', 'retrying', 'processing');
-		
+
 		CREATE TABLE actions_variable
     	(
         	id              UUID PRIMARY KEY NOT NULL,

package/src/model/EventByIdQuery.ts

@@ -0,0 +1,21 @@
+import { DatabaseQuery, DatabaseQueryable, SelectBuilder } from '@contember/database'
+import { EventRow } from './types'
+
+export class EventByIdQuery extends DatabaseQuery<EventRow | null> {
+	constructor(
+		private readonly id: string,
+	) {
+		super()
+	}
+
+	async fetch(queryable: DatabaseQueryable): Promise<EventRow | null> {
+		const result = await SelectBuilder.create<EventRow>()
+			.from('actions_event')
+			.select('*')
+			.where({
+				id: this.id,
+			})
+			.getResult(queryable.db)
+		return this.fetchOneOrNull(result)
+	}
+}

package/src/model/EventsToProcessSpecification.ts

@@ -1,11 +1,12 @@
 import { Operator, SelectBuilderSpecification } from '@contember/database'
 
+export const eventsToProcessStateSpecification: SelectBuilderSpecification = qb =>
+	qb
+		.where(it => it.in('state', ['retrying', 'created', 'processing']))
 
-export const eventsToProcessStateSpecification: SelectBuilderSpecification = qb => qb
-	.where(it => it.in('state', ['retrying', 'created', 'processing']))
-
-export const eventsToProcessSpecification: SelectBuilderSpecification = qb => qb
-	.match(eventsToProcessStateSpecification)
-	.where(it => it.compare('visible_at', Operator.lte, 'now'))
-	.orderBy('priority', 'desc')
-	.orderBy('visible_at')
+export const eventsToProcessSpecification: SelectBuilderSpecification = qb =>
+	qb
+		.match(eventsToProcessStateSpecification)
+		.where(it => it.compare('visible_at', Operator.lte, 'now'))
+		.orderBy('priority', 'desc')
+		.orderBy('visible_at')

package/src/model/SetVariableCommand.ts

@@ -2,7 +2,6 @@ import { Command } from '@contember/engine-system-api'
 import { ConflictActionType, InsertBuilder, Literal } from '@contember/database'
 
 export class SetVariableCommand implements Command<void> {
-
 	constructor(
 		private readonly name: string,
 		private readonly value: string,

package/src/model/types.ts

@@ -14,6 +14,9 @@ export type EventRow = {
 	target: string
 	priority: number
 	trigger: string
+	identity_id: string | null
+	ip_address: string | null
+	user_agent: string | null
 	payload: ActionsPayload.AnyEventPayload
 	log: any[]
 }

package/src/triggers/TriggerHandler.ts

@@ -71,31 +71,30 @@ export class TriggerHandler {
 
 	private async directUpdateHandler(event: AfterUpdateEvent) {
 		const updateListeners = this.listenersStore.getUpdateListeners(event.entity.name)
-		updateListeners.map(listener => {
+		await Promise.all(updateListeners.map(listener => {
 			if (event.data.some(it => listener.fields.has(it.fieldName) && it.value !== it.old)) {
-				this.payloadManager.add({
+				return this.payloadManager.add({
 					listener,
 					entity: event.entity,
 					primary: event.id,
 					cause: event,
 				})
 			}
-		})
+		}))
 	}
 
 	private async directCreateHandler(event: AfterInsertEvent) {
 		const createListeners = this.listenersStore.getCreateListener(event.entity.name)
-		createListeners.map(listener => {
-			this.payloadManager.add({
+		await Promise.all(createListeners.map(listener => {
+			return this.payloadManager.add({
 				listener,
 				entity: event.entity,
 				primary: event.id,
 				cause: event,
 			})
-		})
+		}))
 	}
 
-
 	/**
 	 * Collect affected triggers after entity was created or before it was deleted.
 	 * todo: after insert, it should probably check only owning relations, because other relations are connected later, so it would be always empty
@@ -103,9 +102,11 @@ export class TriggerHandler {
 	private async indirectChangesEntityHandler(event: BeforeDeleteEvent | AfterInsertEvent) {
 		//
 		const indirectEntityListeners = this.listenersStore.getIndirectListeners(event.entity.name)
-		const promises =  indirectEntityListeners.map(listener => this.collectDeepChanges(event, listener, {
-			[event.entity.primary]: { eq: event.id },
-		}))
+		const promises = indirectEntityListeners.map(listener =>
+			this.collectDeepChanges(event, listener, {
+				[event.entity.primary]: { eq: event.id },
+			})
+		)
 		await Promise.all(promises)
 	}
 
@@ -142,20 +143,20 @@ export class TriggerHandler {
 		await Promise.all(promises)
 	}
 
-
 	private async collectDeepChanges(
 		cause: EventCause,
 		listener: IndirectListener | JunctionListener,
 		where: Input.Where,
 	) {
 		const result = await this.changesFetcher.fetch(listener, where)
-		for (const row of result) {
-			this.payloadManager.add({
+		await Promise.all(result.map(row => {
+			return this.payloadManager.add({
 				listener,
 				entity: listener.rootEntity,
-				primary: row,
+				primary: row.id,
 				cause,
+				nodes: row.nodes,
 			})
-		}
+		}))
 	}
 }

package/src/triggers/TriggerIndirectChangesFetcher.ts

@@ -1,12 +1,21 @@
 import { Mapper, PathFactory, WhereBuilder } from '@contember/engine-content-api'
 import { IndirectListener, JunctionListener } from './TriggerListenersStore'
 import { SelectBuilder } from '@contember/database'
-import { Input } from '@contember/schema'
+import { ActionsPayload, Input, Model, Schema } from '@contember/schema'
+import { JoinBuilder } from '@contember/engine-content-api'
+import { getTargetEntity } from '@contember/schema-utils'
+
+export type TriggerIndirectChangesFetcherResult = {
+	id: Input.PrimaryValue
+	nodes?: ActionsPayload.EntityEventPathNode[]
+}[]
 
 export class TriggerIndirectChangesFetcher {
 	constructor(
+		private readonly model: Model.Schema,
 		private readonly mapper: Mapper,
 		private readonly whereBuilder: WhereBuilder,
+		private readonly joinBuilder: JoinBuilder,
 		private readonly pathFactory: PathFactory,
 	) {
 	}
@@ -14,7 +23,11 @@ export class TriggerIndirectChangesFetcher {
 	public async fetch(
 		listener: IndirectListener | JunctionListener,
 		where: Input.Where,
-	): Promise<Input.PrimaryValue[]> {
+	): Promise<TriggerIndirectChangesFetcherResult> {
+		if (listener.trigger.withNodes) {
+			return this.fetchWithNodes(listener, where)
+		}
+
 		for (let i = listener.path.length - 1; i >= 0; i--) {
 			where = { [listener.path[i]]: where }
 		}
@@ -24,7 +37,53 @@ export class TriggerIndirectChangesFetcher {
 		const path = this.pathFactory.create([])
 		const qbWithWhere = this.whereBuilder.build(qb, listener.rootEntity, path, where)
 
-		return (await qbWithWhere.getResult(this.mapper.db)).map(it => it.id)
+		return (await qbWithWhere.getResult(this.mapper.db))
 	}
 
+	private async fetchWithNodes(
+		listener: IndirectListener | JunctionListener,
+		where: Input.Where,
+	): Promise<TriggerIndirectChangesFetcherResult> {
+		const basePath = this.pathFactory.create([])
+		let path = basePath
+		let entity = listener.rootEntity
+		let qb = SelectBuilder.create()
+			.from(entity.tableName, path.alias)
+			.select([path.alias, entity.primaryColumn], path.for(entity.primary).alias)
+
+		for (let i = 0; i < listener.path.length; i++) {
+			const relationName = listener.path[i]
+			path = path.for(relationName)
+			const targetEntity = getTargetEntity(this.model, entity, relationName)
+			if (!targetEntity) {
+				throw new Error(`Target entity for relation ${entity.name}::${relationName} not found`)
+			}
+			qb = this.joinBuilder.join(qb, path, entity, relationName)
+
+			entity = targetEntity
+			qb = qb.select([path.alias, targetEntity.primaryColumn], path.for(targetEntity.primary).alias)
+		}
+
+		const qbWithWhere = this.whereBuilder.build(qb, entity, path, where)
+
+		const result = await qbWithWhere.getResult(this.mapper.db)
+
+		return result.map(row => {
+			const nodes: ActionsPayload.EntityEventPathNode[] = []
+			let entity = listener.rootEntity
+			let path = basePath
+			const id = row[path.for(entity.primary).alias]
+			for (let i = 0; i < listener.path.length; i++) {
+				const relationName = listener.path[i]
+				const targetEntity = getTargetEntity(this.model, entity, relationName)
+				if (!targetEntity) {
+					throw new Error(`Target entity for relation ${entity.name}::${relationName} not found`)
+				}
+				path = path.for(relationName)
+				nodes.push({ relation: relationName, entity: targetEntity.name, id: row[path.for(targetEntity.primary).alias] })
+				entity = targetEntity
+			}
+			return { id, nodes }
+		})
+	}
 }

package/src/triggers/TriggerListeners.ts

@@ -1,10 +1,4 @@
-import {
-	CreateListener,
-	DeleteListener,
-	IndirectListener,
-	JunctionListener,
-	UpdateListener,
-} from './TriggerListenersStore'
+import { CreateListener, DeleteListener, IndirectListener, JunctionListener, UpdateListener } from './TriggerListenersStore'
 
 export interface TriggerListeners {
 	readonly deleteListeners: Map<string, DeleteListener[]>
@@ -13,4 +7,3 @@ export interface TriggerListeners {
 	readonly indirectListeners: Map<string, IndirectListener[]>
 	readonly junctionListeners: Map<string, Map<string, JunctionListener[]>>
 }
-

package/src/triggers/TriggerListenersBuilder.ts

@@ -6,7 +6,6 @@ import { mapGetOrPut } from '../utils/map'
 import { ImplementationException } from '../ImplementationException'
 
 export class TriggerListenerBuilder {
-
 	private readonly data: TriggerListeners = {
 		createListeners: new Map(),
 		updateListeners: new Map(),
@@ -26,7 +25,7 @@ export class TriggerListenerBuilder {
 		} else if (trigger.type === 'watch') {
 			this.processIndirectListeners(trigger)
 		} else {
-			((_: never) => {
+			;((_: never) => {
 				throw new ImplementationException(`Unhandled trigger ${(trigger as any).type}`)
 			})(trigger)
 		}
@@ -169,12 +168,10 @@ export class TriggerListenerBuilder {
 		return new TriggerListenersStore(this.data)
 	}
 
-
 	private addListener<
 		K extends Exclude<keyof TriggerListeners, 'junctionListeners'>,
-		V extends TriggerListeners[K] extends Map<string, infer V extends any[]> ? V[number] : never
-	>
-	(
+		V extends TriggerListeners[K] extends Map<string, infer V extends any[]> ? V[number] : never,
+	>(
 		type: K,
 		entityName: string,
 		value: V,

package/src/triggers/TriggerListenersStore.ts

@@ -3,7 +3,7 @@ import { TriggerListeners } from './TriggerListeners'
 
 export interface IndirectListener {
 	type: 'indirect'
-	trigger: Actions.AnyTrigger
+	trigger: Actions.WatchTrigger
 	rootEntity: Model.Entity
 	fields: Set<string>
 	relations: Set<string>
@@ -12,7 +12,7 @@ export interface IndirectListener {
 
 export interface JunctionListener {
 	type: 'junction'
-	trigger: Actions.AnyTrigger
+	trigger: Actions.WatchTrigger
 	rootEntity: Model.Entity
 	path: string[]
 	context: {

package/src/triggers/TriggerPayloadBuilder.ts

@@ -23,7 +23,10 @@ export class TriggerPayloadBuilder {
 		const selections = await this.fetchSelection(filteredEvents)
 		const triggerType = filteredEvents[0].listener.trigger.type
 		if (triggerType === 'basic') {
-			return filteredEvents.map(it => ({ trigger: it.listener.trigger.name, ...this.buildBaseEventPayloads(it, it.selection ?? selections[it.primary]) }))
+			return filteredEvents.map(it => ({
+				trigger: it.listener.trigger.name,
+				...this.buildBaseEventPayloads(it, it.selection ?? selections[it.primary]),
+			}))
 		}
 		if (triggerType === 'watch') {
 			return this.buildWatchEventPayloads(filteredEvents, selections)
@@ -35,9 +38,13 @@ export class TriggerPayloadBuilder {
 		if (event.listener.type === 'delete' && event.listener.trigger.selection) {
 			const input = this.convertSelectionNode(event.listener.trigger.selection)
 
-			const selection = await this.mapper.selectUnique(event.entity, input.withArg('by', {
-				[event.entity.primary]: event.primary,
-			}), [])
+			const selection = await this.mapper.selectUnique(
+				event.entity,
+				input.withArg('by', {
+					[event.entity.primary]: event.primary,
+				}),
+				[],
+			)
 			return { ...event, selection }
 		}
 		return event
@@ -51,6 +58,19 @@ export class TriggerPayloadBuilder {
 		}
 		const payloads: ActionsPayload.WatchEventPayload[] = []
 		for (const eventsByPrimary of Object.values(byPrimary)) {
+			const baseEvents: ActionsPayload.BaseEventPayload[] = []
+
+			const existingEvents = new Set<string>()
+			for (const event of eventsByPrimary.events) {
+				const baseEvent = this.buildBaseEventPayloads(event)
+				const stringRepresentation = JSON.stringify(baseEvent)
+				if (existingEvents.has(stringRepresentation)) {
+					continue
+				}
+				existingEvents.add(stringRepresentation)
+				baseEvents.push(baseEvent)
+			}
+
 			payloads.push({
 				operation: 'watch',
 				trigger: events[0].listener.trigger.name,
@@ -58,7 +78,7 @@ export class TriggerPayloadBuilder {
 				id: eventsByPrimary.primary,
 				selection: eventsByPrimary.events.find(it => it.selection)?.selection
 					?? selections[eventsByPrimary.primary],
-				events: eventsByPrimary.events.map(it => this.buildBaseEventPayloads(it)),
+				events: baseEvents,
 			})
 		}
 		return payloads
@@ -74,6 +94,7 @@ export class TriggerPayloadBuilder {
 					selection,
 					values: Object.fromEntries(event.cause.data.map(it => [it.fieldName, it.value])),
 					path: 'path' in event.listener ? event.listener.path : undefined,
+					nodes: event.nodes,
 				}
 			case 'AfterUpdateEvent':
 			case 'BeforeUpdateEvent':
@@ -89,6 +110,7 @@ export class TriggerPayloadBuilder {
 					values: Object.fromEntries(event.cause.data.map(it => [it.fieldName, it.value])),
 					path: 'path' in event.listener ? event.listener.path : undefined,
 					old: Object.fromEntries(afterEvent.data.map(it => [it.fieldName, it.old])),
+					nodes: event.nodes,
 				}
 			case 'BeforeDeleteEvent':
 				return {
@@ -97,6 +119,7 @@ export class TriggerPayloadBuilder {
 					id: event.cause.id,
 					selection,
 					path: 'path' in event.listener ? event.listener.path : undefined,
+					nodes: event.nodes,
 				}
 			case 'AfterJunctionUpdateEvent':
 				if (event.listener.type !== 'junction') {
@@ -112,6 +135,7 @@ export class TriggerPayloadBuilder {
 					id,
 					inverseId,
 					path: 'path' in event.listener ? event.listener.path : undefined,
+					nodes: event.nodes,
 				}
 			default:
 				assertNever(event.cause, it => it.type)
@@ -135,14 +159,20 @@ export class TriggerPayloadBuilder {
 		return await this.mapper.selectAssoc(entity, input, [], entity.primary)
 	}
 
-
 	private convertSelectionNode(node: Actions.SelectionNode, nodeName = 'root', path: string[] = []): ObjectNode<Input.ListQueryInput> {
-		return new ObjectNode(nodeName, nodeName, node.map(it => {
-			const [field, args, selection] = Array.isArray(it) ? it : [it, undefined, undefined]
-			if (selection === undefined || selection.length === 0) {
-				return new FieldNode(field, field, {})
-			}
-			return this.convertSelectionNode(selection, field, [...path, nodeName]).withArgs(args)
-		}), {}, {}, path)
+		return new ObjectNode(
+			nodeName,
+			nodeName,
+			node.map(it => {
+				const [field, args, selection] = Array.isArray(it) ? it : [it, undefined, undefined]
+				if (selection === undefined || selection.length === 0) {
+					return new FieldNode(field, field, {})
+				}
+				return this.convertSelectionNode(selection, field, [...path, nodeName]).withArgs(args)
+			}),
+			{},
+			{},
+			path,
+		)
 	}
 }

package/src/triggers/TriggerPayloadManager.ts

@@ -1,16 +1,16 @@
-import { Actions, Input, Model } from '@contember/schema'
+import { Actions, ActionsPayload, Input, Model } from '@contember/schema'
 import { AnyListener } from './TriggerListenersStore'
 import { EventCause } from './TriggerHandler'
 import { TriggerPayloadBuilder } from './TriggerPayloadBuilder'
 import { TriggerPayloadPersister } from './TriggerPayloadPersister'
 
-
 export interface FiredEvent {
 	listener: AnyListener
 	cause: EventCause
 	entity: Model.Entity
 	primary: Input.PrimaryValue
 	selection?: any
+	nodes?: ActionsPayload.EntityEventPathNode[]
 }
 
 export class TriggerPayloadManager {
@@ -28,7 +28,6 @@ export class TriggerPayloadManager {
 		this.eventsByTrigger[firedEvent.listener.trigger.name].push(event)
 	}
 
-
 	public async persist(): Promise<void> {
 		for (const events of Object.values(this.eventsByTrigger)) {
 			const payloads = await this.triggerPayloadBuilder.build(events)
@@ -37,4 +36,3 @@ export class TriggerPayloadManager {
 		}
 	}
 }
-