@contember/engine-actions 2.1.0-alpha.3 → 2.1.0-alpha.35

package/src/graphql/resolvers/mutation/SetVariablesMutationResolver.ts

@@ -9,7 +9,6 @@ export class SetVariablesMutationResolver implements MutationResolvers<ActionsCo
 	) {
 	}
 
-
 	async setVariables(parent: unknown, { args }: MutationSetVariablesArgs, ctx: ActionsContext) {
 		await ctx.requireAccess(ActionsAuthorizationActions.VARIABLES_SET)
 

package/src/graphql/resolvers/mutation/StopEventMutationResolver.ts

@@ -0,0 +1,19 @@
+import { MutationResolvers, MutationRetryEventArgs } from '../../schema'
+import { ActionsContext } from '../ActionsContext'
+import { ActionsAuthorizationActions } from '../../../authorization'
+import { EventsRepository } from '../../../dispatch/EventsRepository'
+
+export class StopEventMutationResolver implements MutationResolvers<ActionsContext> {
+	constructor(
+		private readonly eventsRepository: EventsRepository,
+	) {
+	}
+	async stopEvent(parent: unknown, args: MutationRetryEventArgs, ctx: ActionsContext) {
+		await ctx.requireAccess(ActionsAuthorizationActions.EVENTS_STOP)
+
+		await this.eventsRepository.markStopped(ctx.db.client, [args.id])
+		return {
+			ok: true,
+		}
+	}
+}

package/src/graphql/resolvers/mutation/index.ts

@@ -1,2 +1,4 @@
 export * from './ProcessBatchMutationResolver'
 export * from './SetVariablesMutationResolver'
+export * from './RetryEventMutationResolver'
+export * from './StopEventMutationResolver'

package/src/graphql/resolvers/query/EventsQueryResolver.ts

@@ -1,10 +1,4 @@
-import {
-	Event,
-	QueryEventsInProcessingArgs,
-	QueryEventsToProcessArgs,
-	QueryFailedEventsArgs,
-	QueryResolvers,
-} from '../../schema'
+import { Event, QueryEventsInProcessingArgs, QueryEventsToProcessArgs, QueryFailedEventsArgs, QueryResolvers } from '../../schema'
 import { ActionsContext } from '../ActionsContext'
 import { EventsToProcessQuery } from '../../../model/EventsToProcessQuery'
 import { EventRow } from '../../../model/types'
@@ -13,6 +7,7 @@ import { Client, DatabaseQuery } from '@contember/database'
 import { EventsInProcessingQuery } from '../../../model/EventsInProcessingQuery'
 import { FailedEventsQuery } from '../../../model/FailedEventsQuery'
 import { ActionsAuthorizationActions } from '../../../authorization'
+import { EventByIdQuery } from '../../../model/EventByIdQuery'
 
 export class EventsQueryResolver implements QueryResolvers<ActionsContext> {
 	async eventsInProcessing(parent: unknown, { args }: QueryEventsInProcessingArgs, ctx: ActionsContext) {
@@ -33,6 +28,16 @@ export class EventsQueryResolver implements QueryResolvers<ActionsContext> {
 		return await this.fetchEvents(ctx.db, new FailedEventsQuery(args ?? {}))
 	}
 
+	async event(parent: unknown, { id }: { id: string }, ctx: ActionsContext): Promise<Event | null> {
+		await ctx.requireAccess(ActionsAuthorizationActions.EVENTS_VIEW)
+		const stages = await this.fetchStagesMap(ctx.db)
+		const result = await ctx.db.queryHandler.fetch(new EventByIdQuery(id))
+		if (!result) {
+			return null
+		}
+		return this.mapEventRows([result], stages)[0]
+	}
+
 	private async fetchEvents(db: DatabaseContext, query: DatabaseQuery<EventRow[]>) {
 		const stages = await this.fetchStagesMap(db)
 		return this.mapEventRows(await db.queryHandler.fetch(query), stages)
@@ -43,7 +48,6 @@ export class EventsQueryResolver implements QueryResolvers<ActionsContext> {
 	}
 
 	private mapEventRows(rows: EventRow[], stagesMap: Record<string, string>): Event[] {
-
 		return rows.map(row => ({
 			id: row.id,
 			createdAt: row.created_at,
@@ -57,6 +61,9 @@ export class EventsQueryResolver implements QueryResolvers<ActionsContext> {
 			state: row.state,
 			target: row.target,
 			transactionId: row.transaction_id,
+			identityId: row.identity_id ?? undefined,
+			ipAddress: row.ip_address ?? undefined,
+			userAgent: row.user_agent ?? undefined,
 		}))
 	}
 }

package/src/graphql/resolvers/query/VariablesQueryResolver.ts

@@ -4,7 +4,6 @@ import { VariablesManager } from '../../../model/VariablesManager'
 import { ActionsAuthorizationActions } from '../../../authorization'
 
 export class VariablesQueryResolver implements QueryResolvers<ActionsContext> {
-
 	constructor(
 		private readonly variablesManager: VariablesManager,
 	) {

package/src/graphql/schema/actions.graphql.ts

@@ -15,11 +15,14 @@ export const schema: DocumentNode = gql`
         failedEvents(args: EventArgs): [Event!]!
         eventsToProcess(args: EventArgs): [Event!]!
         eventsInProcessing(args: EventArgs): [Event!]!
+        event(id: Uuid!): Event
         variables: [Variable!]!
     }
 
     type Mutation {
         processBatch: ProcessBatchResponse!
+        retryEvent(id: Uuid!): RetryEventResponse!
+        stopEvent(id: Uuid!): StopEventResponse!
         setVariables(args: SetVariablesArgs!): SetVariablesResponse!
     }
 
@@ -32,6 +35,9 @@ export const schema: DocumentNode = gql`
     type Event {
         id: Uuid!
         transactionId: Uuid!
+        identityId: Uuid
+        ipAddress: String
+        userAgent: String
         createdAt: DateTime!
         lastStateChange: DateTime!
         resolvedAt: DateTime
@@ -57,16 +63,24 @@ export const schema: DocumentNode = gql`
         ok: Boolean!
     }
 
+    type RetryEventResponse {
+        ok: Boolean!
+    }
+
+    type StopEventResponse {
+        ok: Boolean!
+    }
+
     input SetVariablesArgs {
         variables: [VariableInput!]!
         mode: SetVariablesMode
     }
-	
+
 	"""
-	Defines how it handles original variables. 
+	Defines how it handles original variables.
 	- MERGE merges with new values (default behaviour)
 	- SET replaces all variables
-	- APPEND_ONLY_MISSING appends values if not already exist 
+	- APPEND_ONLY_MISSING appends values if not already exist
 	"""
 	enum SetVariablesMode {
 		MERGE
@@ -78,7 +92,7 @@ export const schema: DocumentNode = gql`
         name: String!
         value: String!
     }
-	
+
 	type SetVariablesResponse {
 		ok: Boolean!
 	}

package/src/graphql/schema/index.ts

@@ -16,13 +16,15 @@ export type Scalars = {
 	Float: { input: number; output: number }
 	DateTime: { input: Date; output: Date }
 	Json: { input: any; output: any }
-	Uuid: { input: String; output: String }
+	Uuid: { input: string; output: string }
 }
 
 export type Event = {
 	readonly __typename?: 'Event'
 	readonly createdAt: Scalars['DateTime']['output']
 	readonly id: Scalars['Uuid']['output']
+	readonly identityId?: Maybe<Scalars['Uuid']['output']>
+	readonly ipAddress?: Maybe<Scalars['String']['output']>
 	readonly lastStateChange: Scalars['DateTime']['output']
 	readonly log: Scalars['Json']['output']
 	readonly numRetries: Scalars['Int']['output']
@@ -32,6 +34,7 @@ export type Event = {
 	readonly state: EventState
 	readonly target: Scalars['String']['output']
 	readonly transactionId: Scalars['Uuid']['output']
+	readonly userAgent?: Maybe<Scalars['String']['output']>
 	readonly visibleAt?: Maybe<Scalars['DateTime']['output']>
 }
 
@@ -42,24 +45,33 @@ export type EventArgs = {
 }
 
 export type EventState =
-  | 'created'
-  | 'failed'
-  | 'processing'
-  | 'retrying'
-  | 'stopped'
-  | 'succeed'
+	| 'created'
+	| 'failed'
+	| 'processing'
+	| 'retrying'
+	| 'stopped'
+	| 'succeed'
 
 export type Mutation = {
 	readonly __typename?: 'Mutation'
 	readonly processBatch: ProcessBatchResponse
+	readonly retryEvent: RetryEventResponse
 	readonly setVariables: SetVariablesResponse
+	readonly stopEvent: StopEventResponse
 }
 
+export type MutationRetryEventArgs = {
+	id: Scalars['Uuid']['input']
+}
 
 export type MutationSetVariablesArgs = {
 	args: SetVariablesArgs
 }
 
+export type MutationStopEventArgs = {
+	id: Scalars['Uuid']['input']
+}
+
 export type ProcessBatchResponse = {
 	readonly __typename?: 'ProcessBatchResponse'
 	readonly ok: Scalars['Boolean']['output']
@@ -67,27 +79,34 @@ export type ProcessBatchResponse = {
 
 export type Query = {
 	readonly __typename?: 'Query'
+	readonly event?: Maybe<Event>
 	readonly eventsInProcessing: ReadonlyArray<Event>
 	readonly eventsToProcess: ReadonlyArray<Event>
 	readonly failedEvents: ReadonlyArray<Event>
 	readonly variables: ReadonlyArray<Variable>
 }
 
+export type QueryEventArgs = {
+	id: Scalars['Uuid']['input']
+}
 
 export type QueryEventsInProcessingArgs = {
 	args?: InputMaybe<EventArgs>
 }
 
-
 export type QueryEventsToProcessArgs = {
 	args?: InputMaybe<EventArgs>
 }
 
-
 export type QueryFailedEventsArgs = {
 	args?: InputMaybe<EventArgs>
 }
 
+export type RetryEventResponse = {
+	readonly __typename?: 'RetryEventResponse'
+	readonly ok: Scalars['Boolean']['output']
+}
+
 export type SetVariablesArgs = {
 	readonly mode?: InputMaybe<SetVariablesMode>
 	readonly variables: ReadonlyArray<VariableInput>
@@ -100,15 +119,20 @@ export type SetVariablesArgs = {
  * - APPEND_ONLY_MISSING appends values if not already exist
  */
 export type SetVariablesMode =
-  | 'APPEND_ONLY_MISSING'
-  | 'MERGE'
-  | 'SET'
+	| 'APPEND_ONLY_MISSING'
+	| 'MERGE'
+	| 'SET'
 
 export type SetVariablesResponse = {
 	readonly __typename?: 'SetVariablesResponse'
 	readonly ok: Scalars['Boolean']['output']
 }
 
+export type StopEventResponse = {
+	readonly __typename?: 'StopEventResponse'
+	readonly ok: Scalars['Boolean']['output']
+}
+
 export type Variable = {
 	readonly __typename?: 'Variable'
 	readonly name: Scalars['String']['output']
@@ -120,35 +144,34 @@ export type VariableInput = {
 	readonly value: Scalars['String']['input']
 }
 
-
-
 export type ResolverTypeWrapper<T> = Promise<T> | T
 
-
 export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
 	resolve: ResolverFn<TResult, TParent, TContext, TArgs>
 }
-export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>
+export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> =
+	| ResolverFn<TResult, TParent, TContext, TArgs>
+	| ResolverWithResolve<TResult, TParent, TContext, TArgs>
 
 export type ResolverFn<TResult, TParent, TContext, TArgs> = (
 	parent: TParent,
 	args: TArgs,
 	context: TContext,
-	info: GraphQLResolveInfo
+	info: GraphQLResolveInfo,
 ) => Promise<TResult> | TResult
 
 export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
 	parent: TParent,
 	args: TArgs,
 	context: TContext,
-	info: GraphQLResolveInfo
+	info: GraphQLResolveInfo,
 ) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>
 
 export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
 	parent: TParent,
 	args: TArgs,
 	context: TContext,
-	info: GraphQLResolveInfo
+	info: GraphQLResolveInfo,
 ) => TResult | Promise<TResult>
 
 export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
@@ -162,17 +185,17 @@ export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
 }
 
 export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
-  | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
-  | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>
+	| SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
+	| SubscriptionResolverObject<TResult, TParent, TContext, TArgs>
 
 export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
-  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
-  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>
+	| ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
+	| SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>
 
 export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
 	parent: TParent,
 	context: TContext,
-	info: GraphQLResolveInfo
+	info: GraphQLResolveInfo,
 ) => Maybe<TTypes> | Promise<Maybe<TTypes>>
 
 export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>
@@ -184,11 +207,9 @@ export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs
 	parent: TParent,
 	args: TArgs,
 	context: TContext,
-	info: GraphQLResolveInfo
+	info: GraphQLResolveInfo,
 ) => TResult | Promise<TResult>
 
-
-
 /** Mapping between all available schema types and the resolvers types */
 export type ResolversTypes = {
 	Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>
@@ -201,9 +222,11 @@ export type ResolversTypes = {
 	Mutation: ResolverTypeWrapper<{}>
 	ProcessBatchResponse: ResolverTypeWrapper<ProcessBatchResponse>
 	Query: ResolverTypeWrapper<{}>
+	RetryEventResponse: ResolverTypeWrapper<RetryEventResponse>
 	SetVariablesArgs: SetVariablesArgs
 	SetVariablesMode: SetVariablesMode
 	SetVariablesResponse: ResolverTypeWrapper<SetVariablesResponse>
+	StopEventResponse: ResolverTypeWrapper<StopEventResponse>
 	String: ResolverTypeWrapper<Scalars['String']['output']>
 	Uuid: ResolverTypeWrapper<Scalars['Uuid']['output']>
 	Variable: ResolverTypeWrapper<Variable>
@@ -221,8 +244,10 @@ export type ResolversParentTypes = {
 	Mutation: {}
 	ProcessBatchResponse: ProcessBatchResponse
 	Query: {}
+	RetryEventResponse: RetryEventResponse
 	SetVariablesArgs: SetVariablesArgs
 	SetVariablesResponse: SetVariablesResponse
+	StopEventResponse: StopEventResponse
 	String: Scalars['String']['output']
 	Uuid: Scalars['Uuid']['output']
 	Variable: Variable
@@ -236,6 +261,8 @@ export interface DateTimeScalarConfig extends GraphQLScalarTypeConfig<ResolversT
 export type EventResolvers<ContextType = any, ParentType extends ResolversParentTypes['Event'] = ResolversParentTypes['Event']> = {
 	createdAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>
 	id?: Resolver<ResolversTypes['Uuid'], ParentType, ContextType>
+	identityId?: Resolver<Maybe<ResolversTypes['Uuid']>, ParentType, ContextType>
+	ipAddress?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
 	lastStateChange?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>
 	log?: Resolver<ResolversTypes['Json'], ParentType, ContextType>
 	numRetries?: Resolver<ResolversTypes['Int'], ParentType, ContextType>
@@ -245,6 +272,7 @@ export type EventResolvers<ContextType = any, ParentType extends ResolversParent
 	state?: Resolver<ResolversTypes['EventState'], ParentType, ContextType>
 	target?: Resolver<ResolversTypes['String'], ParentType, ContextType>
 	transactionId?: Resolver<ResolversTypes['Uuid'], ParentType, ContextType>
+	userAgent?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>
 	visibleAt?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>
 	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
@@ -255,22 +283,47 @@ export interface JsonScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes
 
 export type MutationResolvers<ContextType = any, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = {
 	processBatch?: Resolver<ResolversTypes['ProcessBatchResponse'], ParentType, ContextType>
+	retryEvent?: Resolver<ResolversTypes['RetryEventResponse'], ParentType, ContextType, RequireFields<MutationRetryEventArgs, 'id'>>
 	setVariables?: Resolver<ResolversTypes['SetVariablesResponse'], ParentType, ContextType, RequireFields<MutationSetVariablesArgs, 'args'>>
+	stopEvent?: Resolver<ResolversTypes['StopEventResponse'], ParentType, ContextType, RequireFields<MutationStopEventArgs, 'id'>>
 }
 
-export type ProcessBatchResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['ProcessBatchResponse'] = ResolversParentTypes['ProcessBatchResponse']> = {
+export type ProcessBatchResponseResolvers<
+	ContextType = any,
+	ParentType extends ResolversParentTypes['ProcessBatchResponse'] = ResolversParentTypes['ProcessBatchResponse'],
+> = {
 	ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
 	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
 
 export type QueryResolvers<ContextType = any, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = {
+	event?: Resolver<Maybe<ResolversTypes['Event']>, ParentType, ContextType, RequireFields<QueryEventArgs, 'id'>>
 	eventsInProcessing?: Resolver<ReadonlyArray<ResolversTypes['Event']>, ParentType, ContextType, Partial<QueryEventsInProcessingArgs>>
 	eventsToProcess?: Resolver<ReadonlyArray<ResolversTypes['Event']>, ParentType, ContextType, Partial<QueryEventsToProcessArgs>>
 	failedEvents?: Resolver<ReadonlyArray<ResolversTypes['Event']>, ParentType, ContextType, Partial<QueryFailedEventsArgs>>
 	variables?: Resolver<ReadonlyArray<ResolversTypes['Variable']>, ParentType, ContextType>
 }
 
-export type SetVariablesResponseResolvers<ContextType = any, ParentType extends ResolversParentTypes['SetVariablesResponse'] = ResolversParentTypes['SetVariablesResponse']> = {
+export type RetryEventResponseResolvers<
+	ContextType = any,
+	ParentType extends ResolversParentTypes['RetryEventResponse'] = ResolversParentTypes['RetryEventResponse'],
+> = {
+	ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
+	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
+}
+
+export type SetVariablesResponseResolvers<
+	ContextType = any,
+	ParentType extends ResolversParentTypes['SetVariablesResponse'] = ResolversParentTypes['SetVariablesResponse'],
+> = {
+	ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
+	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
+}
+
+export type StopEventResponseResolvers<
+	ContextType = any,
+	ParentType extends ResolversParentTypes['StopEventResponse'] = ResolversParentTypes['StopEventResponse'],
+> = {
 	ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
 	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
 }
@@ -292,8 +345,9 @@ export type Resolvers<ContextType = any> = {
 	Mutation?: MutationResolvers<ContextType>
 	ProcessBatchResponse?: ProcessBatchResponseResolvers<ContextType>
 	Query?: QueryResolvers<ContextType>
+	RetryEventResponse?: RetryEventResponseResolvers<ContextType>
 	SetVariablesResponse?: SetVariablesResponseResolvers<ContextType>
+	StopEventResponse?: StopEventResponseResolvers<ContextType>
 	Uuid?: GraphQLScalarType
 	Variable?: VariableResolvers<ContextType>
 }
-

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'
@@ -22,13 +28,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 +50,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 +65,54 @@ 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,
-					)
+				.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())
-				})
+						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
-
 		}
 		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)
+	}
+}