@contember/engine-actions 1.3.0-alpha.8 → 1.3.0-beta.2

package/src/triggers/TriggerPayloadPersister.ts

@@ -2,8 +2,15 @@ import { Client, InsertBuilder } from '@contember/database'
 import { AnyEventPayload } from './Payload'
 import { Mapper } from '@contember/engine-content-api'
 import { Actions } from '@contember/schema'
+import { EventRow } from '../model/types'
 
 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
+	last_state_change: string | Date
+}
+
 export class TriggerPayloadPersister {
 	constructor(
 		private readonly mapper: Mapper,
@@ -21,7 +28,7 @@ export class TriggerPayloadPersister {
 			const chunk = payloads.slice(i, i + chunkSize)
 			await InsertBuilder.create()
 				.into('actions_event')
-				.values(chunk.map(it => ({
+				.values(chunk.map((it): EventRowToInsert => ({
 					id: this.providers.uuid(),
 					transaction_id: this.mapper.transactionId,
 					created_at: 'now',
@@ -34,6 +41,8 @@ export class TriggerPayloadPersister {
 					trigger: trigger.name,
 					priority: trigger.priority ?? 0,
 					payload: it,
+					resolved_at: null,
+					last_state_change: 'now',
 				})))
 				.execute(this.client)
 		}

package/src/tsconfig.json

@@ -4,6 +4,7 @@
 		"outDir": "../dist/src"
 	},
 	"references": [
+		{ "path": "../../../packages/authorization/src" },
 		{ "path": "../../../packages/database/src" },
 		{ "path": "../../../packages/database-migrations/src" },
 		{ "path": "../../../packages/engine-common/src" },

package/tests/cases/integration/triggers.rootWatch.test.ts

@@ -150,3 +150,67 @@ test('triggers: root watch - noop', async () => {
 })
 
 
+test('triggers: root delete', async () => {
+	const schema = createSchema(ActionsModel)
+	await executeDbTest({
+		executionContainerFactoryFactory,
+		migrationGroups: { 'contember/actions': migrationsGroup },
+		schema: schema,
+		seed: [
+			{
+				query: gql`
+                    mutation {
+                        createArticle(data: {title: "Hello world"}) {
+                            ok
+                        }
+                    }
+				`,
+			},
+		],
+		query: gql`
+            mutation {
+                deleteArticle(by: {title: "Hello world"}) {
+                    ok
+                }
+            }
+		`,
+		return: {
+			deleteArticle: {
+				ok: true,
+			},
+		},
+		expectSystemDatabase: {
+			actions_event: [{
+				payload: {
+					id: '123e4567-e89b-12d3-a456-000000000003',
+					entity: 'Article',
+					events: [{
+						id: '123e4567-e89b-12d3-a456-000000000003',
+						entity: 'Article',
+						values: { id: '123e4567-e89b-12d3-a456-000000000003', title: 'Hello world' },
+						operation: 'create',
+					}],
+					trigger: 'article_watch',
+					operation: 'watch',
+					selection: { id: '123e4567-e89b-12d3-a456-000000000003', title: 'Hello world' },
+				},
+				log: [],
+			}, {
+				payload: {
+					id: '123e4567-e89b-12d3-a456-000000000003',
+					entity: 'Article',
+					events: [{
+						id: '123e4567-e89b-12d3-a456-000000000003',
+						entity: 'Article',
+						operation: 'delete',
+					}],
+					trigger: 'article_watch',
+					operation: 'watch',
+					selection: { id: '123e4567-e89b-12d3-a456-000000000003', title: 'Hello world' },
+				},
+				log: [],
+			}],
+		},
+	})
+})
+

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

@@ -0,0 +1,275 @@
+import { assert, describe, expect, test } from 'vitest'
+import { WebhookTargetHandler } from '../../../src/dispatch/WebhookTargetHandler'
+import { FetcherResponse } from '../../../src/dispatch/WebhookFetcher'
+import { createLogger, TestLoggerHandler } from '@contember/logger'
+import { testUuid } from '@contember/engine-api-tester'
+import { AnyEventPayload } from '../../../src/triggers/Payload'
+import { EventRow } from '../../../src/model/types'
+import { Actions } from '@contember/schema'
+import { HandledEvent } from '../../../src/dispatch/types'
+
+
+const now = new Date()
+const createTestEvent = (i = 0, row: Partial<EventRow> = {}): EventRow => ({
+	created_at: now,
+	id: testUuid(i * 10 + 1),
+	trigger: 'test',
+	target: 'test_target',
+	last_state_change: now,
+	log: [],
+	num_retries: 0,
+	resolved_at: null,
+	transaction_id: testUuid(i * 10 + 2),
+	stage_id: testUuid(i * 10 + 3),
+	visible_at: now,
+	payload: { foo: 'bar' } as unknown as AnyEventPayload,
+	priority: 1,
+	schema_id: 1,
+	state: 'created',
+	...row,
+})
+
+const dropDuration = (events: HandledEvent[]): HandledEvent[] => {
+	return events.map(it => ({ ...it, result: { ...it.result, durationMs: -1 } }))
+}
+
+describe('webhook handler', () => {
+	test('successful response', async () => {
+		const testLoggerHandler = new TestLoggerHandler()
+		const logger = createLogger(testLoggerHandler)
+
+		let fetchCalled = false
+		const webhookHandler = new WebhookTargetHandler({
+			fetch(url: string, init: RequestInit): Promise<FetcherResponse> {
+				fetchCalled = true
+				assert.equal(url, 'http://localhost')
+
+				return Promise.resolve({
+					ok: true,
+					headers: new Headers(),
+					responseText: '',
+					status: 200,
+					statusText: 'OK',
+				})
+			},
+		})
+
+		const target: Actions.AnyTarget = {
+			name: 'test_target',
+			type: 'webhook',
+			url: 'http://localhost',
+		}
+
+		const event1 = createTestEvent(0)
+		const event2 = createTestEvent(1)
+		const result = await webhookHandler.handle({
+			logger,
+			target: target,
+			events: [event1, event2],
+			variables: {},
+		})
+		assert.equal(fetchCalled, true)
+		assert.deepStrictEqual(dropDuration(result), [
+			{
+				row: event1,
+				target,
+				result: {
+					ok: true,
+					code: 200,
+					durationMs: -1,
+				},
+			},
+			{
+				row: event2,
+				target,
+				result: {
+					ok: true,
+					code: 200,
+					durationMs: -1,
+				},
+			},
+		])
+	})
+
+	test('error response', async () => {
+		const testLoggerHandler = new TestLoggerHandler()
+		const logger = createLogger(testLoggerHandler)
+
+		let fetchCalled = false
+		const webhookHandler = new WebhookTargetHandler({
+			fetch(url: string, init: RequestInit): Promise<FetcherResponse> {
+				fetchCalled = true
+				assert.equal(url, 'http://localhost')
+
+				return Promise.resolve({
+					ok: false,
+					headers: new Headers(),
+					responseText: 'Failed to something',
+					status: 500,
+					statusText: 'Err',
+				})
+			},
+		})
+
+		const target: Actions.AnyTarget = {
+			name: 'test_target',
+			type: 'webhook',
+			url: 'http://localhost',
+		}
+
+		const event1 = createTestEvent(0)
+		const event2 = createTestEvent(1)
+		const result = await webhookHandler.handle({
+			logger,
+			target: target,
+			events: [event1, event2],
+			variables: {},
+		})
+		assert.equal(fetchCalled, true)
+		assert.deepStrictEqual(dropDuration(result), [
+			{
+				row: event1,
+				target,
+				result: {
+					ok: false,
+					code: 500,
+					durationMs: -1,
+					errorMessage: 'Err',
+					response: 'Failed to something',
+				},
+			},
+			{
+				row: event2,
+				target,
+				result: {
+					ok: false,
+					code: 500,
+					durationMs: -1,
+					errorMessage: 'Err',
+					response: 'Failed to something',
+				},
+			},
+		])
+	})
+
+
+	test('invalid partial response', async () => {
+		const testLoggerHandler = new TestLoggerHandler()
+		const logger = createLogger(testLoggerHandler)
+
+		let fetchCalled = false
+		const webhookHandler = new WebhookTargetHandler({
+			fetch(url: string, init: RequestInit): Promise<FetcherResponse> {
+				fetchCalled = true
+				assert.equal(url, 'http://localhost')
+
+				return Promise.resolve({
+					ok: true,
+					headers: new Headers([['content-type', 'application/json']]),
+					responseText: `{"events": []}`,
+					status: 200,
+					statusText: 'OK',
+				})
+			},
+		})
+
+		const target: Actions.AnyTarget = {
+			name: 'test_target',
+			type: 'webhook',
+			url: 'http://localhost',
+		}
+
+		const event1 = createTestEvent(0)
+		const event2 = createTestEvent(1)
+		const result = await webhookHandler.handle({
+			logger,
+			target: target,
+			events: [event1, event2],
+			variables: {},
+		})
+		assert.equal(fetchCalled, true)
+		assert.deepStrictEqual(dropDuration(result), [
+			{
+				row: event1,
+				target,
+				result: {
+					ok: false,
+					code: 200,
+					durationMs: -1,
+					errorMessage: 'Invalid response: value at path /failures: must be array, undefined given',
+					response: '{"events": []}',
+				},
+			},
+			{
+				row: event2,
+				target,
+				result: {
+					ok: false,
+					code: 200,
+					durationMs: -1,
+					errorMessage: 'Invalid response: value at path /failures: must be array, undefined given',
+					response: '{"events": []}',
+				},
+			},
+		])
+	})
+
+
+	test('partially successful response', async () => {
+		const testLoggerHandler = new TestLoggerHandler()
+		const logger = createLogger(testLoggerHandler)
+
+		let fetchCalled = false
+		const webhookHandler = new WebhookTargetHandler({
+			fetch(url: string, init: RequestInit): Promise<FetcherResponse> {
+				fetchCalled = true
+				assert.equal(url, 'http://localhost')
+
+				return Promise.resolve({
+					ok: true,
+					headers: new Headers([['content-type', 'application/json']]),
+					responseText: `{"failures": [{"eventId": "${testUuid(1)}", "error": "foo failure"}]}`,
+					status: 200,
+					statusText: 'OK',
+				})
+			},
+		})
+
+		const target: Actions.AnyTarget = {
+			name: 'test_target',
+			type: 'webhook',
+			url: 'http://localhost',
+		}
+
+		const event1 = createTestEvent(0)
+		const event2 = createTestEvent(1)
+		const result = await webhookHandler.handle({
+			logger,
+			target: target,
+			events: [event1, event2],
+			variables: {},
+		})
+		assert.equal(fetchCalled, true)
+		assert.deepStrictEqual(dropDuration(result), [
+			{
+				row: event1,
+				target,
+				result: {
+					ok: false,
+					code: 200,
+					durationMs: -1,
+					errorMessage: 'foo failure',
+				},
+			},
+			{
+				row: event2,
+				target,
+				result: {
+					ok: true,
+					code: 200,
+					durationMs: -1,
+				},
+			},
+		])
+	})
+})