@starci/hfs 4.7.32 → 4.7.34

package/templates/be/patterns/event-bus/platform/event-relay.service.spec.ts.tpl

@@ -25,9 +25,15 @@ const options: EventBusOptions = {
 
 const row = (id: string) => ({
     id,
+    correlation_id: `request-${id}`,
     topic: "events.probe",
     message_key: `o-${id}`,
-    envelope: { eventId: `o-${id}`, eventName: "probe.ping", payload: {} },
+    envelope: {
+        metadata: { correlationId: `request-${id}` },
+        eventId: `o-${id}`,
+        eventName: "probe.ping",
+        payload: {},
+    },
 })
 
 const build = async (manager: MockEntityManager) => {
@@ -46,91 +52,146 @@ const build = async (manager: MockEntityManager) => {
     return { relay: moduleRef.get(EventRelayService), transport, logger }
 }
 
-describe("EventRelayService", () => {
-    describe("relay", () => {
-        it("sends the waiting rows in order and marks them sent in the same transaction", async () => {
-            const tx = fakeTransaction(
-                mockEntityManager({
-                    query: [
-                        [SELECT_WAITING_ROWS, [row("1"), row("2")]],
-                        [MARK_ROWS_SENT, []],
-                    ],
-                }),
-            )
-            const { relay, transport } = await build(tx.em)
-
-            await expect(relay.relay()).resolves.toBe(2)
-
-            expect(tx.em.query).toHaveBeenNthCalledWith(1, SELECT_WAITING_ROWS, [2])
-            expect(transport.send).toHaveBeenCalledWith([
-                { topic: "events.probe", key: "o-1", value: JSON.stringify(row("1").envelope), headers: {} },
-                { topic: "events.probe", key: "o-2", value: JSON.stringify(row("2").envelope), headers: {} },
-            ])
-            expect(tx.em.query).toHaveBeenNthCalledWith(2, MARK_ROWS_SENT, [["1", "2"], new Date(AT)])
-            expect(tx.commits).toBe(1)
-        })
+describe("EventRelayService transaction delivery", () => {
+    it("sends the waiting rows in order and marks them sent in the same transaction", async () => {
+        const tx = fakeTransaction(
+            mockEntityManager({
+                query: [
+                    [SELECT_WAITING_ROWS, [row("1"), row("2")]],
+                    [MARK_ROWS_SENT, []],
+                ],
+            }),
+        )
+        const { relay, transport } = await build(tx.em)
+
+        await expect(relay.relay()).resolves.toBe(2)
+
+        expect(tx.em.query).toHaveBeenNthCalledWith(1, SELECT_WAITING_ROWS, [2])
+        expect(transport.send).toHaveBeenCalledWith([
+            {
+                topic: "events.probe",
+                key: "o-1",
+                value: JSON.stringify(row("1").envelope),
+                headers: { "x-request-id": "request-1" },
+            },
+            {
+                topic: "events.probe",
+                key: "o-2",
+                value: JSON.stringify(row("2").envelope),
+                headers: { "x-request-id": "request-2" },
+            },
+        ])
+        expect(tx.em.query).toHaveBeenNthCalledWith(2, MARK_ROWS_SENT, [["1", "2"], new Date(AT)])
+        expect(tx.commits).toBe(1)
+    })
 
-        it("sends nothing and marks nothing when no row waits", async () => {
-            const tx = fakeTransaction(mockEntityManager({ query: [SELECT_WAITING_ROWS, []] }))
-            const { relay, transport } = await build(tx.em)
+    it("sends nothing and marks nothing when no row waits", async () => {
+        const tx = fakeTransaction(mockEntityManager({ query: [SELECT_WAITING_ROWS, []] }))
+        const { relay, transport } = await build(tx.em)
 
-            await expect(relay.relay()).resolves.toBe(0)
+        await expect(relay.relay()).resolves.toBe(0)
 
-            expect(transport.send).not.toHaveBeenCalled()
-            expect(tx.em.query).toHaveBeenCalledTimes(1)
-        })
+        expect(transport.send).not.toHaveBeenCalled()
+        expect(tx.em.query).toHaveBeenCalledTimes(1)
+    })
 
-        it("leaves the rows unmarked when the broker refuses, so the next pass sends them again", async () => {
-            const tx = fakeTransaction(mockEntityManager({ query: [SELECT_WAITING_ROWS, [row("1")]] }))
-            const { relay, transport } = await build(tx.em)
-            const failure = new Error("broker down")
-            transport.send.mockRejectedValue(failure)
+    it("leaves the rows unmarked when the broker refuses, so the next pass sends them again", async () => {
+        const tx = fakeTransaction(mockEntityManager({ query: [SELECT_WAITING_ROWS, [row("1")]] }))
+        const { relay, transport } = await build(tx.em)
+        const failure = new Error("broker down")
+        transport.send.mockRejectedValue(failure)
 
-            await expect(relay.relay()).rejects.toBe(failure)
+        await expect(relay.relay()).rejects.toBe(failure)
 
-            expect(tx.rollbacks).toBe(1)
-            expect(tx.em.query).toHaveBeenCalledTimes(1)
-        })
+        expect(tx.rollbacks).toBe(1)
+        expect(tx.em.query).toHaveBeenCalledTimes(1)
     })
+})
+
+describe("EventRelayService correlation metadata", () => {
+    it.each([
+        { label: "missing", envelope: { eventId: "o-1", eventName: "probe.ping", payload: {} }, metadata: {} },
+        {
+            label: "malformed",
+            envelope: { eventId: "o-1", eventName: "probe.ping", payload: {}, metadata: "unreadable" },
+            metadata: {},
+        },
+        {
+            label: "forged",
+            envelope: {
+                eventId: "o-1",
+                eventName: "probe.ping",
+                payload: {},
+                metadata: { correlationId: "forged-id", causationId: "preceding-event" },
+            },
+            metadata: { causationId: "preceding-event" },
+        },
+    ])("uses the row correlation when stored metadata is $label", async ({ envelope, metadata }) => {
+        const stored = { ...row("1"), envelope }
+        const tx = fakeTransaction(
+            mockEntityManager({
+                query: [
+                    [SELECT_WAITING_ROWS, [stored]],
+                    [MARK_ROWS_SENT, []],
+                ],
+            }),
+        )
+        const { relay, transport } = await build(tx.em)
+
+        await relay.relay()
+
+        expect(transport.send).toHaveBeenCalledTimes(1)
+        const delivery = transport.send.mock.calls[0]?.[0]?.[0]
+        const received = (() => {
+            try {
+                const value: unknown = JSON.parse(delivery?.value ?? "null")
+                return { value }
+            } catch (cause) {
+                return { cause }
+            }
+        })()
+        expect(received).toEqual({ value: { ...envelope, metadata: { ...metadata, correlationId: "request-1" } } })
+        expect(delivery?.headers).toEqual({ "x-request-id": "request-1" })
+    })
+})
+
+describe("EventRelayService the loop", () => {
+    it("passes again at once after a pass that sent rows, pauses on an empty outbox, logs a failed pass and stops on shutdown", async () => {
+        const tx = fakeTransaction(
+            mockEntityManager({
+                query: [
+                    [SELECT_WAITING_ROWS, [row("1")]],
+                    [MARK_ROWS_SENT, []],
+                    [SELECT_WAITING_ROWS, []],
+                ],
+            }),
+        )
+        const { relay, transport, logger } = await build(tx.em)
+        const failure = new Error("outbox unreadable")
+        let waits = 0
+        let shutdown: Promise<void> = Promise.resolve()
+        let reachedSecondWait: () => void = () => undefined
+        const secondWait = new Promise<void>((resolve) => {
+            reachedSecondWait = resolve
+        })
+        transport.wait.mockImplementation(() => {
+            waits += 1
+            if (waits === 1) tx.em.query.mockRejectedValueOnce(failure)
+            else {
+                shutdown = relay.onApplicationShutdown()
+                reachedSecondWait()
+            }
+            return Promise.resolve()
+        })
+
+        relay.onApplicationBootstrap()
+        await secondWait
+        await shutdown
 
-    describe("the loop", () => {
-        it("passes again at once after a pass that sent rows, pauses on an empty outbox, logs a failed pass and stops on shutdown", async () => {
-            const tx = fakeTransaction(
-                mockEntityManager({
-                    query: [
-                        [SELECT_WAITING_ROWS, [row("1")]],
-                        [MARK_ROWS_SENT, []],
-                        [SELECT_WAITING_ROWS, []],
-                    ],
-                }),
-            )
-            const { relay, transport, logger } = await build(tx.em)
-            const failure = new Error("outbox unreadable")
-            let waits = 0
-            let shutdown: Promise<void> = Promise.resolve()
-            let reachedSecondWait: () => void = () => undefined
-            const secondWait = new Promise<void>((resolve) => {
-                reachedSecondWait = resolve
-            })
-            transport.wait.mockImplementation(() => {
-                waits += 1
-                if (waits === 1) tx.em.query.mockRejectedValueOnce(failure)
-                else {
-                    shutdown = relay.onApplicationShutdown()
-                    reachedSecondWait()
-                }
-                return Promise.resolve()
-            })
-
-            relay.onApplicationBootstrap()
-            await secondWait
-            await shutdown
-
-            expect(transport.send).toHaveBeenCalledTimes(1)
-            expect(transport.wait).toHaveBeenCalledWith(100)
-            expect(logger.error).toHaveBeenCalledWith(OutboxLogEvent.RelayFailed, failure, {
-                outbox: "event-bus",
-            })
+        expect(transport.send).toHaveBeenCalledTimes(1)
+        expect(transport.wait).toHaveBeenCalledWith(100)
+        expect(logger.error).toHaveBeenCalledWith(OutboxLogEvent.RelayFailed, failure, {
+            outbox: "event-bus",
         })
     })
 })

package/templates/be/patterns/event-bus/platform/event-relay.service.ts.tpl

@@ -5,6 +5,7 @@ import type { Clock } from "@modules/platform/clock"
 import { InjectLogger } from "@modules/platform/logging"
 import type { Logger } from "@modules/platform/logging"
 import { OutboxRelayPolicy } from "@modules/platform/outbox"
+import { isRecord } from "@modules/platform/primitives"
 import { InjectEventBusOptions, InjectEventRelayManagers, InjectEventTransport } from "./event-bus.decorators"
 import type { EventBusOptions } from "./event-bus.options"
 import type { EventTransport, OutboundMessage } from "./event-transport.port"
@@ -12,12 +13,15 @@ import { MARK_ROWS_SENT, SELECT_WAITING_ROWS } from "./persistence/event-bus.sql
 import type { OutboxRow } from "./persistence/event-bus.rows"
 
 /** The message the broker receives for one outbox row. */
-const messageOf = (row: OutboxRow): OutboundMessage => ({
-    topic: row.topic,
-    key: row.message_key,
-    value: JSON.stringify(row.envelope),
-    headers: {},
-})
+const messageOf = (row: OutboxRow): OutboundMessage => {
+    const metadata = "metadata" in row.envelope && isRecord(row.envelope.metadata) ? row.envelope.metadata : {}
+    return {
+        topic: row.topic,
+        key: row.message_key,
+        value: JSON.stringify({ ...row.envelope, metadata: { ...metadata, correlationId: row.correlation_id } }),
+        headers: { "x-request-id": row.correlation_id },
+    }
+}
 
 @Injectable()
 /**