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

package/src/model/EventByIdQuery.ts

@@ -0,0 +1,21 @@
+import { DatabaseQuery, DatabaseQueryable, SelectBuilder } from '@contember/database'
+import { EventRow } from './types'
+
+export class EventByIdQuery extends DatabaseQuery<EventRow | null> {
+	constructor(
+		private readonly id: string,
+	) {
+		super()
+	}
+
+	async fetch(queryable: DatabaseQueryable): Promise<EventRow | null> {
+		const result = await SelectBuilder.create<EventRow>()
+			.from('actions_event')
+			.select('*')
+			.where({
+				id: this.id,
+			})
+			.getResult(queryable.db)
+		return this.fetchOneOrNull(result)
+	}
+}

package/src/model/EventsToProcessSpecification.ts

@@ -1,11 +1,12 @@
 import { Operator, SelectBuilderSpecification } from '@contember/database'
 
+export const eventsToProcessStateSpecification: SelectBuilderSpecification = qb =>
+	qb
+		.where(it => it.in('state', ['retrying', 'created', 'processing']))
 
-export const eventsToProcessStateSpecification: SelectBuilderSpecification = qb => qb
-	.where(it => it.in('state', ['retrying', 'created', 'processing']))
-
-export const eventsToProcessSpecification: SelectBuilderSpecification = qb => qb
-	.match(eventsToProcessStateSpecification)
-	.where(it => it.compare('visible_at', Operator.lte, 'now'))
-	.orderBy('priority', 'desc')
-	.orderBy('visible_at')
+export const eventsToProcessSpecification: SelectBuilderSpecification = qb =>
+	qb
+		.match(eventsToProcessStateSpecification)
+		.where(it => it.compare('visible_at', Operator.lte, 'now'))
+		.orderBy('priority', 'desc')
+		.orderBy('visible_at')

package/src/model/SetVariableCommand.ts

@@ -2,7 +2,6 @@ import { Command } from '@contember/engine-system-api'
 import { ConflictActionType, InsertBuilder, Literal } from '@contember/database'
 
 export class SetVariableCommand implements Command<void> {
-
 	constructor(
 		private readonly name: string,
 		private readonly value: string,

package/src/model/types.ts

@@ -14,6 +14,9 @@ export type EventRow = {
 	target: string
 	priority: number
 	trigger: string
+	identity_id: string | null
+	ip_address: string | null
+	user_agent: string | null
 	payload: ActionsPayload.AnyEventPayload
 	log: any[]
 }

package/src/triggers/TriggerHandler.ts

@@ -71,31 +71,30 @@ export class TriggerHandler {
 
 	private async directUpdateHandler(event: AfterUpdateEvent) {
 		const updateListeners = this.listenersStore.getUpdateListeners(event.entity.name)
-		updateListeners.map(listener => {
+		await Promise.all(updateListeners.map(listener => {
 			if (event.data.some(it => listener.fields.has(it.fieldName) && it.value !== it.old)) {
-				this.payloadManager.add({
+				return 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({
+		await Promise.all(createListeners.map(listener => {
+			return 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
@@ -103,9 +102,11 @@ export class TriggerHandler {
 	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 },
-		}))
+		const promises = indirectEntityListeners.map(listener =>
+			this.collectDeepChanges(event, listener, {
+				[event.entity.primary]: { eq: event.id },
+			})
+		)
 		await Promise.all(promises)
 	}
 
@@ -142,20 +143,20 @@ export class TriggerHandler {
 		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({
+		await Promise.all(result.map(row => {
+			return this.payloadManager.add({
 				listener,
 				entity: listener.rootEntity,
-				primary: row,
+				primary: row.id,
 				cause,
+				nodes: row.nodes,
 			})
-		}
+		}))
 	}
 }

package/src/triggers/TriggerIndirectChangesFetcher.ts

@@ -1,12 +1,21 @@
 import { Mapper, PathFactory, WhereBuilder } from '@contember/engine-content-api'
 import { IndirectListener, JunctionListener } from './TriggerListenersStore'
 import { SelectBuilder } from '@contember/database'
-import { Input } from '@contember/schema'
+import { ActionsPayload, Input, Model, Schema } from '@contember/schema'
+import { JoinBuilder } from '@contember/engine-content-api'
+import { getTargetEntity } from '@contember/schema-utils'
+
+export type TriggerIndirectChangesFetcherResult = {
+	id: Input.PrimaryValue
+	nodes?: ActionsPayload.EntityEventPathNode[]
+}[]
 
 export class TriggerIndirectChangesFetcher {
 	constructor(
+		private readonly model: Model.Schema,
 		private readonly mapper: Mapper,
 		private readonly whereBuilder: WhereBuilder,
+		private readonly joinBuilder: JoinBuilder,
 		private readonly pathFactory: PathFactory,
 	) {
 	}
@@ -14,7 +23,11 @@ export class TriggerIndirectChangesFetcher {
 	public async fetch(
 		listener: IndirectListener | JunctionListener,
 		where: Input.Where,
-	): Promise<Input.PrimaryValue[]> {
+	): Promise<TriggerIndirectChangesFetcherResult> {
+		if (listener.trigger.withNodes) {
+			return this.fetchWithNodes(listener, where)
+		}
+
 		for (let i = listener.path.length - 1; i >= 0; i--) {
 			where = { [listener.path[i]]: where }
 		}
@@ -24,7 +37,53 @@ export class TriggerIndirectChangesFetcher {
 		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)
+		return (await qbWithWhere.getResult(this.mapper.db))
 	}
 
+	private async fetchWithNodes(
+		listener: IndirectListener | JunctionListener,
+		where: Input.Where,
+	): Promise<TriggerIndirectChangesFetcherResult> {
+		const basePath = this.pathFactory.create([])
+		let path = basePath
+		let entity = listener.rootEntity
+		let qb = SelectBuilder.create()
+			.from(entity.tableName, path.alias)
+			.select([path.alias, entity.primaryColumn], path.for(entity.primary).alias)
+
+		for (let i = 0; i < listener.path.length; i++) {
+			const relationName = listener.path[i]
+			path = path.for(relationName)
+			const targetEntity = getTargetEntity(this.model, entity, relationName)
+			if (!targetEntity) {
+				throw new Error(`Target entity for relation ${entity.name}::${relationName} not found`)
+			}
+			qb = this.joinBuilder.join(qb, path, entity, relationName)
+
+			entity = targetEntity
+			qb = qb.select([path.alias, targetEntity.primaryColumn], path.for(targetEntity.primary).alias)
+		}
+
+		const qbWithWhere = this.whereBuilder.build(qb, entity, path, where)
+
+		const result = await qbWithWhere.getResult(this.mapper.db)
+
+		return result.map(row => {
+			const nodes: ActionsPayload.EntityEventPathNode[] = []
+			let entity = listener.rootEntity
+			let path = basePath
+			const id = row[path.for(entity.primary).alias]
+			for (let i = 0; i < listener.path.length; i++) {
+				const relationName = listener.path[i]
+				const targetEntity = getTargetEntity(this.model, entity, relationName)
+				if (!targetEntity) {
+					throw new Error(`Target entity for relation ${entity.name}::${relationName} not found`)
+				}
+				path = path.for(relationName)
+				nodes.push({ relation: relationName, entity: targetEntity.name, id: row[path.for(targetEntity.primary).alias] })
+				entity = targetEntity
+			}
+			return { id, nodes }
+		})
+	}
 }

package/src/triggers/TriggerListeners.ts

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

package/src/triggers/TriggerListenersBuilder.ts

@@ -6,7 +6,6 @@ import { mapGetOrPut } from '../utils/map'
 import { ImplementationException } from '../ImplementationException'
 
 export class TriggerListenerBuilder {
-
 	private readonly data: TriggerListeners = {
 		createListeners: new Map(),
 		updateListeners: new Map(),
@@ -26,7 +25,7 @@ export class TriggerListenerBuilder {
 		} else if (trigger.type === 'watch') {
 			this.processIndirectListeners(trigger)
 		} else {
-			((_: never) => {
+			;((_: never) => {
 				throw new ImplementationException(`Unhandled trigger ${(trigger as any).type}`)
 			})(trigger)
 		}
@@ -169,12 +168,10 @@ export class TriggerListenerBuilder {
 		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
-	>
-	(
+		V extends TriggerListeners[K] extends Map<string, infer V extends any[]> ? V[number] : never,
+	>(
 		type: K,
 		entityName: string,
 		value: V,

package/src/triggers/TriggerListenersStore.ts

@@ -3,7 +3,7 @@ import { TriggerListeners } from './TriggerListeners'
 
 export interface IndirectListener {
 	type: 'indirect'
-	trigger: Actions.AnyTrigger
+	trigger: Actions.WatchTrigger
 	rootEntity: Model.Entity
 	fields: Set<string>
 	relations: Set<string>
@@ -12,7 +12,7 @@ export interface IndirectListener {
 
 export interface JunctionListener {
 	type: 'junction'
-	trigger: Actions.AnyTrigger
+	trigger: Actions.WatchTrigger
 	rootEntity: Model.Entity
 	path: string[]
 	context: {

package/src/triggers/TriggerPayloadBuilder.ts

@@ -23,7 +23,10 @@ export class TriggerPayloadBuilder {
 		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, it.selection ?? selections[it.primary]) }))
+			return filteredEvents.map(it => ({
+				trigger: it.listener.trigger.name,
+				...this.buildBaseEventPayloads(it, it.selection ?? selections[it.primary]),
+			}))
 		}
 		if (triggerType === 'watch') {
 			return this.buildWatchEventPayloads(filteredEvents, selections)
@@ -35,9 +38,13 @@ export class TriggerPayloadBuilder {
 		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,
-			}), [])
+			const selection = await this.mapper.selectUnique(
+				event.entity,
+				input.withArg('by', {
+					[event.entity.primary]: event.primary,
+				}),
+				[],
+			)
 			return { ...event, selection }
 		}
 		return event
@@ -51,6 +58,19 @@ export class TriggerPayloadBuilder {
 		}
 		const payloads: ActionsPayload.WatchEventPayload[] = []
 		for (const eventsByPrimary of Object.values(byPrimary)) {
+			const baseEvents: ActionsPayload.BaseEventPayload[] = []
+
+			const existingEvents = new Set<string>()
+			for (const event of eventsByPrimary.events) {
+				const baseEvent = this.buildBaseEventPayloads(event)
+				const stringRepresentation = JSON.stringify(baseEvent)
+				if (existingEvents.has(stringRepresentation)) {
+					continue
+				}
+				existingEvents.add(stringRepresentation)
+				baseEvents.push(baseEvent)
+			}
+
 			payloads.push({
 				operation: 'watch',
 				trigger: events[0].listener.trigger.name,
@@ -58,7 +78,7 @@ export class TriggerPayloadBuilder {
 				id: eventsByPrimary.primary,
 				selection: eventsByPrimary.events.find(it => it.selection)?.selection
 					?? selections[eventsByPrimary.primary],
-				events: eventsByPrimary.events.map(it => this.buildBaseEventPayloads(it)),
+				events: baseEvents,
 			})
 		}
 		return payloads
@@ -74,6 +94,7 @@ export class TriggerPayloadBuilder {
 					selection,
 					values: Object.fromEntries(event.cause.data.map(it => [it.fieldName, it.value])),
 					path: 'path' in event.listener ? event.listener.path : undefined,
+					nodes: event.nodes,
 				}
 			case 'AfterUpdateEvent':
 			case 'BeforeUpdateEvent':
@@ -89,6 +110,7 @@ export class TriggerPayloadBuilder {
 					values: Object.fromEntries(event.cause.data.map(it => [it.fieldName, it.value])),
 					path: 'path' in event.listener ? event.listener.path : undefined,
 					old: Object.fromEntries(afterEvent.data.map(it => [it.fieldName, it.old])),
+					nodes: event.nodes,
 				}
 			case 'BeforeDeleteEvent':
 				return {
@@ -97,6 +119,7 @@ export class TriggerPayloadBuilder {
 					id: event.cause.id,
 					selection,
 					path: 'path' in event.listener ? event.listener.path : undefined,
+					nodes: event.nodes,
 				}
 			case 'AfterJunctionUpdateEvent':
 				if (event.listener.type !== 'junction') {
@@ -112,6 +135,7 @@ export class TriggerPayloadBuilder {
 					id,
 					inverseId,
 					path: 'path' in event.listener ? event.listener.path : undefined,
+					nodes: event.nodes,
 				}
 			default:
 				assertNever(event.cause, it => it.type)
@@ -135,14 +159,20 @@ export class TriggerPayloadBuilder {
 		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)
+		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

@@ -1,16 +1,16 @@
-import { Actions, Input, Model } from '@contember/schema'
+import { Actions, ActionsPayload, Input, Model } from '@contember/schema'
 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
+	nodes?: ActionsPayload.EntityEventPathNode[]
 }
 
 export class TriggerPayloadManager {
@@ -28,7 +28,6 @@ export class TriggerPayloadManager {
 		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)
@@ -37,4 +36,3 @@ export class TriggerPayloadManager {
 		}
 	}
 }
-

package/src/triggers/TriggerPayloadPersister.ts

@@ -2,8 +2,8 @@ import { Client, InsertBuilder } from '@contember/database'
 import { Mapper } from '@contember/engine-content-api'
 import { Actions, ActionsPayload } from '@contember/schema'
 import { EventRow } from '../model/types'
+import { notify } from '../utils/notifyChannel'
 
-export const NOTIFY_CHANNEL_NAME = 'actions_event'
 type EventRowToInsert = Omit<EventRow, 'created_at' | 'visible_at' | 'last_state_change' | 'log'> & {
 	created_at: string | Date
 	visible_at: string | Date
@@ -17,7 +17,9 @@ export class TriggerPayloadPersister {
 		private readonly providers: { uuid: () => string },
 		private readonly projectSlug: string,
 		private readonly stageId: string,
-		private readonly schemaId?: number,
+		private readonly schemaId: number | undefined,
+		private readonly identityId: string,
+		private readonly userInfo: { ipAddress: string | null; userAgent: string | null },
 	) {
 	}
 
@@ -45,10 +47,13 @@ export class TriggerPayloadPersister {
 					payload: it,
 					resolved_at: null,
 					last_state_change: 'now',
+					identity_id: this.identityId,
+					ip_address: this.userInfo.ipAddress,
+					user_agent: this.userInfo.userAgent,
 				})))
 				.execute(this.client)
 		}
 
-		await this.client.query('SELECT pg_notify(?, ?)', [NOTIFY_CHANNEL_NAME, this.projectSlug])
+		await notify(this.client, this.projectSlug)
 	}
 }

package/src/utils/notifyChannel.ts

@@ -0,0 +1,6 @@
+import { Client } from '@contember/database'
+
+export const NOTIFY_CHANNEL_NAME = 'actions_event'
+export const notify = async (db: Client, projectSlug: string) => {
+	await db.query('SELECT pg_notify(?, ?)', [NOTIFY_CHANNEL_NAME, projectSlug])
+}