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

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
+    - bunx biome lint --write

package/package.json

@@ -22,32 +22,37 @@
     }
   },
   "dependencies": {
-    "@contember/authorization": "2.1.0-alpha.3",
-    "@contember/database": "2.1.0-alpha.3",
-    "@contember/database-migrations": "2.1.0-alpha.3",
-    "@contember/engine-common": "2.1.0-alpha.3",
-    "@contember/engine-content-api": "2.1.0-alpha.3",
-    "@contember/engine-http": "2.1.0-alpha.3",
-    "@contember/engine-plugins": "2.1.0-alpha.3",
-    "@contember/engine-system-api": "2.1.0-alpha.3",
-    "@contember/engine-tenant-api": "2.1.0-alpha.3",
-    "@contember/graphql-utils": "2.1.0-alpha.3",
-    "@contember/logger": "2.1.0-alpha.3",
-    "@contember/schema": "2.1.0-alpha.3",
-    "@contember/schema-utils": "2.1.0-alpha.3",
-    "@contember/typesafe": "2.1.0-alpha.3",
-    "@graphql-tools/schema": "^10.0.7",
-    "graphql-tag": "^2.12.6"
+    "@contember/authorization": "workspace:*",
+    "@contember/database": "workspace:*",
+    "@contember/database-migrations": "workspace:*",
+    "@contember/engine-common": "workspace:*",
+    "@contember/engine-content-api": "workspace:*",
+    "@contember/engine-http": "workspace:*",
+    "@contember/engine-plugins": "workspace:*",
+    "@contember/engine-system-api": "workspace:*",
+    "@contember/engine-tenant-api": "workspace:*",
+    "@contember/graphql-utils": "workspace:*",
+    "@contember/logger": "workspace:*",
+    "@contember/schema": "workspace:*",
+    "@contember/schema-utils": "workspace:*",
+    "@contember/typesafe": "workspace:*",
+    "@graphql-tools/schema": "catalog:",
+    "graphql-tag": "catalog:"
   },
   "devDependencies": {
-    "@types/bun": "^1.1.10",
-    "@types/ws": "^8.5.12",
-    "graphql": "^16.9.0"
+    "@types/bun": "catalog:",
+    "@types/ws": "catalog:",
+    "graphql": "catalog:"
   },
   "peerDependencies": {
-    "graphql": ">= 14.6.0",
-    "pg": "^8.5.0"
+    "graphql": "catalog:",
+    "pg": "catalog:"
   },
   "type": "module",
-  "version": "2.1.0-alpha.3"
+  "version": "2.1.0-alpha.35",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/contember/contember.git",
+    "directory": "packages/engine-actions"
+  }
 }

package/src/ActionsExecutionContainerHookFactory.ts

@@ -12,17 +12,29 @@ export class ActionsExecutionContainerHookFactory {
 
 	create(): ExecutionContainerHook {
 		return builder => {
-			return builder.setupService('mapperFactory', (mapperFactory, { whereBuilder, schema, pathFactory, systemSchema, providers, stage, project, schemaMeta }) => {
-				mapperFactory.hooks.push(mapper => {
-					const triggerPayloadPersister = new TriggerPayloadPersister(mapper, mapper.db.forSchema(systemSchema), providers, project.slug, stage.id, schemaMeta.id)
-					const triggerPayloadBuilder = new TriggerPayloadBuilder(mapper)
-					const payloadManager = new TriggerPayloadManager(triggerPayloadBuilder, triggerPayloadPersister)
-					const changesFetcher = new TriggerIndirectChangesFetcher(mapper, whereBuilder, pathFactory)
-					const listenersStore = this.listenerStoreProvider.getListenerStore(schema)
-					const triggerHandler = new TriggerHandler(payloadManager, listenersStore, changesFetcher)
-					triggerHandler.attach(mapper.eventManager)
-				})
-			})
+			return builder.setupService(
+				'mapperFactory',
+				(mapperFactory, { whereBuilder, schema, pathFactory, systemSchema, providers, stage, project, schemaMeta, joinBuilder, userInfo }) => {
+					mapperFactory.hooks.push(mapper => {
+						const triggerPayloadPersister = new TriggerPayloadPersister(
+							mapper,
+							mapper.db.forSchema(systemSchema),
+							providers,
+							project.slug,
+							stage.id,
+							schemaMeta.id,
+							mapper.identityId,
+							userInfo,
+						)
+						const triggerPayloadBuilder = new TriggerPayloadBuilder(mapper)
+						const payloadManager = new TriggerPayloadManager(triggerPayloadBuilder, triggerPayloadPersister)
+						const changesFetcher = new TriggerIndirectChangesFetcher(schema.model, mapper, whereBuilder, joinBuilder, pathFactory)
+						const listenersStore = this.listenerStoreProvider.getListenerStore(schema)
+						const triggerHandler = new TriggerHandler(payloadManager, listenersStore, changesFetcher)
+						triggerHandler.attach(mapper.eventManager)
+					})
+				},
+			)
 		}
 	}
 }

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/DispatchWorkerSupervisor.ts

@@ -6,7 +6,6 @@ import { Logger } from '@contember/logger'
 import { ImplementationException } from '../ImplementationException'
 
 export class DispatchWorkerSupervisorFactory {
-
 	constructor(
 		private projectDispatcherFactory: ProjectDispatcherFactory,
 	) {
@@ -74,21 +73,23 @@ export class DispatchWorkerSupervisor implements Runnable {
 				throw e
 			}
 		}
-		const projectTracker = new Supervisor(new AcquiringListener(
-			tenantContainer.databaseContext.client,
-			'project_updated',
-			async () => {
-				logger.debug('Project config change detected, reloading dispatch workers')
-				await endProjectWorkers()
-				try {
-					await startWorkers(true)
-				} catch (e) {
-					logger.error(e, { message: 'Dispatch workers reload failed, terminating' })
-					await endAll()
-					onError(e)
-				}
-			},
-		))
+		const projectTracker = new Supervisor(
+			new AcquiringListener(
+				tenantContainer.databaseContext.client,
+				'project_updated',
+				async () => {
+					logger.debug('Project config change detected, reloading dispatch workers')
+					await endProjectWorkers()
+					try {
+						await startWorkers(true)
+					} catch (e) {
+						logger.error(e, { message: 'Dispatch workers reload failed, terminating' })
+						await endAll()
+						onError(e)
+					}
+				},
+			),
+		)
 
 		const runningProjectTracker = await projectTracker.run({
 			logger,

package/src/dispatch/EventDispatcher.ts

@@ -6,7 +6,6 @@ import { ContentSchemaResolver } from '@contember/engine-http'
 import { DatabaseContext } from '@contember/engine-system-api'
 import { VariablesManager } from '../model/VariablesManager'
 
-
 type ProcessBatchArgs = {
 	db: DatabaseContext
 	contentSchemaResolver: ContentSchemaResolver
@@ -20,7 +19,6 @@ type ProcessBatchResult = {
 }
 
 export class EventDispatcher {
-
 	constructor(
 		private readonly eventsRepository: EventsRepository,
 		private readonly variablesManager: VariablesManager,

package/src/dispatch/EventsRepository.ts

@@ -1,17 +1,8 @@
-import {
-	Client,
-	Connection,
-	Literal,
-	LockModifier,
-	LockType,
-	Operator,
-	SelectBuilder,
-	UpdateBuilder,
-} from '@contember/database'
+import { Client, Connection, Literal, LockModifier, LockType, Operator, SelectBuilder, UpdateBuilder } from '@contember/database'
 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
 const DEFAULT_REPEAT_INTERVAL_MS = 5_000 // 5 seconds
@@ -19,7 +10,6 @@ const DEFAULT_MAX_ATTEMPTS = 10
 const DEFAULT_BATCH_SIZE = 1
 
 export class EventsRepository {
-
 	public async fetchBatch(actions: Actions.Schema, db: Client): Promise<FetchBatchResult> {
 		const primaryEvent = (await this.fetchInternal(db, 1))[0]
 		if (!primaryEvent) {
@@ -35,7 +25,6 @@ export class EventsRepository {
 		return { ok: true, events: [primaryEvent, ...batch], target }
 	}
 
-
 	private async fetchBackOff(db: Client): Promise<number | undefined> {
 		const result = await SelectBuilder.create<{ ms: number }>()
 			.from('actions_event')
@@ -48,20 +37,19 @@ export class EventsRepository {
 		return result.length ? Math.max(0, result[0].ms) : undefined
 	}
 
-
 	private async fetchInternal(db: Client, limit: number, targetName?: string): Promise<EventRow[]> {
 		const visibleAt = new Date()
 		visibleAt.setTime(visibleAt.getTime() + ACK_TIMEOUT_MS)
 		return await UpdateBuilder.create()
 			.table('actions_event')
-			.with('events', qb => qb
-				.select(it => it.raw('*'))
-				.from('actions_event')
-				.match(eventsToProcessSpecification)
-				.where(targetName ? { target: targetName } : {})
-				.limit(limit)
-				.lock(LockType.forNoKeyUpdate, LockModifier.skipLocked),
-			)
+			.with('events', qb =>
+				qb
+					.select(it => it.raw('*'))
+					.from('actions_event')
+					.match(eventsToProcessSpecification)
+					.where(targetName ? { target: targetName } : {})
+					.limit(limit)
+					.lock(LockType.forNoKeyUpdate, LockModifier.skipLocked))
 			.values<EventRow>({
 				state: 'processing',
 				last_state_change: new Date(),
@@ -87,15 +75,38 @@ 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,22 +125,26 @@ 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))
+		nextAttempt.setTime(
+			nextAttempt.getTime() + (event.target?.initialRepeatIntervalMs ?? DEFAULT_REPEAT_INTERVAL_MS) * Math.pow(2, event.row.num_retries),
+		)
 		await UpdateBuilder.create()
 			.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',
-					visible_at: nextAttempt,
-				} : {
-					state: 'failed',
-				}),
+				...(numRetries < (event.target?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS)
+					? {
+						state: 'retrying',
+						visible_at: nextAttempt,
+					}
+					: {
+						state: 'failed',
+					}),
 			})
 			.where({ id: event.row.id })
 			.execute(db)
@@ -138,16 +153,21 @@ export class EventsRepository {
 	private async markFailedOnUnknownTarget(db: Client, targetName: string, primaryEventId: string) {
 		await UpdateBuilder.create()
 			.table('actions_event')
-			.where(it => it.or(it => it
-				.and(it => it
-					.in('state', ['retrying', 'created', 'processing'])
-					.compare('visible_at', Operator.lte, 'now')
-					.compare('target', Operator.eq, targetName),
+			.where(it =>
+				it.or(it =>
+					it
+						.and(it =>
+							it
+								.in('state', ['retrying', 'created', 'processing'])
+								.compare('visible_at', Operator.lte, 'now')
+								.compare('target', Operator.eq, targetName)
+						)
+						.and(it =>
+							it
+								.compare('id', Operator.eq, primaryEventId)
+						)
 				)
-				.and(it => it
-					.compare('id', Operator.eq, primaryEventId),
-				),
-			))
+			)
 			.values<EventRow>({
 				// intentionally not retrying
 				last_state_change: new Date(),

package/src/dispatch/ProjectDispatcher.ts

@@ -3,8 +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 {
 	constructor(
@@ -12,13 +11,13 @@ export class ProjectDispatcherFactory {
 	) {
 	}
 
-	public create({ db, contentSchemaResolver, projectSlug }: { db: DatabaseContext; contentSchemaResolver: ContentSchemaResolver; projectSlug: string}): ProjectDispatcher {
+	public create(
+		{ db, contentSchemaResolver, projectSlug }: { db: DatabaseContext; contentSchemaResolver: ContentSchemaResolver; projectSlug: string },
+	): ProjectDispatcher {
 		return new ProjectDispatcher(this.dispatcher, db, contentSchemaResolver, projectSlug)
 	}
 }
 
-
-
 export class ProjectDispatcher implements Runnable {
 	constructor(
 		private readonly dispatcher: EventDispatcher,
@@ -29,16 +28,14 @@ export class ProjectDispatcher implements Runnable {
 	}
 
 	public async run({ logger, onError, onClose }: RunnableArgs): Promise<Running> {
-
 		return await new Promise<Running>(async (resolve, reject) => {
-
 			let resolvePending = () => {}
 			let rejectPending = (e: any) => {}
 
 			const resolvePendingRef = () => {
 				resolvePending()
 			}
-			let pendingError: any = undefined
+			let pendingError: any
 			const rejectPendingRef = (e: any) => {
 				pendingError = e
 				rejectPending(e)
@@ -112,8 +109,6 @@ export class ProjectDispatcher implements Runnable {
 			} catch (e) {
 				reject(e)
 			}
- 		})
-
-
+		})
 	}
 }

package/src/dispatch/WebhookTargetHandler.ts

@@ -1,5 +1,5 @@
 import { Actions, ActionsPayload } from '@contember/schema'
-import { EventRow, HandledEvent, InvokeHandler, InvokeHandlerArgs  } from './types'
+import { EventRow, HandledEvent, InvokeHandler, InvokeHandlerArgs } from './types'
 import { VariablesMap } from '../model/VariablesManager'
 import * as Typesafe from '@contember/typesafe'
 import { FetcherResponse, WebhookFetcher } from './WebhookFetcher'
@@ -19,7 +19,7 @@ const ResponseType = Typesafe.noExtraProps(Typesafe.object({
 	),
 }))
 
-type EventResponseFactory = (eventRow: EventRow) => ({ ok: boolean; code?: number; response?: string; errorMessage?: string; durationMs?: number })
+type EventResponseFactory = (eventRow: EventRow) => { ok: boolean; code?: number; response?: string; errorMessage?: string; durationMs?: number }
 
 export class WebhookTargetHandler implements InvokeHandler<Actions.WebhookTarget> {
 	constructor(
@@ -35,14 +35,12 @@ export class WebhookTargetHandler implements InvokeHandler<Actions.WebhookTarget
 
 		let eventResponseFactory: EventResponseFactory
 		try {
-
 			const response = await this.fetch(timeoutMs ?? DEFAULT_TIMEOUT_MS, target, variables, events)
 
 			eventResponseFactory = this.createResponseFactory({
 				response: response,
 				events,
 			})
-
 		} catch (e) {
 			logger.warn(e)
 			const errorMessages = this.extractErrorMessages(e)
@@ -73,7 +71,8 @@ export class WebhookTargetHandler implements InvokeHandler<Actions.WebhookTarget
 			})
 		}
 
-		if (response.responseText.trim() === ''
+		if (
+			response.responseText.trim() === ''
 			|| !response.headers.get('content-type')?.toLowerCase().includes('json')
 		) {
 			return () => ({
@@ -93,7 +92,7 @@ export class WebhookTargetHandler implements InvokeHandler<Actions.WebhookTarget
 			const responseData = ResponseType(parsedJson)
 			const eventsInBatch = new Set(events.map(it => it.id))
 			const failedEvents = Object.fromEntries(responseData.failures?.map(it => [it.eventId, it]) ?? [])
-			const missingEvents =  Object.keys(failedEvents).filter(it => !eventsInBatch.has(it))
+			const missingEvents = Object.keys(failedEvents).filter(it => !eventsInBatch.has(it))
 
 			if (missingEvents.length) {
 				return () => ({
@@ -140,10 +139,17 @@ export class WebhookTargetHandler implements InvokeHandler<Actions.WebhookTarget
 		})
 	}
 
-	private async doFetch(target: Actions.WebhookTarget, variables: VariablesMap, abortController: AbortController, events: EventRow[]): Promise<FetcherResponse> {
+	private async doFetch(
+		target: Actions.WebhookTarget,
+		variables: VariablesMap,
+		abortController: AbortController,
+		events: EventRow[],
+	): Promise<FetcherResponse> {
 		const resolvedUrl = this.resolveVariables(target.url, variables)
-		const resolvedHeaders = Object.fromEntries(Object.entries(target.headers ?? {})
-			.map(([key, value]) => [key, this.resolveVariables(value, variables)]))
+		const resolvedHeaders = Object.fromEntries(
+			Object.entries(target.headers ?? {})
+				.map(([key, value]) => [key, this.resolveVariables(value, variables)]),
+		)
 
 		return await this.fetcher.fetch(resolvedUrl, {
 			method: 'POST',
@@ -174,6 +180,9 @@ export class WebhookTargetHandler implements InvokeHandler<Actions.WebhookTarget
 			meta: {
 				eventId: it.id,
 				transactionId: it.transaction_id,
+				identityId: it.identity_id ?? null,
+				ipAddress: it.ip_address ?? null,
+				userAgent: it.user_agent ?? null,
 				createdAt: it.created_at.toISOString(),
 				lastStateChange: it.last_state_change.toISOString(),
 				numRetries: it.num_retries,

package/src/dispatch/types.ts

@@ -3,7 +3,7 @@ import { Actions } from '@contember/schema'
 import { EventRow } from '../model/types'
 import { VariablesMap } from '../model/VariablesManager'
 
-export { type EventRow }
+export type { EventRow }
 
 export interface InvokeHandler<Target extends Actions.AnyTarget> {
 	handle(args: InvokeHandlerArgs<Target>): Promise<HandledEvent[]>
@@ -29,4 +29,3 @@ export type InvocationResult = {
 	code?: number
 	response?: string
 }
-

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))) {
@@ -34,11 +35,12 @@ export class ActionsApiMiddlewareFactory {
 			}
 			const handler = this.actionsGraphQLHandler
 
-			await timer('GraphQL', () => handler({
-				request: koa.request,
-				response: koa.response,
-				createContext: () => graphqlContext,
-			}))
+			await timer('GraphQL', () =>
+				handler({
+					request: koa.request,
+					response: koa.response,
+					createContext: () => graphqlContext,
+				}))
 			logger.debug('Actions query finished')
 		}
 	}

package/src/graphql/http/ActionsContextResolver.ts

@@ -29,8 +29,7 @@ export class ActionsContextResolver {
 					id: authResult.identityId,
 					roles: authResult.roles,
 				},
-			),
-		)
+			))
 		logger.debug('Memberships fetched', { memberships })
 
 		if (memberships.length === 0) {

package/src/graphql/http/ActionsGraphQLHandlerFactory.ts

@@ -4,7 +4,6 @@ import { ResolversFactory } from '../resolvers/ResolversFactory'
 import { schema as graphqlDocument } from '../schema/actions.graphql'
 import { ActionsContext } from '../resolvers/ActionsContext'
 
-
 export type ActionsGraphQLHandler = GraphQLQueryHandler<ActionsContext>
 
 export class ActionsGraphQLHandlerFactory {

package/src/graphql/http/ActionsWebsocketControllerFactory.ts

@@ -55,7 +55,7 @@ export class ActionsWebsocketControllerFactory {
 			if (!authResult) {
 				throw new HttpErrorResponse(401, 'Authentication required')
 			}
-			if (!authResult.roles.some(it => it === TenantRole.SUPER_ADMIN || it  === TenantRole.PROJECT_ADMIN)) {
+			if (!authResult.roles.some(it => it === TenantRole.SUPER_ADMIN || it === TenantRole.PROJECT_ADMIN)) {
 				throw new HttpErrorResponse(403, 'Not allowed to run actions worker')
 			}
 
@@ -113,9 +113,12 @@ export class ActionsWebsocketControllerFactory {
 						const workerId = Math.random().toString().substring(2)
 						const dispatchSupervisor = this.dispatchWorkerSupervisorFactory.create(projectGroup)
 						try {
-							const running  = dispatchSupervisor.run({ logger, onError: () => {
-								send({ type: 'workerCrashed', workerId })
-							} })
+							const running = dispatchSupervisor.run({
+								logger,
+								onError: () => {
+									send({ type: 'workerCrashed', workerId })
+								},
+							})
 							workers.push({ id: workerId, running })
 							await running
 							send({ type: 'workerStarted', workerId })
@@ -144,4 +147,3 @@ export class ActionsWebsocketControllerFactory {
 		}
 	}
 }
-

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,22 +11,29 @@ export class ResolversFactory {
 		private readonly processBatchMutationResolver: ProcessBatchMutationResolver,
 		private readonly variablesQueryResolver: VariablesQueryResolver,
 		private readonly setVariablesMutationResolver: SetVariablesMutationResolver,
+		private readonly retryEventMutationResolver: RetryEventMutationResolver,
+		private readonly stopEventMutationResolver: StopEventMutationResolver,
 	) {
 	}
 
 	create(): Resolvers {
-		const resolvers: Resolvers<ActionsContext> & { Mutation: Required<Resolvers<ActionsContext>['Mutation']> } & { Query: Required<Resolvers<ActionsContext>['Query']> } = {
+		const resolvers: Resolvers<ActionsContext> & { Mutation: Required<Resolvers<ActionsContext>['Mutation']> } & {
+			Query: Required<Resolvers<ActionsContext>['Query']>
+		} = {
 			Json: JSONType,
 			DateTime: DateTimeType,
 			Uuid: UuidType,
 			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,
+		}
+	}
+}