@contember/engine-actions 1.3.0-alpha.4

package/src/triggers/Payload.ts

@@ -0,0 +1,82 @@
+import { Input, JSONObject, JSONValue } from '@contember/schema'
+
+export type UpdateEvent = {
+	operation: 'update'
+	entity: string
+	id: Input.PrimaryValue
+	values: JSONObject
+	old?: JSONObject
+	selection?: any
+	path?: string[]
+}
+
+export type CreateEvent = {
+	operation: 'create'
+	entity: string
+	id: Input.PrimaryValue
+	values: JSONObject
+	selection?: any
+	path?: string[]
+}
+
+export type DeleteEvent = {
+	operation: 'delete'
+	entity: string
+	id: Input.PrimaryValue
+	selection?: any
+	path?: string[]
+}
+
+export type JunctionConnectEvent = {
+	operation: 'junction_connect'
+	entity: string
+	id: Input.PrimaryValue
+	relation: string
+	inverseId: Input.PrimaryValue
+	selection?: any
+	path?: string[]
+}
+
+export type JunctionDisconnectEvent = {
+	operation: 'junction_disconnect'
+	entity: string
+	id: Input.PrimaryValue
+	relation: string
+	inverseId: Input.PrimaryValue
+	selection?: any
+	path?: string[]
+}
+
+export type WatchEventPayload = {
+	operation: 'watch'
+	trigger: string
+	entity: string
+	id: Input.PrimaryValue
+	events: BaseEventPayload[]
+	selection?: any
+}
+
+export type BaseEventPayload =
+	| CreateEvent
+	| UpdateEvent
+	| DeleteEvent
+	| JunctionConnectEvent
+	| JunctionDisconnectEvent
+
+export type BasicEventPayload =
+	& BaseEventPayload
+	& {
+		trigger: string
+	}
+
+export type AnyEventPayload =
+	| BasicEventPayload
+	| WatchEventPayload
+
+export interface TriggerPayload {
+	// identityId: string
+	// apiKeyId: string
+	transactionId: string
+	createdAt: string
+	event: AnyEventPayload
+}

package/src/triggers/TriggerHandler.ts

@@ -0,0 +1,161 @@
+import {
+	AfterInsertEvent,
+	AfterJunctionUpdateEvent,
+	AfterUpdateEvent,
+	BeforeDeleteEvent,
+	BeforeUpdateEvent,
+	EventManager,
+} from '@contember/engine-content-api'
+import { Input } from '@contember/schema'
+import { IndirectListener, JunctionListener, TriggerListenersStore } from './TriggerListenersStore'
+import { TriggerPayloadManager } from './TriggerPayloadManager'
+import { TriggerIndirectChangesFetcher } from './TriggerIndirectChangesFetcher'
+
+export type EventCause =
+	| BeforeUpdateEvent
+	| AfterUpdateEvent
+	| BeforeDeleteEvent
+	| AfterInsertEvent
+	| AfterJunctionUpdateEvent
+
+export class TriggerHandler {
+	constructor(
+		private readonly payloadManager: TriggerPayloadManager,
+		private readonly listenersStore: TriggerListenersStore,
+		private readonly changesFetcher: TriggerIndirectChangesFetcher,
+	) {
+	}
+
+	attach(evm: EventManager) {
+		evm.listen('BeforeDeleteEvent', async event => {
+			await this.directDeleteHandler(event)
+			await this.indirectChangesEntityHandler(event)
+		})
+		evm.listen('AfterInsertEvent', async event => {
+			await this.indirectChangesEntityHandler(event)
+			await this.directCreateHandler(event)
+		})
+		evm.listen('BeforeUpdateEvent', async event => {
+			await this.indirectChangesRelationHandler(event)
+		})
+		evm.listen('AfterUpdateEvent', async event => {
+			if (event.hasChanges) {
+				await this.indirectChangesUpdatesHandler(event)
+				await this.directUpdateHandler(event)
+			}
+		})
+		evm.listen('AfterJunctionUpdateEvent', async event => {
+			if (event.hasChanges) {
+				await this.junctionHandler(event)
+			}
+		})
+		evm.listen('BeforeCommitEvent', async event => {
+			await this.payloadManager.persist()
+		})
+	}
+
+	private async directDeleteHandler(event: BeforeDeleteEvent) {
+		const deleteListeners = this.listenersStore.getDeleteListener(event.entity.name)
+		if (!deleteListeners) {
+			return
+		}
+		await Promise.all(deleteListeners.map(listener => {
+			return this.payloadManager.add({
+				listener,
+				entity: event.entity,
+				primary: event.id,
+				cause: event,
+			})
+		}))
+	}
+
+	private async directUpdateHandler(event: AfterUpdateEvent) {
+		const updateListeners = this.listenersStore.getUpdateListeners(event.entity.name)
+		updateListeners.map(listener => {
+			if (event.data.some(it => listener.fields.has(it.fieldName))) {
+				this.payloadManager.add({
+					listener,
+					entity: event.entity,
+					primary: event.id,
+					cause: event,
+				})
+			}
+		})
+	}
+
+	private async directCreateHandler(event: AfterInsertEvent) {
+		const createListeners = this.listenersStore.getCreateListener(event.entity.name)
+		createListeners.map(listener => {
+			this.payloadManager.add({
+				listener,
+				entity: event.entity,
+				primary: event.id,
+				cause: event,
+			})
+		})
+	}
+
+
+	/**
+	 * Collect affected triggers after entity was created or before it was deleted.
+	 * todo: after insert, it should probably check only owning relations, because other relations are connected later, so it would be always empty
+	 */
+	private async indirectChangesEntityHandler(event: BeforeDeleteEvent | AfterInsertEvent) {
+		//
+		const indirectEntityListeners = this.listenersStore.getIndirectListeners(event.entity.name)
+		const promises =  indirectEntityListeners.map(listener => this.collectDeepChanges(event, listener, {
+			[event.entity.primary]: { eq: event.id },
+		}))
+		await Promise.all(promises)
+	}
+
+	private async indirectChangesRelationHandler(event: BeforeUpdateEvent) {
+		await this.indirectChangesUpdatesHandlerInner(event, 'relations')
+	}
+
+	private async indirectChangesUpdatesHandler(event: AfterUpdateEvent) {
+		await this.indirectChangesUpdatesHandlerInner(event, 'fields')
+	}
+	private async indirectChangesUpdatesHandlerInner(event: AfterUpdateEvent | BeforeUpdateEvent, type: 'fields' | 'relations') {
+		const indirectEntityListeners = this.listenersStore.getIndirectListeners(event.entity.name)
+		const promises = indirectEntityListeners.map(listener => {
+			if (event.data.some(val => listener[type].has(val.fieldName))) {
+				return this.collectDeepChanges(event, listener, {
+					[event.entity.primary]: { eq: event.id },
+				})
+			}
+		})
+		await Promise.all(promises)
+	}
+
+	private async junctionHandler(event: AfterJunctionUpdateEvent) {
+		const listeners = this.listenersStore.getJunctionListeners(event.owningEntity.name, event.owningRelation.name)
+		const promises = listeners.map(listener => {
+			const primary = listener.context.type === 'owning'
+				? event.owningId
+				: event.inverseId
+			const entity = listener.context.entity
+			return this.collectDeepChanges(event, listener, {
+				[entity.primary]: { eq: primary },
+			})
+		})
+		await Promise.all(promises)
+	}
+
+
+	private async collectDeepChanges(
+		cause: EventCause,
+		listener: IndirectListener | JunctionListener,
+		where: Input.Where,
+	) {
+		const result = await this.changesFetcher.fetch(listener, where)
+		for (const row of result) {
+			this.payloadManager.add({
+				listener,
+				entity: listener.rootEntity,
+				primary: row,
+				cause,
+			})
+		}
+	}
+}

package/src/triggers/TriggerIndirectChangesFetcher.ts

@@ -0,0 +1,30 @@
+import { Mapper, PathFactory, WhereBuilder } from '@contember/engine-content-api'
+import { IndirectListener, JunctionListener } from './TriggerListenersStore'
+import { SelectBuilder } from '@contember/database'
+import { Input } from '@contember/schema'
+
+export class TriggerIndirectChangesFetcher {
+	constructor(
+		private readonly mapper: Mapper,
+		private readonly whereBuilder: WhereBuilder,
+		private readonly pathFactory: PathFactory,
+	) {
+	}
+
+	public async fetch(
+		listener: IndirectListener | JunctionListener,
+		where: Input.Where,
+	): Promise<Input.PrimaryValue[]> {
+		for (const key of listener.path.reverse()) {
+			where = { [key]: where }
+		}
+		const qb = SelectBuilder.create<{ id: Input.PrimaryValue }>()
+			.from(listener.rootEntity.tableName, 'root_')
+			.select(['root_', listener.rootEntity.primaryColumn], 'id')
+		const path = this.pathFactory.create([])
+		const qbWithWhere = this.whereBuilder.build(qb, listener.rootEntity, path, where)
+
+		return (await qbWithWhere.getResult(this.mapper.db)).map(it => it.id)
+	}
+
+}

package/src/triggers/TriggerListeners.ts

@@ -0,0 +1,16 @@
+import {
+	CreateListener,
+	DeleteListener,
+	IndirectListener,
+	JunctionListener,
+	UpdateListener,
+} from './TriggerListenersStore'
+
+export interface TriggerListeners {
+	readonly deleteListeners: Map<string, DeleteListener[]>
+	readonly createListeners: Map<string, CreateListener[]>
+	readonly updateListeners: Map<string, UpdateListener[]>
+	readonly indirectListeners: Map<string, IndirectListener[]>
+	readonly junctionListeners: Map<string, Map<string, JunctionListener[]>>
+}
+

package/src/triggers/TriggerListenersBuilder.ts

@@ -0,0 +1,190 @@
+import { Actions, Model } from '@contember/schema'
+import { TriggerListeners } from './TriggerListeners'
+import { JunctionListener, TriggerListenersStore } from './TriggerListenersStore'
+import { acceptFieldVisitor, getEntity } from '@contember/schema-utils'
+import { mapGetOrPut } from '../utils/map'
+import { ImplementationException } from '../ImplementationException'
+
+export class TriggerListenerBuilder {
+
+	private readonly data: TriggerListeners = {
+		createListeners: new Map(),
+		updateListeners: new Map(),
+		deleteListeners: new Map(),
+		indirectListeners: new Map(),
+		junctionListeners: new Map(),
+	}
+
+	constructor(
+		private readonly model: Model.Schema,
+	) {
+	}
+
+	public add(trigger: Actions.AnyTrigger) {
+		if (trigger.type === 'basic') {
+			this.processBasicTrigger(trigger)
+		} else if (trigger.type === 'watch') {
+			this.processIndirectListeners(trigger)
+		} else {
+			((_: never) => {
+				throw new ImplementationException(`Unhandled trigger ${(trigger as any).type}`)
+			})(trigger)
+		}
+	}
+
+	private processBasicTrigger(trigger: Actions.BasicTrigger) {
+		const entity = getEntity(this.model, trigger.entity)
+		if (trigger.create) {
+			this.addListener('createListeners', trigger.entity, {
+				type: 'create',
+				entity,
+				trigger,
+			})
+		}
+		if (trigger.delete) {
+			this.addListener('deleteListeners', trigger.entity, {
+				type: 'delete',
+				entity,
+				trigger,
+			})
+		}
+		if (trigger.update) {
+			this.addListener('updateListeners', trigger.entity, {
+				type: 'update',
+				entity,
+				trigger,
+				fields: new Set(Object.keys(entity.fields)), // todo: only columns and owning
+			})
+		}
+	}
+
+	private processIndirectListeners(
+		trigger: Actions.WatchTrigger,
+	) {
+		const entity = getEntity(this.model, trigger.entity)
+		this.addListener('createListeners', trigger.entity, {
+			type: 'create',
+			entity,
+			trigger,
+		})
+		this.addListener('deleteListeners', trigger.entity, {
+			type: 'delete',
+			entity,
+			trigger,
+		})
+		this.processIndirectListenersNode(trigger, entity, entity, trigger.watch, [])
+	}
+	private processIndirectListenersNode(
+		trigger: Actions.WatchTrigger,
+		rootEntity: Model.Entity,
+		entity: Model.Entity,
+		node: Actions.SelectionNode,
+		path: string[],
+	) {
+		const fields = new Set<string>()
+		const relations = new Set<string>()
+		for (const entry of node) {
+			const [field, args, selection] = Array.isArray(entry) ? entry : [entry, undefined, undefined]
+			acceptFieldVisitor(this.model, entity, field, {
+				visitColumn: ({ entity, column }) => {
+					if (selection?.length > 0) {
+						throw new ImplementationException(`Column ${field} cannot have sub-selection`)
+					}
+					fields.add(column.name)
+				},
+				visitManyHasOne: ({ entity, relation, targetEntity, targetRelation }) => {
+					fields.add(relation.name)
+					relations.add(relation.name)
+					if (selection?.length > 0) {
+						this.processIndirectListenersNode(trigger, rootEntity, targetEntity, selection, [...path, relation.name])
+					}
+				},
+				visitOneHasMany: ({ entity, relation, targetEntity, targetRelation }) => {
+					this.processIndirectListenersNode(trigger, rootEntity, targetEntity, [...selection ?? [], targetRelation.name], [...path, relation.name])
+				},
+				visitOneHasOneOwning: ({ entity, relation, targetEntity, targetRelation }) => {
+					fields.add(relation.name)
+					relations.add(relation.name)
+					if (selection?.length > 0) {
+						this.processIndirectListenersNode(trigger, rootEntity, targetEntity, selection, [...path, relation.name])
+					}
+				},
+				visitOneHasOneInverse: ({ entity, relation, targetEntity, targetRelation }) => {
+					this.processIndirectListenersNode(trigger, rootEntity, targetEntity, [...selection ?? [], targetRelation.name], [...path, relation.name])
+				},
+				visitManyHasManyOwning: ({ entity, relation, targetEntity, targetRelation }) => {
+					this.addJunctionListener(entity.name, relation.name, {
+						type: 'junction',
+						rootEntity,
+						path: path,
+						trigger,
+						context: {
+							entity,
+							relation,
+							type: 'owning',
+						},
+					})
+					if (selection?.length > 0) {
+						this.processIndirectListenersNode(trigger, rootEntity, targetEntity, selection, [...path, relation.name])
+					}
+				},
+				visitManyHasManyInverse: ({ entity, relation, targetEntity, targetRelation }) => {
+					this.addJunctionListener(targetEntity.name, targetRelation.name, {
+						type: 'junction',
+						rootEntity,
+						path: path,
+						trigger,
+						context: {
+							entity,
+							relation,
+							type: 'inverse',
+						},
+					})
+					if (selection?.length > 0) {
+						this.processIndirectListenersNode(trigger, rootEntity, targetEntity, selection, [...path, relation.name])
+					}
+				},
+			})
+		}
+		if (path.length === 0) {
+			this.addListener('updateListeners', entity.name, {
+				type: 'update',
+				entity: rootEntity,
+				fields,
+				trigger,
+			})
+		} else {
+			this.addListener('indirectListeners', entity.name, {
+				type: 'indirect',
+				rootEntity: rootEntity,
+				fields,
+				relations,
+				path,
+				trigger,
+			})
+		}
+	}
+
+	public createStore(): TriggerListenersStore {
+		return new TriggerListenersStore(this.data)
+	}
+
+
+	private addListener<
+		K extends Exclude<keyof TriggerListeners, 'junctionListeners'>,
+		V extends TriggerListeners[K] extends Map<string, infer V extends any[]> ? V[number] : never
+	>
+	(
+		type: K,
+		entityName: string,
+		value: V,
+	) {
+		mapGetOrPut<string, V[], []>(this.data[type] as Map<string, V[]>, entityName, () => []).push(value)
+	}
+
+	private addJunctionListener(entityName: string, relationName: string, listener: JunctionListener) {
+		const entityJunctionListeners = mapGetOrPut(this.data.junctionListeners, entityName, () => new Map())
+		const relationListeners = mapGetOrPut(entityJunctionListeners, relationName, () => [])
+		relationListeners.push(listener)
+	}
+}

package/src/triggers/TriggerListenersFactory.ts

@@ -0,0 +1,19 @@
+import { TriggerListenersStore } from './TriggerListenersStore'
+import { TriggerListenerBuilder } from './TriggerListenersBuilder'
+import { Schema } from '@contember/schema'
+
+export class TriggerListenersFactory {
+	constructor(
+		private readonly schema: Schema,
+	) {
+	}
+
+	public create(): TriggerListenersStore {
+		const builder = new TriggerListenerBuilder(this.schema.model)
+		for (const trigger of Object.values(this.schema.actions.triggers)) {
+			builder.add(trigger)
+		}
+
+		return builder.createStore()
+	}
+}

package/src/triggers/TriggerListenersStore.ts

@@ -0,0 +1,76 @@
+import { Actions, Model } from '@contember/schema'
+import { TriggerListeners } from './TriggerListeners'
+
+export interface IndirectListener {
+	type: 'indirect'
+	trigger: Actions.AnyTrigger
+	rootEntity: Model.Entity
+	fields: Set<string>
+	relations: Set<string>
+	path: string[]
+}
+
+export interface JunctionListener {
+	type: 'junction'
+	trigger: Actions.AnyTrigger
+	rootEntity: Model.Entity
+	path: string[]
+	context: {
+		entity: Model.Entity
+		relation: Model.ManyHasManyOwningRelation | Model.ManyHasManyInverseRelation
+		type: 'owning' | 'inverse'
+	}
+}
+
+export interface DeleteListener {
+	type: 'delete'
+	trigger: Actions.AnyTrigger
+	entity: Model.Entity
+}
+
+export interface CreateListener {
+	type: 'create'
+	trigger: Actions.AnyTrigger
+	entity: Model.Entity
+}
+
+export interface UpdateListener {
+	type: 'update'
+	trigger: Actions.AnyTrigger
+	entity: Model.Entity
+	fields: Set<string>
+}
+
+export type AnyListener =
+	| JunctionListener
+	| UpdateListener
+	| CreateListener
+	| DeleteListener
+	| IndirectListener
+
+export class TriggerListenersStore {
+	constructor(
+		private readonly listeners: TriggerListeners,
+	) {
+	}
+
+	public getUpdateListeners(entityName: string): UpdateListener[] {
+		return this.listeners.updateListeners.get(entityName) ?? []
+	}
+
+	public getDeleteListener(entityName: string): DeleteListener[] {
+		return this.listeners.deleteListeners.get(entityName) ?? []
+	}
+
+	public getCreateListener(entityName: string): CreateListener[] {
+		return this.listeners.createListeners.get(entityName) ?? []
+	}
+
+	public getIndirectListeners(entityName: string): IndirectListener[] {
+		return this.listeners.indirectListeners.get(entityName) ?? []
+	}
+
+	public getJunctionListeners(entityName: string, relationName: string): JunctionListener[] {
+		return this.listeners.junctionListeners.get(entityName)?.get(relationName) ?? []
+	}
+}