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

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

package/package.json

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

package/src/ActionsExecutionContainerHookFactory.ts

@@ -12,17 +12,33 @@ 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, triggeredActionsCollector },
+				) => {
+					mapperFactory.hooks.push(mapper => {
+						const triggerPayloadPersister = new TriggerPayloadPersister(
+							mapper,
+							mapper.db.forSchema(systemSchema),
+							providers,
+							project.slug,
+							stage.id,
+							schemaMeta.id,
+							mapper.identityId,
+							userInfo,
+							triggeredActionsCollector,
+						)
+						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/LazyDispatchWorker.ts

@@ -0,0 +1,72 @@
+import { Runnable, RunnableArgs, Running, Supervisor, SupervisorOptions } from '@contember/engine-common'
+import { ProjectGroupContainerResolver } from '@contember/engine-http'
+import { DispatchWorkerSupervisorFactory } from './DispatchWorkerSupervisor'
+
+export class LazyDispatchWorker implements Runnable {
+	constructor(
+		private readonly projectGroupContainerResolver: ProjectGroupContainerResolver,
+		private readonly supervisorFactory: DispatchWorkerSupervisorFactory,
+		private readonly supervisorOptions: SupervisorOptions = { startupMax: 10 },
+	) {
+	}
+
+	public async run({ logger, onError }: RunnableArgs): Promise<Running> {
+		const running = new Map<string | undefined, Promise<Running | undefined>>()
+		let aborted = false
+
+		const unlisten = this.projectGroupContainerResolver.on('create', ({ container, slug }) => {
+			const groupLabel = slug ?? '<default>'
+			const childLogger = logger.child({ projectGroup: groupLabel })
+			childLogger.debug(`Starting dispatch worker for project group ${groupLabel}`)
+
+			const supervised = new Supervisor(
+				this.supervisorFactory.create(container),
+				this.supervisorOptions,
+			)
+			const runningPromise: Promise<Running | undefined> = supervised.run({
+				logger: childLogger,
+				onError: e => {
+					if (aborted) {
+						return
+					}
+					childLogger.error(e, { message: `Dispatch worker for project group ${groupLabel} crashed` })
+					onError(e)
+				},
+			}).catch(e => {
+				if (!aborted) {
+					childLogger.error(e, { message: `Failed to start dispatch worker for project group ${groupLabel}` })
+					onError(e)
+				}
+				return undefined
+			})
+			running.set(slug, runningPromise)
+
+			return () => {
+				running.delete(slug)
+				;(async () => {
+					try {
+						const r = await runningPromise
+						await r?.end()
+					} catch {
+					}
+				})()
+			}
+		})
+
+		return {
+			end: async () => {
+				aborted = true
+				unlisten()
+				const all = [...running.values()]
+				running.clear()
+				await Promise.allSettled(all.map(async p => {
+					try {
+						const r = await p
+						await r?.end()
+					} catch {
+					}
+				}))
+			},
+		}
+	}
+}

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 {