@contember/engine-actions 2.1.0-beta.1 → 2.2.0-alpha.1

package/src/triggers/TriggerIndirectChangesFetcher.ts

@@ -1,5 +1,5 @@
 import { Mapper, PathFactory, WhereBuilder } from '@contember/engine-content-api'
-import { IndirectListener, JunctionListener } from './TriggerListenersStore'
+import { IndirectListener, JunctionListener } from './TriggerListenersStore.js'
 import { SelectBuilder } from '@contember/database'
 import { ActionsPayload, Input, Model, Schema } from '@contember/schema'
 import { JoinBuilder } from '@contember/engine-content-api'

package/src/triggers/TriggerListeners.ts

@@ -1,4 +1,4 @@
-import { CreateListener, DeleteListener, IndirectListener, JunctionListener, UpdateListener } from './TriggerListenersStore'
+import { CreateListener, DeleteListener, IndirectListener, JunctionListener, UpdateListener } from './TriggerListenersStore.js'
 
 export interface TriggerListeners {
 	readonly deleteListeners: Map<string, DeleteListener[]>

package/src/triggers/TriggerListenersBuilder.ts

@@ -1,9 +1,9 @@
 import { Actions, Model } from '@contember/schema'
-import { TriggerListeners } from './TriggerListeners'
-import { JunctionListener, TriggerListenersStore } from './TriggerListenersStore'
+import { TriggerListeners } from './TriggerListeners.js'
+import { JunctionListener, TriggerListenersStore } from './TriggerListenersStore.js'
 import { acceptFieldVisitor, getEntity } from '@contember/schema-utils'
-import { mapGetOrPut } from '../utils/map'
-import { ImplementationException } from '../ImplementationException'
+import { mapGetOrPut } from '../utils/map.js'
+import { ImplementationException } from '../ImplementationException.js'
 
 export class TriggerListenerBuilder {
 	private readonly data: TriggerListeners = {

package/src/triggers/TriggerListenersFactory.ts

@@ -1,5 +1,5 @@
-import { TriggerListenersStore } from './TriggerListenersStore'
-import { TriggerListenerBuilder } from './TriggerListenersBuilder'
+import { TriggerListenersStore } from './TriggerListenersStore.js'
+import { TriggerListenerBuilder } from './TriggerListenersBuilder.js'
 import { Schema } from '@contember/schema'
 
 export class TriggerListenersFactory {

package/src/triggers/TriggerListenersStore.ts

@@ -1,5 +1,5 @@
 import { Actions, Model } from '@contember/schema'
-import { TriggerListeners } from './TriggerListeners'
+import { TriggerListeners } from './TriggerListeners.js'
 
 export interface IndirectListener {
 	type: 'indirect'

package/src/triggers/TriggerPayloadBuilder.ts

@@ -1,6 +1,6 @@
-import { ImplementationException } from '../ImplementationException'
-import { assertNever } from '../utils/assertNever'
-import { FiredEvent } from './TriggerPayloadManager'
+import { ImplementationException } from '../ImplementationException.js'
+import { assertNever } from '../utils/assertNever.js'
+import { FiredEvent } from './TriggerPayloadManager.js'
 import { Actions, ActionsPayload, Input } from '@contember/schema'
 import { FieldNode, Mapper, ObjectNode } from '@contember/engine-content-api'
 

package/src/triggers/TriggerPayloadManager.ts

@@ -1,8 +1,8 @@
 import { Actions, ActionsPayload, Input, Model } from '@contember/schema'
-import { AnyListener } from './TriggerListenersStore'
-import { EventCause } from './TriggerHandler'
-import { TriggerPayloadBuilder } from './TriggerPayloadBuilder'
-import { TriggerPayloadPersister } from './TriggerPayloadPersister'
+import { AnyListener } from './TriggerListenersStore.js'
+import { EventCause } from './TriggerHandler.js'
+import { TriggerPayloadBuilder } from './TriggerPayloadBuilder.js'
+import { TriggerPayloadPersister } from './TriggerPayloadPersister.js'
 
 export interface FiredEvent {
 	listener: AnyListener

package/src/triggers/TriggerPayloadPersister.ts

@@ -1,8 +1,8 @@
 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'
+import { EventRow } from '../model/types.js'
+import { notify } from '../utils/notifyChannel.js'
 
 type EventRowToInsert = Omit<EventRow, 'created_at' | 'visible_at' | 'last_state_change' | 'log'> & {
 	created_at: string | Date
@@ -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/src/triggers/index.ts

@@ -1,7 +1,7 @@
-export * from './TriggerIndirectChangesFetcher'
-export * from './TriggerListeners'
-export * from './TriggerListenersBuilder'
-export * from './TriggerListenersFactory'
-export * from './TriggerListenersStore'
-export * from './TriggerHandler'
-export * from './TriggerPayloadManager'
+export * from './TriggerIndirectChangesFetcher.js'
+export * from './TriggerListeners.js'
+export * from './TriggerListenersBuilder.js'
+export * from './TriggerListenersFactory.js'
+export * from './TriggerListenersStore.js'
+export * from './TriggerHandler.js'
+export * from './TriggerPayloadManager.js'

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

@@ -1,4 +1,4 @@
-import { TriggerListenerBuilder, TriggerListeners } from '../../../src/triggers'
+import { TriggerListenerBuilder, TriggerListeners } from '../../../src/triggers/index.js'
 import { SchemaDefinition as def } from '@contember/schema-definition'
 import { Actions, Model } from '@contember/schema'
 import { expect, test } from 'bun:test'

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.js'
+import { DispatchWorkerSupervisorFactory } from '../../../src/dispatch/DispatchWorkerSupervisor.js'
+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/tests/cases/unit/webhookHandler.test.ts

@@ -1,11 +1,11 @@
 import { describe, expect, test } from 'bun:test'
-import { WebhookTargetHandler } from '../../../src/dispatch/WebhookTargetHandler'
-import { FetcherResponse } from '../../../src/dispatch/WebhookFetcher'
+import { WebhookTargetHandler } from '../../../src/dispatch/WebhookTargetHandler.js'
+import { FetcherResponse } from '../../../src/dispatch/WebhookFetcher.js'
 import { createLogger, Logger, TestLoggerHandler } from '@contember/logger'
-import { EventRow } from '../../../src/model/types'
+import { EventRow } from '../../../src/model/types.js'
 import { Actions, ActionsPayload } from '@contember/schema'
-import { HandledEvent } from '../../../src/dispatch/types'
-import { testUuid } from '../../src/uuid'
+import { HandledEvent } from '../../../src/dispatch/types.js'
+import { testUuid } from '../../src/uuid.js'
 
 const assert = {
 	equal: (a: any, b: any) => expect(a).toEqual(b),

package/vitest.config.ts

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