@contember/engine-actions 1.3.0-alpha.4

package/src/graphql/schema/index.ts

@@ -0,0 +1,295 @@
+import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql'
+export type Maybe<T> = T | null
+export type InputMaybe<T> = Maybe<T>
+export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] }
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> }
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> }
+export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> }
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+	ID: string
+	String: string
+	Boolean: boolean
+	Int: number
+	Float: number
+	DateTime: Date
+	Json: any
+	Uuid: String
+}
+
+export type Event = {
+	readonly __typename?: 'Event'
+	readonly createdAt: Scalars['DateTime']
+	readonly id: Scalars['Uuid']
+	readonly lastStateChange: Scalars['DateTime']
+	readonly log: Scalars['Json']
+	readonly numRetries: Scalars['Int']
+	readonly payload: Scalars['Json']
+	readonly resolvedAt?: Maybe<Scalars['DateTime']>
+	readonly stage: Scalars['String']
+	readonly state: EventState
+	readonly target: Scalars['String']
+	readonly transactionId: Scalars['Uuid']
+	readonly visibleAt?: Maybe<Scalars['DateTime']>
+}
+
+export type EventArgs = {
+	/** Max 10000 */
+	readonly limit?: InputMaybe<Scalars['Int']>
+	readonly offset?: InputMaybe<Scalars['Int']>
+}
+
+export type EventState =
+  | 'created'
+  | 'failed'
+  | 'processing'
+  | 'retrying'
+  | 'stopped'
+  | 'succeed'
+
+export type Mutation = {
+	readonly __typename?: 'Mutation'
+	readonly processBatch: ProcessBatchResponse
+	readonly setVariables: SetVariablesResponse
+}
+
+
+export type MutationSetVariablesArgs = {
+	args: SetVariablesArgs
+}
+
+export type ProcessBatchResponse = {
+	readonly __typename?: 'ProcessBatchResponse'
+	readonly ok: Scalars['Boolean']
+}
+
+export type Query = {
+	readonly __typename?: 'Query'
+	readonly eventsInProcessing: ReadonlyArray<Event>
+	readonly eventsToProcess: ReadonlyArray<Event>
+	readonly failedEvents: ReadonlyArray<Event>
+	readonly variables: ReadonlyArray<Variable>
+}
+
+
+export type QueryEventsInProcessingArgs = {
+	args?: InputMaybe<EventArgs>
+}
+
+
+export type QueryEventsToProcessArgs = {
+	args?: InputMaybe<EventArgs>
+}
+
+
+export type QueryFailedEventsArgs = {
+	args?: InputMaybe<EventArgs>
+}
+
+export type SetVariablesArgs = {
+	readonly mode?: InputMaybe<SetVariablesMode>
+	readonly variables: ReadonlyArray<VariableInput>
+}
+
+/**
+ * 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
+ */
+export type SetVariablesMode =
+  | 'APPEND_ONLY_MISSING'
+  | 'MERGE'
+  | 'SET'
+
+export type SetVariablesResponse = {
+	readonly __typename?: 'SetVariablesResponse'
+	readonly ok: Scalars['Boolean']
+}
+
+export type Variable = {
+	readonly __typename?: 'Variable'
+	readonly name: Scalars['String']
+	readonly value: Scalars['String']
+}
+
+export type VariableInput = {
+	readonly name: Scalars['String']
+	readonly value: Scalars['String']
+}
+
+
+
+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 ResolverFn<TResult, TParent, TContext, TArgs> = (
+	parent: TParent,
+	args: TArgs,
+	context: TContext,
+	info: GraphQLResolveInfo
+) => Promise<TResult> | TResult
+
+export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
+	parent: TParent,
+	args: TArgs,
+	context: TContext,
+	info: GraphQLResolveInfo
+) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>
+
+export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
+	parent: TParent,
+	args: TArgs,
+	context: TContext,
+	info: GraphQLResolveInfo
+) => TResult | Promise<TResult>
+
+export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
+	subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>
+	resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>
+}
+
+export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
+	subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>
+	resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>
+}
+
+export type SubscriptionObject<TResult, TKey extends string, 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>
+
+export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
+	parent: TParent,
+	context: TContext,
+	info: GraphQLResolveInfo
+) => Maybe<TTypes> | Promise<Maybe<TTypes>>
+
+export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>
+
+export type NextResolverFn<T> = () => Promise<T>
+
+export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
+	next: NextResolverFn<TResult>,
+	parent: TParent,
+	args: TArgs,
+	context: TContext,
+	info: GraphQLResolveInfo
+) => TResult | Promise<TResult>
+
+/** Mapping between all available schema types and the resolvers types */
+export type ResolversTypes = {
+	Boolean: ResolverTypeWrapper<Scalars['Boolean']>
+	DateTime: ResolverTypeWrapper<Scalars['DateTime']>
+	Event: ResolverTypeWrapper<Event>
+	EventArgs: EventArgs
+	EventState: EventState
+	Int: ResolverTypeWrapper<Scalars['Int']>
+	Json: ResolverTypeWrapper<Scalars['Json']>
+	Mutation: ResolverTypeWrapper<{}>
+	ProcessBatchResponse: ResolverTypeWrapper<ProcessBatchResponse>
+	Query: ResolverTypeWrapper<{}>
+	SetVariablesArgs: SetVariablesArgs
+	SetVariablesMode: SetVariablesMode
+	SetVariablesResponse: ResolverTypeWrapper<SetVariablesResponse>
+	String: ResolverTypeWrapper<Scalars['String']>
+	Uuid: ResolverTypeWrapper<Scalars['Uuid']>
+	Variable: ResolverTypeWrapper<Variable>
+	VariableInput: VariableInput
+}
+
+/** Mapping between all available schema types and the resolvers parents */
+export type ResolversParentTypes = {
+	Boolean: Scalars['Boolean']
+	DateTime: Scalars['DateTime']
+	Event: Event
+	EventArgs: EventArgs
+	Int: Scalars['Int']
+	Json: Scalars['Json']
+	Mutation: {}
+	ProcessBatchResponse: ProcessBatchResponse
+	Query: {}
+	SetVariablesArgs: SetVariablesArgs
+	SetVariablesResponse: SetVariablesResponse
+	String: Scalars['String']
+	Uuid: Scalars['Uuid']
+	Variable: Variable
+	VariableInput: VariableInput
+}
+
+export interface DateTimeScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['DateTime'], any> {
+	name: 'DateTime'
+}
+
+export type EventResolvers<ContextType = any, ParentType extends ResolversParentTypes['Event'] = ResolversParentTypes['Event']> = {
+	createdAt?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>
+	id?: Resolver<ResolversTypes['Uuid'], ParentType, ContextType>
+	lastStateChange?: Resolver<ResolversTypes['DateTime'], ParentType, ContextType>
+	log?: Resolver<ResolversTypes['Json'], ParentType, ContextType>
+	numRetries?: Resolver<ResolversTypes['Int'], ParentType, ContextType>
+	payload?: Resolver<ResolversTypes['Json'], ParentType, ContextType>
+	resolvedAt?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>
+	stage?: Resolver<ResolversTypes['String'], ParentType, ContextType>
+	state?: Resolver<ResolversTypes['EventState'], ParentType, ContextType>
+	target?: Resolver<ResolversTypes['String'], ParentType, ContextType>
+	transactionId?: Resolver<ResolversTypes['Uuid'], ParentType, ContextType>
+	visibleAt?: Resolver<Maybe<ResolversTypes['DateTime']>, ParentType, ContextType>
+	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
+}
+
+export interface JsonScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Json'], any> {
+	name: 'Json'
+}
+
+export type MutationResolvers<ContextType = any, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = {
+	processBatch?: Resolver<ResolversTypes['ProcessBatchResponse'], ParentType, ContextType>
+	setVariables?: Resolver<ResolversTypes['SetVariablesResponse'], ParentType, ContextType, RequireFields<MutationSetVariablesArgs, 'args'>>
+}
+
+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']> = {
+	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']> = {
+	ok?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>
+	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
+}
+
+export interface UuidScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Uuid'], any> {
+	name: 'Uuid'
+}
+
+export type VariableResolvers<ContextType = any, ParentType extends ResolversParentTypes['Variable'] = ResolversParentTypes['Variable']> = {
+	name?: Resolver<ResolversTypes['String'], ParentType, ContextType>
+	value?: Resolver<ResolversTypes['String'], ParentType, ContextType>
+	__isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>
+}
+
+export type Resolvers<ContextType = any> = {
+	DateTime?: GraphQLScalarType
+	Event?: EventResolvers<ContextType>
+	Json?: GraphQLScalarType
+	Mutation?: MutationResolvers<ContextType>
+	ProcessBatchResponse?: ProcessBatchResponseResolvers<ContextType>
+	Query?: QueryResolvers<ContextType>
+	SetVariablesResponse?: SetVariablesResponseResolvers<ContextType>
+	Uuid?: GraphQLScalarType
+	Variable?: VariableResolvers<ContextType>
+}
+

package/src/index.ts

@@ -0,0 +1,88 @@
+import { Plugin } from '@contember/engine-plugins'
+import { migrationsGroup } from './migrations'
+import { ActionsExecutionContainerHookFactory } from './ActionsExecutionContainerHookFactory'
+import { ListenerStoreProvider } from './ListenerStoreProvider'
+import { MigrationGroup } from '@contember/database-migrations'
+import { MasterContainerBuilder, MasterContainerHook } from '@contember/engine-http'
+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 { EventDispatcher } from './dispatch/EventDispatcher'
+import { EventsRepository } from './dispatch/EventsRepository'
+import { TargetHandlerResolver } from './dispatch/TargetHandlerResolver'
+import { WebhookTargetHandler } from './dispatch/WebhookTargetHandler'
+import { ActionsContextResolver } from './graphql/http/ActionsContextResolver'
+import { ActionsWebsocketControllerFactory } from './graphql/http/ActionsWebsocketControllerFactory'
+import { DispatchWorkerSupervisorFactory } from './dispatch/DispatchWorkerSupervisor'
+import { ProjectDispatcherFactory } from './dispatch/ProjectDispatcher'
+import { VariablesQueryResolver } from './graphql/resolvers/query/VariablesQueryResolver'
+import { VariablesManager } from './model/VariablesManager'
+
+export {
+	TriggerListenersFactory,
+	TriggerListenersStore,
+	TriggerHandler,
+	TriggerPayloadManager,
+	TriggerIndirectChangesFetcher,
+} from './triggers'
+export { ActionsExecutionContainerHookFactory } from './ActionsExecutionContainerHookFactory'
+export { ListenerStoreProvider } from './ListenerStoreProvider'
+
+export default class ActionsPlugin implements Plugin {
+	name = 'contember/actions'
+
+	getSystemMigrations(): MigrationGroup {
+		return migrationsGroup
+	}
+
+	getExecutionContainerHook() {
+		const hookFactory = new ActionsExecutionContainerHookFactory(new ListenerStoreProvider())
+		return hookFactory.create()
+	}
+
+	getMasterContainerHook() {
+		const hook: MasterContainerHook = (builder: MasterContainerBuilder) => {
+			return builder
+				.addService('actions_variableManager', () => {
+					return new VariablesManager()
+				})
+				.addService('actions_eventDispatcher', ({ actions_variableManager }) => {
+					const eventsRepository = new EventsRepository()
+					const webhookTargetHandler = new WebhookTargetHandler()
+					const targetHandlerResolver = new TargetHandlerResolver(webhookTargetHandler)
+					return new EventDispatcher(eventsRepository, actions_variableManager, targetHandlerResolver)
+				})
+				.addService('actions_dispatchWorkerSupervisorFactory', ({ actions_eventDispatcher }) => {
+					const projectDispatcherFactory = new ProjectDispatcherFactory(actions_eventDispatcher)
+					return new DispatchWorkerSupervisorFactory(projectDispatcherFactory)
+				})
+				.setupService('application', (it, { projectContextResolver, debugMode, actions_eventDispatcher, actions_dispatchWorkerSupervisorFactory, actions_variableManager }) => {
+					const handlerFactory = new ActionsGraphQLHandlerFactory()
+					const eventsQueryResolver = new EventsQueryResolver()
+					const processBatchMutationResolver = new ProcessBatchMutationResolver(actions_eventDispatcher)
+					const variablesQueryResolver = new VariablesQueryResolver(actions_variableManager)
+					const setVariablesMutationResolver = new SetVariablesMutationResolver(actions_variableManager)
+					const resolversFactory = new ResolversFactory(
+						eventsQueryResolver,
+						processBatchMutationResolver,
+						variablesQueryResolver,
+						setVariablesMutationResolver,
+					)
+
+					const actionsContextResolver = new ActionsContextResolver(debugMode, projectContextResolver)
+					const actionsMiddlewareFactory = new ActionsApiMiddlewareFactory(actionsContextResolver, handlerFactory.create(resolversFactory))
+					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

@@ -0,0 +1,16 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+const sql = `
+    CREATE TABLE actions_variable
+    (
+        id              UUID PRIMARY KEY NOT NULL,
+        created_at      TIMESTAMPTZ      NOT NULL DEFAULT NOW(),
+        updated_at TIMESTAMPTZ      NOT NULL DEFAULT NOW(),
+        name            TEXT             NOT NULL UNIQUE,
+        value           TEXT             NOT NULL
+    )
+`
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(sql)
+}

package/src/migrations/index.ts

@@ -0,0 +1,7 @@
+import snapshot from './snapshot'
+import { MigrationGroup } from '@contember/database-migrations'
+import _20230310145000actionsvariables from './2023-03-10-145000-actions-variables'
+
+export const migrationsGroup = new MigrationGroup(snapshot, {
+	'2023-03-10-145000-actions-variables': _20230310145000actionsvariables,
+})

package/src/migrations/snapshot.ts

@@ -0,0 +1,47 @@
+import { MigrationBuilder } from '@contember/database-migrations'
+
+export default async function (builder: MigrationBuilder) {
+	builder.sql(`
+		CREATE TYPE ACTIONS_TRIGGER_STATE AS ENUM (
+			'created' ,
+			'retrying',
+			'processing',
+			'succeed',
+			'failed',
+			'stopped'
+		);
+
+		CREATE TABLE actions_event
+		(
+			id              UUID PRIMARY KEY    NOT NULL,
+			transaction_id  UUID                NOT NULL,
+			created_at      TIMESTAMPTZ         NOT NULL DEFAULT NOW(),
+			resolved_at     TIMESTAMPTZ,
+			visible_at      TIMESTAMPTZ         NOT NULL DEFAULT NOW(),
+			num_retries     INT                 NOT NULL,
+			state           ACTIONS_TRIGGER_STATE NOT NULL DEFAULT 'created',
+			last_state_change TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+			stage_id        UUID                NOT NULL
+				REFERENCES stage
+					ON DELETE CASCADE,
+			schema_id       INTEGER             NOT NULL
+				REFERENCES schema_migration,
+			target          TEXT                NOT NULL,
+			trigger         TEXT                NOT NULL,
+			priority        INT                 NOT NULL DEFAULT 0,
+			payload         JSONB               NOT NULL,
+			log             JSONB               NOT NULL DEFAULT '[]'
+		);
+
+		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,
+        	created_at      TIMESTAMPTZ      NOT NULL DEFAULT NOW(),
+        	updated_at      TIMESTAMPTZ      NOT NULL DEFAULT NOW(),
+        	name            TEXT             NOT NULL UNIQUE,
+        	value           TEXT             NOT NULL
+    	)
+	`)
+}

package/src/model/EventsInProcessingQuery.ts

@@ -0,0 +1,21 @@
+import { DatabaseQuery, DatabaseQueryable, SelectBuilder } from '@contember/database'
+import { EventRow } from './types'
+import { EventArgs } from '../graphql/schema'
+
+export class EventsInProcessingQuery extends DatabaseQuery<EventRow[]> {
+	constructor(
+		private readonly args: EventArgs,
+	) {
+		super()
+	}
+
+	async fetch(queryable: DatabaseQueryable): Promise<EventRow[]> {
+		return SelectBuilder.create<EventRow>()
+			.from('actions_event')
+			.select('*')
+			.where(it => it.in('state', ['processing']))
+			.orderBy('last_state_change', 'asc')
+			.limit(this.args.limit ?? 100, this.args.offset ?? 0)
+			.getResult(queryable.db)
+	}
+}

package/src/model/EventsToProcessQuery.ts

@@ -0,0 +1,21 @@
+import { DatabaseQuery, DatabaseQueryable, SelectBuilder } from '@contember/database'
+import { EventRow } from './types'
+import { EventArgs } from '../graphql/schema'
+import { eventsToProcessSpecification } from './EventsToProcessSpecification'
+
+export class EventsToProcessQuery extends DatabaseQuery<EventRow[]> {
+	constructor(
+		private readonly args: EventArgs,
+	) {
+		super()
+	}
+
+	async fetch(queryable: DatabaseQueryable): Promise<EventRow[]> {
+		return SelectBuilder.create<EventRow>()
+			.from('actions_event')
+			.select('*')
+			.match(eventsToProcessSpecification)
+			.limit(this.args.limit ?? 100, this.args.offset ?? 0)
+			.getResult(queryable.db)
+	}
+}

package/src/model/EventsToProcessSpecification.ts

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

package/src/model/FailedEventsQuery.ts

@@ -0,0 +1,21 @@
+import { DatabaseQuery, DatabaseQueryable, SelectBuilder } from '@contember/database'
+import { EventRow } from './types'
+import { EventArgs } from '../graphql/schema'
+
+export class FailedEventsQuery extends DatabaseQuery<EventRow[]> {
+	constructor(
+		private readonly args: EventArgs,
+	) {
+		super()
+	}
+
+	async fetch(queryable: DatabaseQueryable): Promise<EventRow[]> {
+		return SelectBuilder.create<EventRow>()
+			.from('actions_event')
+			.select('*')
+			.where(it => it.in('state', ['failed', 'retrying']))
+			.orderBy('last_state_change', 'desc')
+			.limit(this.args.limit ?? 100, this.args.offset ?? 0)
+			.getResult(queryable.db)
+	}
+}

package/src/model/SetVariableCommand.ts

@@ -0,0 +1,26 @@
+import { Command } from '@contember/engine-system-api'
+import { ConflictActionType, InsertBuilder, Literal } from '@contember/database'
+
+export class SetVariableCommand implements Command<void> {
+
+	constructor(
+		private readonly name: string,
+		private readonly value: string,
+	) {
+	}
+
+	async execute({ providers, db }: Command.Args): Promise<void> {
+		await InsertBuilder.create()
+			.into('actions_variable')
+			.values({
+				id: providers.uuid(),
+				name: this.name,
+				value: this.value,
+			})
+			.onConflict(ConflictActionType.update, ['name'], {
+				value: this.value,
+				updated_at: new Literal('NOW()'),
+			})
+			.execute(db)
+	}
+}

package/src/model/VariablesManager.ts

@@ -0,0 +1,49 @@
+import { DatabaseContext } from '@contember/engine-system-api'
+import { VariablesQuery } from './VariablesQuery'
+import { SetVariablesArgs } from '../graphql/schema'
+import { DeleteBuilder } from '@contember/database'
+import { SetVariableCommand } from './SetVariableCommand'
+
+export type VariablesMap = Record<string, string>
+
+export class VariablesManager {
+	public async fetchVariables(db: DatabaseContext): Promise<VariablesMap> {
+		return Object.fromEntries((await db.queryHandler.fetch(new VariablesQuery())).map(it => [it.name, it.value]))
+	}
+
+	public async setVariables(db: DatabaseContext, args: SetVariablesArgs) {
+		return await db.transaction(async db => {
+			const current = await this.fetchVariables(db)
+			const mode = args.mode ?? 'MERGE'
+			const inputVariables = Object.fromEntries(args.variables.map(it => [it.name, it.value]))
+
+			let newVariables: VariablesMap = {}
+			switch (mode) {
+				case 'APPEND_ONLY_MISSING':
+					newVariables = { ...inputVariables, ...current }
+					break
+				case 'MERGE':
+					newVariables = { ...current, ...inputVariables }
+					break
+				case 'SET':
+					newVariables = inputVariables
+					break
+			}
+
+			const toDelete = Object.keys(current).filter(it => !(it in newVariables))
+			if (toDelete.length > 0) {
+				await DeleteBuilder.create()
+					.from('actions_variable')
+					.where(it => it.in('name', toDelete))
+					.execute(db.client)
+			}
+
+			for (const [name, value] of Object.entries(newVariables)) {
+				if (value === current[name]) {
+					continue
+				}
+				await db.commandBus.execute(new SetVariableCommand(name, value))
+			}
+		})
+	}
+}

package/src/model/VariablesQuery.ts

@@ -0,0 +1,17 @@
+import { DatabaseQuery, DatabaseQueryable, SelectBuilder } from '@contember/database'
+
+export class VariablesQuery extends DatabaseQuery<VariableRow[]> {
+	public async fetch(queryable: DatabaseQueryable): Promise<VariableRow[]> {
+		return await SelectBuilder.create<VariableRow>()
+			.from('actions_variable')
+			.getResult(queryable.db)
+	}
+}
+
+export type VariableRow = {
+	id: string
+	name: string
+	value: string
+	created_at: Date
+	updated_at: Date
+}

package/src/model/types.ts

@@ -0,0 +1,15 @@
+export type EventRow = {
+	id: string
+	transaction_id: string
+	created_at: Date
+	resolved_at: Date | null
+	visible_at: Date
+	num_retries: number
+	state: 'created' | 'retrying' | 'processing' | 'succeed' | 'failed' | 'stopped'
+	last_state_change: Date
+	stage_id: number
+	schema_id: string
+	target: string
+	payload: any
+	log: any[]
+}