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

package/src/triggers/TriggerPayloadPersister.ts

@@ -1,9 +1,9 @@
 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'
 
-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,10 @@ 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 },
+		private readonly triggeredActionsCollector: TriggeredActionsCollector | undefined,
 	) {
 	}
 
@@ -26,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,
@@ -45,10 +52,21 @@ 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,
+				}
+			})
+			await InsertBuilder.create()
+				.into('actions_event')
+				.values(rows)
 				.execute(this.client)
+
+			if (collected && collected.length > 0) {
+				collector!.add(collected)
+			}
 		}
 
-		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

@@ -3,12 +3,11 @@ import { SchemaDefinition as def } from '@contember/schema-definition'
 import { Actions, Model } from '@contember/schema'
 import { expect, test } from 'bun:test'
 
-
 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',
@@ -34,21 +33,24 @@ test('first level many-has-many owning', () => {
 	const node = [['topics', {}, ['name']]] as const
 	const trigger = createTrigger(node)
 	const listeners = createEmptyListeners([], trigger)
-	listeners.junctionListeners.set('Author', new Map([
-		['topics', [
-			{
-				type: 'junction',
-				path: [],
-				rootEntity: schema.entities.Author,
-				context: {
-					type: 'owning',
-					entity: schema.entities.Author,
-					relation: schema.entities.Author.fields.topics as Model.ManyHasManyOwningRelation,
+	listeners.junctionListeners.set(
+		'Author',
+		new Map([
+			['topics', [
+				{
+					type: 'junction',
+					path: [],
+					rootEntity: schema.entities.Author,
+					context: {
+						type: 'owning',
+						entity: schema.entities.Author,
+						relation: schema.entities.Author.fields.topics as Model.ManyHasManyOwningRelation,
+					},
+					trigger,
 				},
-				trigger,
-			},
-		]],
-	]))
+			]],
+		]),
+	)
 
 	listeners.indirectListeners.set('AuthorTopic', [{
 		type: 'indirect',
@@ -59,31 +61,32 @@ test('first level many-has-many owning', () => {
 		path: ['topics'],
 	}])
 
-
 	assert.deepStrictEqual(testBuilder(node), listeners)
 })
 
 test('first level many-has-many inverse', () => {
-
 	const node = [['followers', {}, ['name']]] as const
 	const trigger = createTrigger(node)
 
 	const listeners = createEmptyListeners([], trigger)
-	listeners.junctionListeners.set('User', new Map([
-		['following', [
-			{
-				type: 'junction',
-				path: [],
-				rootEntity: schema.entities.Author,
-				context: {
-					type: 'inverse',
-					entity: schema.entities.Author,
-					relation: schema.entities.Author.fields.followers as Model.ManyHasManyInverseRelation,
+	listeners.junctionListeners.set(
+		'User',
+		new Map([
+			['following', [
+				{
+					type: 'junction',
+					path: [],
+					rootEntity: schema.entities.Author,
+					context: {
+						type: 'inverse',
+						entity: schema.entities.Author,
+						relation: schema.entities.Author.fields.followers as Model.ManyHasManyInverseRelation,
+					},
+					trigger,
 				},
-				trigger,
-			},
-		]],
-	]))
+			]],
+		]),
+	)
 	listeners.indirectListeners.set('User', [{
 		type: 'indirect',
 		rootEntity: schema.entities.Author,
@@ -95,7 +98,6 @@ test('first level many-has-many inverse', () => {
 	assert.deepStrictEqual(testBuilder(node), listeners)
 })
 
-
 test('first level one-has-one owning', () => {
 	const node = [['avatar', {}, ['url']]] as const
 	const trigger = createTrigger(node)
@@ -160,9 +162,7 @@ test('first level one-has-many', () => {
 	assert.deepStrictEqual(testBuilder(node), listeners)
 })
 
-
 test('second level one-has-one owning', () => {
-
 	const node = [['articles', {}, [['image', {}, ['url']]]]] as const
 
 	const trigger = createTrigger(node)
@@ -188,7 +188,6 @@ test('second level one-has-one owning', () => {
 	assert.deepStrictEqual(testBuilder(node), listeners)
 })
 
-
 test('second level one-has-one inverse', () => {
 	const node = [['articles', {}, [['settings', {}, ['visible']]]]] as const
 
@@ -212,11 +211,9 @@ test('second level one-has-one inverse', () => {
 		path: ['articles'],
 	}])
 
-
 	assert.deepStrictEqual(testBuilder(node), listeners)
 })
 
-
 test('second level one-has-many', () => {
 	const node = [['articles', {}, [['comments', {}, ['content']]]]] as const
 
@@ -244,9 +241,7 @@ test('second level one-has-many', () => {
 	assert.deepStrictEqual(testBuilder(node), listeners)
 })
 
-
 test('third level many-has-one', () => {
-
 	const node = [['articles', {}, [['comments', {}, [['author', {}, ['name']]]]]]] as const
 	const trigger = createTrigger(node)
 
@@ -281,10 +276,7 @@ test('third level many-has-one', () => {
 	assert.deepStrictEqual(testBuilder(node), listeners)
 })
 
-
 test('second level many-has-one', () => {
-
-
 	const node = [['articles', {}, [['category', {}, ['name']]]]] as const
 	const trigger = createTrigger(node)
 	const listeners = createEmptyListeners([], trigger)
@@ -309,27 +301,28 @@ test('second level many-has-one', () => {
 	assert.deepStrictEqual(testBuilder(node), listeners)
 })
 
-
 test('second level many-has-many owning', () => {
-
 	const node = [['articles', {}, [['tags', {}, ['name']]]]] as const
 	const trigger = createTrigger(node)
 	const listeners = createEmptyListeners([], trigger)
-	listeners.junctionListeners.set('Article', new Map([
-		['tags', [
-			{
-				type: 'junction',
-				path: ['articles'],
-				rootEntity: schema.entities.Author,
-				context: {
-					entity: schema.entities.Article,
-					relation: schema.entities.Article.fields.tags as Model.ManyHasManyOwningRelation,
-					type: 'owning',
+	listeners.junctionListeners.set(
+		'Article',
+		new Map([
+			['tags', [
+				{
+					type: 'junction',
+					path: ['articles'],
+					rootEntity: schema.entities.Author,
+					context: {
+						entity: schema.entities.Article,
+						relation: schema.entities.Article.fields.tags as Model.ManyHasManyOwningRelation,
+						type: 'owning',
+					},
+					trigger,
 				},
-				trigger,
-			},
-		]],
-	]))
+			]],
+		]),
+	)
 
 	listeners.indirectListeners.set('Tag', [{
 		type: 'indirect',
@@ -340,7 +333,6 @@ test('second level many-has-many owning', () => {
 		path: ['articles', 'tags'],
 	}])
 
-
 	listeners.indirectListeners.set('Article', [{
 		type: 'indirect',
 		rootEntity: schema.entities.Author,
@@ -354,25 +346,27 @@ test('second level many-has-many owning', () => {
 })
 
 test('second level many-has-many inverse', () => {
-
 	const node = [['articles', {}, [['likedBy', {}, ['name']]]]] as const
 	const trigger = createTrigger(node)
 	const listeners = createEmptyListeners([], trigger)
-	listeners.junctionListeners.set('User', new Map([
-		['likes', [
-			{
-				type: 'junction',
-				path: ['articles'],
-				rootEntity: schema.entities.Author,
-				context: {
-					type: 'inverse',
-					entity: schema.entities.Article,
-					relation: schema.entities.Article.fields.likedBy as Model.ManyHasManyInverseRelation,
+	listeners.junctionListeners.set(
+		'User',
+		new Map([
+			['likes', [
+				{
+					type: 'junction',
+					path: ['articles'],
+					rootEntity: schema.entities.Author,
+					context: {
+						type: 'inverse',
+						entity: schema.entities.Article,
+						relation: schema.entities.Article.fields.likedBy as Model.ManyHasManyInverseRelation,
+					},
+					trigger,
 				},
-				trigger,
-			},
-		]],
-	]))
+			]],
+		]),
+	)
 
 	listeners.indirectListeners.set('User', [{
 		type: 'indirect',
@@ -383,7 +377,6 @@ test('second level many-has-many inverse', () => {
 		path: ['articles', 'likedBy'],
 	}])
 
-
 	listeners.indirectListeners.set('Article', [{
 		type: 'indirect',
 		rootEntity: schema.entities.Author,
@@ -396,7 +389,6 @@ test('second level many-has-many inverse', () => {
 	assert.deepStrictEqual(testBuilder(node), listeners)
 })
 
-
 test('all above', () => {
 	const node = [
 		'name',
@@ -413,70 +405,78 @@ test('all above', () => {
 			['category', {}, ['name']],
 			['tags', {}, ['name']],
 			['likedBy', {}, ['name']],
-
 		]],
 	] as const
 	const trigger = createTrigger(node)
 	const listeners = createEmptyListeners(['name', 'avatar', 'supervisor'], trigger)
-	listeners.junctionListeners.set('Author', new Map([
-		['topics', [
-			{
-				type: 'junction',
-				path: [],
-				rootEntity: schema.entities.Author,
-				context: {
-					type: 'owning',
-					entity: schema.entities.Author,
-					relation: schema.entities.Author.fields.topics as Model.ManyHasManyOwningRelation,
+	listeners.junctionListeners.set(
+		'Author',
+		new Map([
+			['topics', [
+				{
+					type: 'junction',
+					path: [],
+					rootEntity: schema.entities.Author,
+					context: {
+						type: 'owning',
+						entity: schema.entities.Author,
+						relation: schema.entities.Author.fields.topics as Model.ManyHasManyOwningRelation,
+					},
+					trigger,
 				},
-				trigger,
-			},
-		]],
-	]))
-	listeners.junctionListeners.set('User', new Map([
-		['following', [
-			{
-				type: 'junction',
-				path: [],
-				rootEntity: schema.entities.Author,
-				context: {
-					type: 'inverse',
-					entity: schema.entities.Author,
-					relation: schema.entities.Author.fields.followers as Model.ManyHasManyInverseRelation,
+			]],
+		]),
+	)
+	listeners.junctionListeners.set(
+		'User',
+		new Map([
+			['following', [
+				{
+					type: 'junction',
+					path: [],
+					rootEntity: schema.entities.Author,
+					context: {
+						type: 'inverse',
+						entity: schema.entities.Author,
+						relation: schema.entities.Author.fields.followers as Model.ManyHasManyInverseRelation,
+					},
+					trigger,
 				},
-				trigger,
-			},
-		]],
-		['likes', [
-			{
-				type: 'junction',
-				path: ['articles'],
-				rootEntity: schema.entities.Author,
-				context: {
-					type: 'inverse',
-					entity: schema.entities.Article,
-					relation: schema.entities.Article.fields.likedBy as Model.ManyHasManyInverseRelation,
+			]],
+			['likes', [
+				{
+					type: 'junction',
+					path: ['articles'],
+					rootEntity: schema.entities.Author,
+					context: {
+						type: 'inverse',
+						entity: schema.entities.Article,
+						relation: schema.entities.Article.fields.likedBy as Model.ManyHasManyInverseRelation,
+					},
+					trigger,
 				},
-				trigger,
-			},
-		]],
-	]))
-
-	listeners.junctionListeners.set('Article', new Map([
-		['tags', [
-			{
-				type: 'junction',
-				path: ['articles'],
-				rootEntity: schema.entities.Author,
-				context: {
-					type: 'owning',
-					entity: schema.entities.Article,
-					relation: schema.entities.Article.fields.tags as Model.ManyHasManyOwningRelation,
+			]],
+		]),
+	)
+
+	listeners.junctionListeners.set(
+		'Article',
+		new Map([
+			['tags', [
+				{
+					type: 'junction',
+					path: ['articles'],
+					rootEntity: schema.entities.Author,
+					context: {
+						type: 'owning',
+						entity: schema.entities.Article,
+						relation: schema.entities.Article.fields.tags as Model.ManyHasManyOwningRelation,
+					},
+					trigger,
 				},
-				trigger,
-			},
-		]],
-	]))
+			]],
+		]),
+	)
 
 	listeners.indirectListeners.set('AuthorTopic', [{
 		type: 'indirect',
@@ -569,7 +569,6 @@ test('all above', () => {
 		path: ['articles', 'comments'],
 	}])
 
-
 	listeners.indirectListeners.set('Category', [{
 		type: 'indirect',
 		rootEntity: schema.entities.Author,
@@ -596,7 +595,6 @@ test('all above', () => {
 		path: ['articles'],
 	}])
 
-
 	listeners.indirectListeners.set('AuthorTopic', [{
 		type: 'indirect',
 		rootEntity: schema.entities.Author,
@@ -609,7 +607,6 @@ test('all above', () => {
 	assert.deepStrictEqual(testBuilder(node), listeners)
 })
 
-
 namespace WatchModel {
 	export class Author {
 		name = def.stringColumn()