@contember/engine-actions 2.1.0-alpha.2 → 2.1.0-alpha.21

package/dist/types/utils/notifyChannel.d.ts

@@ -0,0 +1,4 @@
+import { Client } from '@contember/database';
+export declare const NOTIFY_CHANNEL_NAME = "actions_event";
+export declare const notify: (db: Client, projectSlug: string) => Promise<void>;
+//# sourceMappingURL=notifyChannel.d.ts.map

package/dist/types/utils/notifyChannel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifyChannel.d.ts","sourceRoot":"","sources":["../../../src/utils/notifyChannel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAE5C,eAAO,MAAM,mBAAmB,kBAAkB,CAAA;AAClD,eAAO,MAAM,MAAM,GAAU,IAAI,MAAM,EAAE,aAAa,MAAM,kBAE3D,CAAA"}

package/graphql.codegen.yml

@@ -10,7 +10,7 @@ generates:
       enumsAsTypes: "1"
       scalars:
         DateTime: Date
-        Uuid: String
+        Uuid: string
         Json: any
     plugins:
       - "typescript"
@@ -18,4 +18,4 @@ generates:
       - "typescript-resolvers"
 hooks:
   afterAllFileWrite:
-    - yarn run -T eslint --fix
+    - bun run eslint --fix

package/package.json

@@ -22,20 +22,20 @@
     }
   },
   "dependencies": {
-    "@contember/authorization": "2.1.0-alpha.2",
-    "@contember/database": "2.1.0-alpha.2",
-    "@contember/database-migrations": "2.1.0-alpha.2",
-    "@contember/engine-common": "2.1.0-alpha.2",
-    "@contember/engine-content-api": "2.1.0-alpha.2",
-    "@contember/engine-http": "2.1.0-alpha.2",
-    "@contember/engine-plugins": "2.1.0-alpha.2",
-    "@contember/engine-system-api": "2.1.0-alpha.2",
-    "@contember/engine-tenant-api": "2.1.0-alpha.2",
-    "@contember/graphql-utils": "2.1.0-alpha.2",
-    "@contember/logger": "2.1.0-alpha.2",
-    "@contember/schema": "2.1.0-alpha.2",
-    "@contember/schema-utils": "2.1.0-alpha.2",
-    "@contember/typesafe": "2.1.0-alpha.2",
+    "@contember/authorization": "2.1.0-alpha.21",
+    "@contember/database": "2.1.0-alpha.21",
+    "@contember/database-migrations": "2.1.0-alpha.21",
+    "@contember/engine-common": "2.1.0-alpha.21",
+    "@contember/engine-content-api": "2.1.0-alpha.21",
+    "@contember/engine-http": "2.1.0-alpha.21",
+    "@contember/engine-plugins": "2.1.0-alpha.21",
+    "@contember/engine-system-api": "2.1.0-alpha.21",
+    "@contember/engine-tenant-api": "2.1.0-alpha.21",
+    "@contember/graphql-utils": "2.1.0-alpha.21",
+    "@contember/logger": "2.1.0-alpha.21",
+    "@contember/schema": "2.1.0-alpha.21",
+    "@contember/schema-utils": "2.1.0-alpha.21",
+    "@contember/typesafe": "2.1.0-alpha.21",
     "@graphql-tools/schema": "^10.0.7",
     "graphql-tag": "^2.12.6"
   },
@@ -49,5 +49,5 @@
     "pg": "^8.5.0"
   },
   "type": "module",
-  "version": "2.1.0-alpha.2"
+  "version": "2.1.0-alpha.21"
 }

package/src/authorization/ActionsAuthorizationActions.ts

@@ -11,4 +11,6 @@ export namespace ActionsAuthorizationActions {
 
 	export const EVENTS_VIEW = Authorizator.createAction(Resources.events, 'view')
 	export const EVENTS_PROCESS = Authorizator.createAction(Resources.events, 'process')
+	export const EVENTS_RETRY = Authorizator.createAction(Resources.events, 'retry')
+	export const EVENTS_STOP = Authorizator.createAction(Resources.events, 'stop')
 }

package/src/dispatch/EventsRepository.ts

@@ -11,6 +11,7 @@ import {
 import { EventRow, HandledEvent } from './types'
 import { Actions } from '@contember/schema'
 import { eventsToProcessSpecification, eventsToProcessStateSpecification } from '../model/EventsToProcessSpecification'
+import { notify } from '../utils/notifyChannel'
 
 
 const ACK_TIMEOUT_MS = 1_000 * 60 * 10 // 10 minutes
@@ -87,15 +88,33 @@ export class EventsRepository {
 		})
 	}
 
-	public async requeue(db: Client, events: EventRow[]): Promise<void> {
+	public async requeue(db: Client, events: string[]): Promise<void> {
 		await UpdateBuilder.create()
 			.table('actions_event')
 			.values<EventRow>({
-				state: it => it.raw('CASE WHEN num_retries = 0 THEN ? ELSE ? END', 'created', 'retrying'),
+				state: it => it.raw(`
+					CASE 
+					WHEN num_retries = 0 THEN 
+						?::__SCHEMA__.actions_trigger_state 
+					ELSE 
+					?::__SCHEMA__.actions_trigger_state END
+				`, 'created', 'retrying'),
 				last_state_change: new Date(),
 				visible_at: new Date(),
 			})
-			.where(it => it.in('id', events.map(it => it.id)))
+			.where(it => it.in('id', events))
+			.execute(db)
+	}
+
+	public async markStopped(db: Client, events: string[]): Promise<void> {
+		await UpdateBuilder.create()
+			.table('actions_event')
+			.values<EventRow>({
+				state: 'stopped',
+				last_state_change: new Date(),
+				resolved_at: new Date(),
+			})
+			.where(it => it.in('id', events))
 			.execute(db)
 	}
 
@@ -114,7 +133,7 @@ export class EventsRepository {
 	}
 
 	private async markFailed(db: Client, event: HandledEvent): Promise<void> {
-		const numRetries = event.row.num_retries
+		const numRetries = event.row.num_retries + 1
 		const now = new Date()
 		const nextAttempt = new Date()
 		nextAttempt.setTime(nextAttempt.getTime() + (event.target?.initialRepeatIntervalMs ?? DEFAULT_REPEAT_INTERVAL_MS) * Math.pow(2, event.row.num_retries))
@@ -122,7 +141,7 @@ export class EventsRepository {
 			.table('actions_event')
 			.values<EventRow>({
 				last_state_change: now,
-				num_retries: event.row.num_retries + 1,
+				num_retries: numRetries,
 				log: JSON.stringify([...event.row.log, event.result]) as any,
 				...(numRetries < (event.target?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS) ? {
 					state: 'retrying',

package/src/dispatch/ProjectDispatcher.ts

@@ -3,7 +3,7 @@ import { EventDispatcher } from './EventDispatcher'
 import { ContentSchemaResolver } from '@contember/engine-http'
 import { Runnable, RunnableArgs, Running } from '@contember/engine-common'
 import { Listener } from '@contember/database'
-import { NOTIFY_CHANNEL_NAME } from '../triggers/TriggerPayloadPersister'
+import { NOTIFY_CHANNEL_NAME } from '../utils/notifyChannel'
 
 
 export class ProjectDispatcherFactory {

package/src/graphql/http/ActionsApiMiddlewareFactory.ts

@@ -25,6 +25,7 @@ export class ActionsApiMiddlewareFactory {
 			const graphqlContext: ActionsContext = {
 				db: systemDatabase,
 				logger,
+				project: projectContainer.project,
 				contentSchemaResolver: projectContainer.contentSchemaResolver,
 				requireAccess: async (action, message) => {
 					if (!(await this.authorizator.isAllowed(identity, new AuthorizationScope.Global(), action))) {

package/src/graphql/resolvers/ActionsContext.ts

@@ -7,5 +7,6 @@ export interface ActionsContext {
 	logger: Logger
 	db: DatabaseContext
 	contentSchemaResolver: ContentSchemaResolver
+	project: { slug: string }
 	requireAccess: (action: Authorizator.Action, message?: string) => Promise<void>
 }

package/src/graphql/resolvers/ResolversFactory.ts

@@ -1,7 +1,7 @@
 import { DateTimeType, JSONType, UuidType } from '@contember/graphql-utils'
 import { Resolvers } from '../schema'
 import { EventsQueryResolver } from './query'
-import { ProcessBatchMutationResolver, SetVariablesMutationResolver } from './mutation'
+import { ProcessBatchMutationResolver, RetryEventMutationResolver, SetVariablesMutationResolver, StopEventMutationResolver } from './mutation'
 import { ActionsContext } from './ActionsContext'
 import { VariablesQueryResolver } from './query/VariablesQueryResolver'
 
@@ -11,6 +11,8 @@ export class ResolversFactory {
 		private readonly processBatchMutationResolver: ProcessBatchMutationResolver,
 		private readonly variablesQueryResolver: VariablesQueryResolver,
 		private readonly setVariablesMutationResolver: SetVariablesMutationResolver,
+		private readonly retryEventMutationResolver: RetryEventMutationResolver,
+		private readonly stopEventMutationResolver: StopEventMutationResolver,
 	) {
 	}
 
@@ -22,11 +24,14 @@ export class ResolversFactory {
 			Mutation: {
 				processBatch: this.processBatchMutationResolver.processBatch.bind(this.processBatchMutationResolver),
 				setVariables: this.setVariablesMutationResolver.setVariables.bind(this.setVariablesMutationResolver),
+				retryEvent: this.retryEventMutationResolver.retryEvent.bind(this.retryEventMutationResolver),
+				stopEvent: this.stopEventMutationResolver.stopEvent.bind(this.stopEventMutationResolver),
 			},
 			Query: {
 				eventsInProcessing: this.eventsQueryResolver.eventsInProcessing.bind(this.eventsQueryResolver),
 				eventsToProcess: this.eventsQueryResolver.eventsToProcess.bind(this.eventsQueryResolver),
 				failedEvents: this.eventsQueryResolver.failedEvents.bind(this.eventsQueryResolver),
+				event: this.eventsQueryResolver.event.bind(this.eventsQueryResolver),
 				variables: this.variablesQueryResolver.variables.bind(this.variablesQueryResolver),
 			},
 		}

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

@@ -0,0 +1,22 @@
+import { MutationResolvers, MutationRetryEventArgs } from '../../schema'
+import { ActionsContext } from '../ActionsContext'
+import { ActionsAuthorizationActions } from '../../../authorization'
+import { EventsRepository } from '../../../dispatch/EventsRepository'
+import { notify } from '../../../utils/notifyChannel'
+
+export class RetryEventMutationResolver implements MutationResolvers<ActionsContext> {
+	constructor(
+		private readonly eventsRepository: EventsRepository,
+	) {
+	}
+	async retryEvent(parent: unknown, args: MutationRetryEventArgs, ctx: ActionsContext) {
+		await ctx.requireAccess(ActionsAuthorizationActions.EVENTS_RETRY)
+
+		await this.eventsRepository.requeue(ctx.db.client, [args.id])
+		await notify(ctx.db.client, ctx.project.slug)
+
+		return {
+			ok: true,
+		}
+	}
+}

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

@@ -13,6 +13,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 +34,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)

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!
     }
 
@@ -56,6 +59,14 @@ export const schema: DocumentNode = gql`
     type ProcessBatchResponse {
         ok: Boolean!
     }
+    
+    type RetryEventResponse {
+        ok: Boolean!
+    }
+    
+    type StopEventResponse {
+        ok: Boolean!
+    }
 
     input SetVariablesArgs {
         variables: [VariableInput!]!

package/src/graphql/schema/index.ts

@@ -16,7 +16,7 @@ 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 = {
@@ -52,7 +52,14 @@ export type EventState =
 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']
 }
 
 
@@ -60,6 +67,11 @@ export type MutationSetVariablesArgs = {
 	args: SetVariablesArgs
 }
 
+
+export type MutationStopEventArgs = {
+	id: Scalars['Uuid']['input']
+}
+
 export type ProcessBatchResponse = {
 	readonly __typename?: 'ProcessBatchResponse'
 	readonly ok: Scalars['Boolean']['output']
@@ -67,6 +79,7 @@ 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>
@@ -74,6 +87,11 @@ export type Query = {
 }
 
 
+export type QueryEventArgs = {
+	id: Scalars['Uuid']['input']
+}
+
+
 export type QueryEventsInProcessingArgs = {
 	args?: InputMaybe<EventArgs>
 }
@@ -88,6 +106,11 @@ 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>
@@ -109,6 +132,11 @@ export type 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']
@@ -201,9 +229,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 +251,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
@@ -255,7 +287,9 @@ 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']> = {
@@ -264,17 +298,28 @@ export type ProcessBatchResponseResolvers<ContextType = any, ParentType extends
 }
 
 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 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>
+}
+
 export interface UuidScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Uuid'], any> {
 	name: 'Uuid'
 }
@@ -292,7 +337,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,7 @@ 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'
@@ -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,7 +65,7 @@ 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 }) => {
+				.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)
@@ -74,6 +76,8 @@ export default class ActionsPlugin implements Plugin {
 						processBatchMutationResolver,
 						variablesQueryResolver,
 						setVariablesMutationResolver,
+						new RetryEventMutationResolver(actions_eventRepository),
+						new StopEventMutationResolver(actions_eventRepository),
 					)
 
 					const actionsContextResolver = new ActionsContextResolver(debugMode, projectContextResolver)

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/triggers/TriggerPayloadPersister.ts

@@ -2,8 +2,9 @@ import { Client, InsertBuilder } from '@contember/database'
 import { Mapper } from '@contember/engine-content-api'
 import { Actions, ActionsPayload } from '@contember/schema'
 import { EventRow } from '../model/types'
+import { notify } from '../utils/notifyChannel'
+
 
-export const NOTIFY_CHANNEL_NAME = 'actions_event'
 type EventRowToInsert = Omit<EventRow, 'created_at' | 'visible_at' | 'last_state_change' | 'log'> & {
 	created_at: string | Date
 	visible_at: string | Date
@@ -49,6 +50,6 @@ export class TriggerPayloadPersister {
 				.execute(this.client)
 		}
 
-		await this.client.query('SELECT pg_notify(?, ?)', [NOTIFY_CHANNEL_NAME, this.projectSlug])
+		await notify(this.client, this.projectSlug)
 	}
 }

package/src/utils/notifyChannel.ts

@@ -0,0 +1,6 @@
+import { Client } from '@contember/database'
+
+export const NOTIFY_CHANNEL_NAME = 'actions_event'
+export const notify = async (db: Client, projectSlug: string) => {
+	await db.query('SELECT pg_notify(?, ?)', [NOTIFY_CHANNEL_NAME, projectSlug])
+}