@contember/engine-actions 2.1.0-beta.1 → 2.1.0-beta.2

package/package.json

@@ -49,7 +49,7 @@
     "pg": "^8.20.0"
   },
   "type": "module",
-  "version": "2.1.0-beta.1",
+  "version": "2.1.0-beta.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/contember/contember.git",

package/src/ActionsExecutionContainerHookFactory.ts

@@ -14,7 +14,10 @@ export class ActionsExecutionContainerHookFactory {
 		return builder => {
 			return builder.setupService(
 				'mapperFactory',
-				(mapperFactory, { whereBuilder, schema, pathFactory, systemSchema, providers, stage, project, schemaMeta, joinBuilder, userInfo }) => {
+				(
+					mapperFactory,
+					{ whereBuilder, schema, pathFactory, systemSchema, providers, stage, project, schemaMeta, joinBuilder, userInfo, triggeredActionsCollector },
+				) => {
 					mapperFactory.hooks.push(mapper => {
 						const triggerPayloadPersister = new TriggerPayloadPersister(
 							mapper,
@@ -25,6 +28,7 @@ export class ActionsExecutionContainerHookFactory {
 							schemaMeta.id,
 							mapper.identityId,
 							userInfo,
+							triggeredActionsCollector,
 						)
 						const triggerPayloadBuilder = new TriggerPayloadBuilder(mapper)
 						const payloadManager = new TriggerPayloadManager(triggerPayloadBuilder, triggerPayloadPersister)

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

@@ -21,6 +21,7 @@ import { WebhookTargetHandler } from './dispatch/WebhookTargetHandler'
 import { ActionsContextResolver } from './graphql/http/ActionsContextResolver'
 import { ActionsWebsocketControllerFactory } from './graphql/http/ActionsWebsocketControllerFactory'
 import { DispatchWorkerSupervisorFactory } from './dispatch/DispatchWorkerSupervisor'
+import { LazyDispatchWorker } from './dispatch/LazyDispatchWorker'
 import { ProjectDispatcherFactory } from './dispatch/ProjectDispatcher'
 import { VariablesQueryResolver } from './graphql/resolvers/query/VariablesQueryResolver'
 import { VariablesManager } from './model/VariablesManager'
@@ -108,11 +109,16 @@ export default class ActionsPlugin implements Plugin {
 						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
+				.setupService(
+					'applicationWorkers',
+					(it, { actions_dispatchWorkerSupervisorFactory, projectGroupContainer, projectGroupContainerResolver, serverConfig }) => {
+						if (!(serverConfig as any).projectGroup) {
+							it.registerWorker(this.name, actions_dispatchWorkerSupervisorFactory.create(projectGroupContainer))
+						} else {
+							it.registerWorker(this.name, new LazyDispatchWorker(projectGroupContainerResolver, actions_dispatchWorkerSupervisorFactory))
+						}
+					},
+				) as unknown as MasterContainerBuilder
 		}
 		return hook
 	}

package/src/triggers/TriggerPayloadPersister.ts

@@ -1,5 +1,5 @@
 import { Client, InsertBuilder } from '@contember/database'
-import { Mapper } from '@contember/engine-content-api'
+import { Mapper, TriggeredActionEvent, TriggeredActionsCollector } from '@contember/engine-content-api'
 import { Actions, ActionsPayload } from '@contember/schema'
 import { EventRow } from '../model/types'
 import { notify } from '../utils/notifyChannel'
@@ -20,6 +20,7 @@ export class TriggerPayloadPersister {
 		private readonly schemaId: number | undefined,
 		private readonly identityId: string,
 		private readonly userInfo: { ipAddress: string | null; userAgent: string | null },
+		private readonly triggeredActionsCollector: TriggeredActionsCollector | undefined,
 	) {
 	}
 
@@ -28,13 +29,17 @@ export class TriggerPayloadPersister {
 		if (!this.schemaId) {
 			throw new Error('Schema id is not set')
 		}
+		const collector = this.triggeredActionsCollector
 		for (let i = 0; i < payloads.length; i += chunkSize) {
 			const chunk = payloads.slice(i, i + chunkSize)
-			await InsertBuilder.create()
-				.into('actions_event')
-				.values(chunk.map((it): EventRowToInsert => ({
-					id: this.providers.uuid(),
-					transaction_id: this.mapper.transactionId,
+			const collected: TriggeredActionEvent[] | undefined = collector ? [] : undefined
+			const rows = chunk.map((it): EventRowToInsert => {
+				const id = this.providers.uuid()
+				const transactionId = this.mapper.transactionId
+				collected?.push({ id, trigger: trigger.name, target: trigger.target, transactionId })
+				return {
+					id,
+					transaction_id: transactionId,
 					created_at: 'now',
 					visible_at: 'now',
 					num_retries: 0,
@@ -50,8 +55,16 @@ export class TriggerPayloadPersister {
 					identity_id: this.identityId,
 					ip_address: this.userInfo.ipAddress,
 					user_agent: this.userInfo.userAgent,
-				})))
+				}
+			})
+			await InsertBuilder.create()
+				.into('actions_event')
+				.values(rows)
 				.execute(this.client)
+
+			if (collected && collected.length > 0) {
+				collector!.add(collected)
+			}
 		}
 
 		await notify(this.client, this.projectSlug)

package/tests/cases/unit/lazyDispatchWorker.test.ts

@@ -0,0 +1,226 @@
+import { describe, expect, test } from 'bun:test'
+import { Runnable, RunnableArgs, Running } from '@contember/engine-common'
+import { createLogger, TestLoggerHandler } from '@contember/logger'
+import { LazyDispatchWorker } from '../../../src/dispatch/LazyDispatchWorker'
+import { DispatchWorkerSupervisorFactory } from '../../../src/dispatch/DispatchWorkerSupervisor'
+import { ProjectGroupContainerResolver } from '@contember/engine-http'
+import { ProjectGroupContainer } from '@contember/engine-http'
+
+const silentLogger = createLogger(new TestLoggerHandler())
+
+const tick = () => new Promise<void>(r => setImmediate(r))
+
+const waitFor = async (cond: () => boolean, attempts = 50) => {
+	for (let i = 0; i < attempts; i++) {
+		if (cond()) return
+		await tick()
+	}
+	throw new Error('waitFor: condition not met')
+}
+
+type FakeRunnable = Runnable & {
+	id: string
+	startCount: number
+	endCount: number
+	failOnRun?: () => Error | undefined
+	emitError?: (e: any) => void
+}
+
+const createFakeSupervisor = (id: string, opts: { failOnRun?: () => Error | undefined } = {}): FakeRunnable => {
+	const fake: FakeRunnable = {
+		id,
+		startCount: 0,
+		endCount: 0,
+		failOnRun: opts.failOnRun,
+		async run(args: RunnableArgs): Promise<Running> {
+			fake.startCount++
+			const failure = fake.failOnRun?.()
+			if (failure) {
+				throw failure
+			}
+			fake.emitError = args.onError
+			return {
+				end: async () => {
+					fake.endCount++
+				},
+			}
+		},
+	}
+	return fake
+}
+
+type FakeResolver = Pick<ProjectGroupContainerResolver, 'on'> & {
+	fire: (slug: string | undefined) => (() => void) | undefined
+	listenerCount: () => number
+}
+
+const createFakeResolver = (): FakeResolver => {
+	const listeners: Array<(args: { container: ProjectGroupContainer; slug: string | undefined }) => void | (() => void)> = []
+	return {
+		on(_event, cb) {
+			listeners.push(cb as any)
+			return () => {
+				const idx = listeners.indexOf(cb as any)
+				if (idx >= 0) listeners.splice(idx, 1)
+			}
+		},
+		fire(slug) {
+			const fakeContainer = { slug } as unknown as ProjectGroupContainer
+			const cleanups = listeners.map(it => it({ container: fakeContainer, slug }))
+			return () => cleanups.forEach(it => it?.())
+		},
+		listenerCount: () => listeners.length,
+	}
+}
+
+const createFakeFactory = (registry: FakeRunnable[]): DispatchWorkerSupervisorFactory => {
+	let counter = 0
+	return {
+		create(_container: ProjectGroupContainer): any {
+			const fake = createFakeSupervisor(`fake-${counter++}`)
+			registry.push(fake)
+			return fake
+		},
+	} as any
+}
+
+const recordOnError = () => {
+	const errors: any[] = []
+	return { errors, onError: (e: any) => errors.push(e) }
+}
+
+describe('LazyDispatchWorker', () => {
+	test('does not spawn supervisor before any project group is created', async () => {
+		const resolver = createFakeResolver()
+		const supervisors: FakeRunnable[] = []
+		const worker = new LazyDispatchWorker(resolver as any, createFakeFactory(supervisors))
+		const { onError } = recordOnError()
+
+		const running = await worker.run({ logger: silentLogger, onError })
+
+		expect(supervisors).toHaveLength(0)
+		expect(resolver.listenerCount()).toBe(1)
+
+		await running.end()
+		expect(resolver.listenerCount()).toBe(0)
+	})
+
+	test('spawns supervisor when project group is created', async () => {
+		const resolver = createFakeResolver()
+		const supervisors: FakeRunnable[] = []
+		const worker = new LazyDispatchWorker(resolver as any, createFakeFactory(supervisors))
+		const { onError, errors } = recordOnError()
+
+		const running = await worker.run({ logger: silentLogger, onError })
+
+		resolver.fire('tenantA')
+		await waitFor(() => supervisors.length === 1 && supervisors[0].startCount === 1)
+
+		expect(supervisors[0].startCount).toBe(1)
+		expect(supervisors[0].endCount).toBe(0)
+		expect(errors).toHaveLength(0)
+
+		await running.end()
+		expect(supervisors[0].endCount).toBe(1)
+	})
+
+	test('spawns one supervisor per project group, isolated', async () => {
+		const resolver = createFakeResolver()
+		const supervisors: FakeRunnable[] = []
+		const worker = new LazyDispatchWorker(resolver as any, createFakeFactory(supervisors))
+		const { onError } = recordOnError()
+
+		const running = await worker.run({ logger: silentLogger, onError })
+
+		resolver.fire('tenantA')
+		resolver.fire('tenantB')
+		await waitFor(() => supervisors.length === 2 && supervisors.every(it => it.startCount === 1))
+
+		await running.end()
+		expect(supervisors.map(it => it.endCount)).toEqual([1, 1])
+	})
+
+	test('container invalidation ends only that supervisor', async () => {
+		const resolver = createFakeResolver()
+		const supervisors: FakeRunnable[] = []
+		const worker = new LazyDispatchWorker(resolver as any, createFakeFactory(supervisors))
+		const { onError } = recordOnError()
+
+		const running = await worker.run({ logger: silentLogger, onError })
+
+		const cleanupA = resolver.fire('tenantA')!
+		resolver.fire('tenantB')
+		await waitFor(() => supervisors.length === 2 && supervisors.every(it => it.startCount === 1))
+
+		cleanupA()
+		await waitFor(() => supervisors[0].endCount === 1)
+
+		expect(supervisors[0].endCount).toBe(1)
+		expect(supervisors[1].endCount).toBe(0)
+
+		await running.end()
+		expect(supervisors[1].endCount).toBe(1)
+	})
+
+	test('end() unsubscribes listener, no further supervisors are spawned', async () => {
+		const resolver = createFakeResolver()
+		const supervisors: FakeRunnable[] = []
+		const worker = new LazyDispatchWorker(resolver as any, createFakeFactory(supervisors))
+		const { onError } = recordOnError()
+
+		const running = await worker.run({ logger: silentLogger, onError })
+		expect(resolver.listenerCount()).toBe(1)
+
+		await running.end()
+		expect(resolver.listenerCount()).toBe(0)
+
+		resolver.fire('tenantLate')
+		await tick()
+		expect(supervisors).toHaveLength(0)
+	})
+
+	test('startup failure of a tenant supervisor propagates to onError once retries are exhausted', async () => {
+		const resolver = createFakeResolver()
+		const registry: FakeRunnable[] = []
+		const factory: DispatchWorkerSupervisorFactory = {
+			create(_container: ProjectGroupContainer): any {
+				const fake = createFakeSupervisor(`fake-${registry.length}`, {
+					failOnRun: () => new Error('boom'),
+				})
+				registry.push(fake)
+				return fake
+			},
+		} as any
+		const worker = new LazyDispatchWorker(resolver as any, factory, { startupMax: 0, minBackoff: 1 })
+		const { onError, errors } = recordOnError()
+
+		const running = await worker.run({ logger: silentLogger, onError })
+
+		resolver.fire('tenantBroken')
+		await waitFor(() => errors.length > 0, 200)
+
+		expect(errors[0]).toBeInstanceOf(Error)
+		expect((errors[0] as Error).message).toContain('boom')
+
+		await running.end()
+	})
+
+	test('errors after end() are swallowed', async () => {
+		const resolver = createFakeResolver()
+		const supervisors: FakeRunnable[] = []
+		const worker = new LazyDispatchWorker(resolver as any, createFakeFactory(supervisors))
+		const { onError, errors } = recordOnError()
+
+		const running = await worker.run({ logger: silentLogger, onError })
+
+		resolver.fire('tenantA')
+		await waitFor(() => supervisors.length === 1 && supervisors[0].emitError !== undefined)
+
+		await running.end()
+		expect(supervisors[0].endCount).toBe(1)
+
+		supervisors[0].emitError!(new Error('after end'))
+		await tick()
+		expect(errors).toHaveLength(0)
+	})
+})

package/vitest.config.ts

@@ -1,3 +0,0 @@
-import { defineProject } from 'vitest/config'
-
-export default defineProject({})