@contember/engine-actions 1.3.0-alpha.4

package/src/triggers/TriggerPayloadBuilder.ts

@@ -0,0 +1,148 @@
+import { AnyEventPayload, BaseEventPayload, WatchEventPayload } from './Payload'
+import { ImplementationException } from '../ImplementationException'
+import { assertNever } from '../utils/assertNever'
+import { FiredEvent } from './TriggerPayloadManager'
+import { Actions, Input } from '@contember/schema'
+import { FieldNode, Mapper, ObjectNode } from '@contember/engine-content-api'
+
+type Selections = Record<Input.PrimaryValue, any>
+
+export class TriggerPayloadBuilder {
+	constructor(
+		private readonly mapper: Mapper,
+	) {
+	}
+
+	public async build(events: FiredEvent[]): Promise<AnyEventPayload[]> {
+		const filteredEvents = events.filter(it => {
+			return it.cause.type !== 'BeforeUpdateEvent'
+				|| it.cause.afterEvent?.hasChanges === true
+		})
+		if (filteredEvents.length === 0) {
+			return []
+		}
+		const selections = await this.fetchSelection(filteredEvents)
+		const triggerType = filteredEvents[0].listener.trigger.type
+		if (triggerType === 'basic') {
+			return filteredEvents.map(it => ({ trigger: it.listener.trigger.name, ...this.buildBaseEventPayloads(it, selections[it.primary]) }))
+		}
+		if (triggerType === 'watch') {
+			return this.buildWatchEventPayloads(filteredEvents, selections)
+		}
+		return assertNever(triggerType)
+	}
+
+	public async preprocessEvent(event: FiredEvent): Promise<FiredEvent> {
+		if (event.listener.type === 'delete' && event.listener.trigger.selection) {
+			const input = this.convertSelectionNode(event.listener.trigger.selection)
+
+			const selection = await this.mapper.selectUnique(event.entity, input.withArg('by', {
+				[event.entity.primary]: event.primary,
+			}), [])
+			return { ...event, selection }
+		}
+		return event
+	}
+
+	private buildWatchEventPayloads(events: FiredEvent[], selections: Selections): WatchEventPayload[] {
+		const byPrimary: Record<Input.PrimaryValue, { primary: Input.PrimaryValue; events: FiredEvent[] }> = {}
+		for (const event of events) {
+			byPrimary[event.primary] ??= { primary: event.primary, events: [] }
+			byPrimary[event.primary].events.push(event)
+		}
+		const payloads: WatchEventPayload[] = []
+		for (const eventsByPrimary of Object.values(byPrimary)) {
+			payloads.push({
+				operation: 'watch',
+				trigger: events[0].listener.trigger.name,
+				entity: events[0].entity.name,
+				id: eventsByPrimary.primary,
+				selection: selections[eventsByPrimary.primary],
+				events: eventsByPrimary.events.map(it => this.buildBaseEventPayloads(it)),
+			})
+		}
+		return payloads
+	}
+
+	private buildBaseEventPayloads(event: FiredEvent, selection?: any): BaseEventPayload {
+		switch (event.cause.type) {
+			case 'AfterInsertEvent':
+				return {
+					operation: 'create',
+					entity: event.cause.entity.name,
+					id: event.cause.id,
+					selection,
+					values: Object.fromEntries(event.cause.data.map(it => [it.fieldName, it.resolvedValue])),
+					path: 'path' in event.listener ? event.listener.path : undefined,
+				}
+			case 'AfterUpdateEvent':
+			case 'BeforeUpdateEvent':
+				const afterEvent = event.cause.type === 'AfterUpdateEvent' ? event.cause : event.cause.afterEvent
+				if (!afterEvent) {
+					throw new ImplementationException()
+				}
+				return {
+					operation: 'update',
+					entity: event.cause.entity.name,
+					id: event.cause.id,
+					selection,
+					values: Object.fromEntries(event.cause.data.map(it => [it.fieldName, it.resolvedValue])),
+					path: 'path' in event.listener ? event.listener.path : undefined,
+					old: Object.fromEntries(afterEvent.data.map(it => [it.fieldName, it.old])),
+				}
+			case 'BeforeDeleteEvent':
+				return {
+					operation: 'delete',
+					entity: event.cause.entity.name,
+					id: event.cause.id,
+					selection,
+					path: 'path' in event.listener ? event.listener.path : undefined,
+				}
+			case 'AfterJunctionUpdateEvent':
+				if (event.listener.type !== 'junction') {
+					throw new ImplementationException()
+				}
+				const [id, inverseId] = event.listener.context.type === 'owning'
+					? [event.cause.owningId, event.cause.inverseId]
+					: [event.cause.inverseId, event.cause.owningId]
+				return {
+					operation: event.cause.operation === 'connect' ? 'junction_connect' : 'junction_disconnect',
+					entity: event.listener.context.entity.name,
+					relation: event.listener.context.relation.name,
+					id,
+					inverseId,
+					path: 'path' in event.listener ? event.listener.path : undefined,
+				}
+			default:
+				assertNever(event.cause, it => it.type)
+		}
+	}
+
+	private async fetchSelection(events: FiredEvent[]): Promise<Selections> {
+		const trigger = events[0].listener.trigger
+		if (!trigger.selection) {
+			return {}
+		}
+
+		const ids = Array.from(new Set(events.filter(it => it.listener.type !== 'delete').map(it => it.primary)))
+		if (ids.length === 0) {
+			return {}
+		}
+		const entity = events[0].entity
+		const input = this.convertSelectionNode(trigger.selection).withArg('filter', {
+			[entity.primary]: { in: ids },
+		})
+		return await this.mapper.selectAssoc(entity, input, [], entity.primary)
+	}
+
+
+	private convertSelectionNode(node: Actions.SelectionNode, nodeName = 'root', path: string[] = []): ObjectNode<Input.ListQueryInput> {
+		return new ObjectNode(nodeName, nodeName, node.map(it => {
+			const [field, args, selection] = Array.isArray(it) ? it : [it, undefined, undefined]
+			if (selection === undefined || selection.length === 0) {
+				return new FieldNode(field, field, {})
+			}
+			return this.convertSelectionNode(selection, field, [...path, nodeName]).withArgs(args)
+		}), {}, {}, path)
+	}
+}

package/src/triggers/TriggerPayloadManager.ts

@@ -0,0 +1,47 @@
+import { Actions, Input, Model } from '@contember/schema'
+import { AnyEventPayload } from './Payload'
+import { AnyListener } from './TriggerListenersStore'
+import { EventCause } from './TriggerHandler'
+import { TriggerPayloadBuilder } from './TriggerPayloadBuilder'
+import { TriggerPayloadPersister } from './TriggerPayloadPersister'
+
+
+export interface FiredEvent {
+	listener: AnyListener
+	cause: EventCause
+	entity: Model.Entity
+	primary: Input.PrimaryValue
+	selection?: any
+}
+
+export type GroupedPayloads = {
+	trigger: Actions.AnyTrigger
+	entity: Model.Entity
+	payloads: AnyEventPayload[]
+}
+
+export class TriggerPayloadManager {
+	private eventsByTrigger: Record<string, FiredEvent[]> = {}
+
+	constructor(
+		private readonly triggerPayloadBuilder: TriggerPayloadBuilder,
+		private readonly triggerPayloadPersister: TriggerPayloadPersister,
+	) {
+	}
+
+	public async add(firedEvent: FiredEvent) {
+		const event = await this.triggerPayloadBuilder.preprocessEvent(firedEvent)
+		this.eventsByTrigger[firedEvent.listener.trigger.name] ??= []
+		this.eventsByTrigger[firedEvent.listener.trigger.name].push(event)
+	}
+
+
+	public async persist(): Promise<void> {
+		for (const events of Object.values(this.eventsByTrigger)) {
+			const payloads = await this.triggerPayloadBuilder.build(events)
+			const trigger = events[0].listener.trigger
+			await this.triggerPayloadPersister.persist(trigger, payloads)
+		}
+	}
+}
+

package/src/triggers/TriggerPayloadPersister.ts

@@ -0,0 +1,43 @@
+import { Client, InsertBuilder } from '@contember/database'
+import { AnyEventPayload } from './Payload'
+import { Mapper } from '@contember/engine-content-api'
+import { Actions } from '@contember/schema'
+
+export const NOTIFY_CHANNEL_NAME = 'actions_event'
+export class TriggerPayloadPersister {
+	constructor(
+		private readonly mapper: Mapper,
+		private readonly client: Client,
+		private readonly providers: { uuid: () => string },
+		private readonly projectSlug: string,
+		private readonly stageId: string,
+		private readonly schemaId: number,
+	) {
+	}
+
+	public async persist(trigger: Actions.AnyTrigger, payloads: AnyEventPayload[]): Promise<void> {
+		const chunkSize = 100
+		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 => ({
+					id: this.providers.uuid(),
+					transaction_id: this.mapper.transactionId,
+					created_at: 'now',
+					visible_at: 'now',
+					num_retries: 0,
+					state: 'created',
+					stage_id: this.stageId,
+					schema_id: this.schemaId,
+					target: trigger.target,
+					trigger: trigger.name,
+					priority: trigger.priority ?? 0,
+					payload: it,
+				})))
+				.execute(this.client)
+		}
+
+		await this.client.query('SELECT pg_notify(?, ?)', [NOTIFY_CHANNEL_NAME, this.projectSlug])
+	}
+}

package/src/triggers/index.ts

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

package/src/tsconfig.json

@@ -0,0 +1,21 @@
+{
+	"extends": "../tsconfig.settings.json",
+	"compilerOptions": {
+		"outDir": "../dist/src"
+	},
+	"references": [
+		{ "path": "../../../packages/database/src" },
+		{ "path": "../../../packages/database-migrations/src" },
+		{ "path": "../../../packages/engine-common/src" },
+		{ "path": "../../../packages/engine-content-api/src" },
+		{ "path": "../../../packages/engine-system-api/src" },
+		{ "path": "../../../packages/engine-tenant-api/src" },
+		{ "path": "../../../packages/graphql-utils/src" },
+		{ "path": "../../../packages/logger/src" },
+		{ "path": "../../../packages/schema/src" },
+		{ "path": "../../../packages/schema-utils/src" },
+		{ "path": "../../../packages/typesafe/src" },
+		{ "path": "../../../packages/engine-plugins/src" },
+		{ "path": "../../../packages/engine-http/src" }
+	]
+}

package/src/utils/assertNever.ts

@@ -0,0 +1,3 @@
+export function assertNever(_: never, formatUnhandledDiscriminator?: (value: any) => string): never {
+	throw new Error(`Unhandled case ${formatUnhandledDiscriminator?.(_)}`)
+}

package/src/utils/map.ts

@@ -0,0 +1,13 @@
+export const mapGetOrPut = <K, V, D extends V>(
+	map: Map<K, V>,
+	key: K,
+	defaultValue: () => D,
+): V => {
+	const value = map.get(key)
+	if (value !== undefined) {
+		return value
+	}
+	const newValue = defaultValue()
+	map.set(key, newValue)
+	return newValue
+}