@contember/engine-actions 2.1.0-alpha.3 → 2.1.0-alpha.30

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/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,28 +71,28 @@ 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,
 			})
-		})
+		}))
 	}
 
 
@@ -103,7 +103,7 @@ 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, {
+		const promises = indirectEntityListeners.map(listener => this.collectDeepChanges(event, listener, {
 			[event.entity.primary]: { eq: event.id },
 		}))
 		await Promise.all(promises)
@@ -149,13 +149,14 @@ export class TriggerHandler {
 		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/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

@@ -51,6 +51,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 +71,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 +87,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 +103,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 +112,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 +128,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)

package/src/triggers/TriggerPayloadManager.ts

@@ -1,4 +1,4 @@
-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'
@@ -11,6 +11,7 @@ export interface FiredEvent {
 	entity: Model.Entity
 	primary: Input.PrimaryValue
 	selection?: any
+	nodes?: ActionsPayload.EntityEventPathNode[]
 }
 
 export class TriggerPayloadManager {

package/src/triggers/TriggerPayloadPersister.ts

@@ -2,8 +2,9 @@ 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 +18,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 +48,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])
+}

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

@@ -8,7 +8,7 @@ const assert = {
 	equal: (a: any, b: any) => expect(a).toEqual(b),
 	deepStrictEqual: (a: any, b: any) => expect(a).toStrictEqual(b),
 }
-const createTrigger = (watchNode: Actions.SelectionNode): Actions.AnyTrigger => ({
+const createTrigger = (watchNode: Actions.SelectionNode): Actions.WatchTrigger => ({
 	type: 'watch',
 	entity: 'Author',
 	name: 'author_trigger',

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

@@ -29,6 +29,9 @@ const createTestEvent = (i = 0, row: Partial<EventRow> = {}): EventRow => ({
 	priority: 1,
 	schema_id: 1,
 	state: 'created',
+	identity_id: testUuid(i * 10 + 4),
+	ip_address: '127.0.0.1',
+	user_agent: 'test-agent',
 	...row,
 })
 
@@ -56,6 +59,9 @@ describe('webhook request', () => {
 						meta: {
 							eventId: testUuid(1),
 							transactionId: testUuid(2),
+							identityId: testUuid(4),
+							ipAddress: '127.0.0.1',
+							userAgent: 'test-agent',
 							createdAt: now.toISOString(),
 							lastStateChange: now.toISOString(),
 							numRetries: 0,
@@ -104,6 +110,9 @@ describe('webhook request', () => {
 								meta: {
 									eventId: testUuid(1),
 									transactionId: testUuid(2),
+									identityId: testUuid(4),
+									ipAddress: '127.0.0.1',
+									userAgent: 'test-agent',
 									createdAt: now.toISOString(),
 									lastStateChange: now.toISOString(),
 									numRetries: 0,