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

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,
+		}
+	}
+}

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>
 }
-