bunsane 0.2.9 → 0.3.0

package/tests/integration/remote/dlq.test.ts

@@ -0,0 +1,175 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { RemoteManager } from "../../../core/remote/RemoteManager";
+import { MockRedisStreamServer } from "../../helpers/MockRedisStreamServer";
+import { createMockRedisFactory } from "../../helpers/MockRedisClient";
+
+const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe("Dead Letter Queue", () => {
+    let server: MockRedisStreamServer;
+    let producer: RemoteManager;
+
+    beforeEach(async () => {
+        server = new MockRedisStreamServer();
+        producer = new RemoteManager({
+            appName: "prod",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 30,
+            autoClaimIdleMs: 0,
+            shutdownDrainMs: 100,
+        });
+        await producer.start();
+    });
+
+    afterEach(async () => {
+        await producer.shutdown();
+    });
+
+    test("poison message routed to DLQ after second delivery", async () => {
+        // Consumer 1: handler fails → message stays in PEL with deliveryCount=1
+        const c1 = new RemoteManager({
+            appName: "cons",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 30,
+            autoClaimIdleMs: 0,
+            dlqMaxDeliveries: 2,
+            shutdownDrainMs: 100,
+        });
+        await c1.start();
+        c1.on(
+            "poison",
+            async () => {
+                throw new Error("always fails");
+            },
+            "h1"
+        );
+        await producer.emit("cons", "poison", { bad: true });
+        await wait(200);
+        expect(server.getPelSize("remote:cons", "cons")).toBe(1);
+        await c1.shutdown();
+
+        // Consumer 2: autoClaimIdleMs > 0 triggers XAUTOCLAIM on startup →
+        // claims the orphan, deliveryCount becomes 2 → DLQ check fires.
+        const c2 = new RemoteManager({
+            appName: "cons",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 30,
+            autoClaimIdleMs: 1,
+            dlqMaxDeliveries: 2,
+            shutdownDrainMs: 100,
+            enableLogging: true,
+        });
+        await c2.start();
+        c2.on(
+            "poison",
+            async () => {
+                throw new Error("still fails");
+            },
+            "h1"
+        );
+        await wait(300);
+
+        expect(server.getStreamLength("remote:cons:dlq")).toBe(1);
+        const snap = c2.getMetrics();
+        expect(snap.events.dlq).toBe(1);
+
+        await c2.shutdown();
+    });
+
+    test("dlqMaxDeliveries=0 disables DLQ routing", async () => {
+        const c1 = new RemoteManager({
+            appName: "cons2",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 30,
+            autoClaimIdleMs: 0,
+            dlqMaxDeliveries: 0,
+            shutdownDrainMs: 100,
+        });
+        await c1.start();
+        c1.on(
+            "fail",
+            async () => {
+                throw new Error("x");
+            },
+            "h1"
+        );
+        await producer.emit("cons2", "fail", {});
+        await wait(200);
+        await c1.shutdown();
+
+        const c2 = new RemoteManager({
+            appName: "cons2",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 30,
+            autoClaimIdleMs: 1,
+            dlqMaxDeliveries: 0,
+            shutdownDrainMs: 100,
+        });
+        await c2.start();
+        c2.on(
+            "fail",
+            async () => {
+                throw new Error("x");
+            },
+            "h1"
+        );
+        await wait(300);
+
+        expect(server.getStreamLength("remote:cons2:dlq")).toBe(0);
+
+        await c2.shutdown();
+    });
+
+    test("DLQ entry carries original_id + delivery_count metadata", async () => {
+        const c1 = new RemoteManager({
+            appName: "cons3",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 30,
+            autoClaimIdleMs: 0,
+            dlqMaxDeliveries: 2,
+            shutdownDrainMs: 100,
+        });
+        await c1.start();
+        c1.on(
+            "p",
+            async () => {
+                throw new Error("x");
+            },
+            "h1"
+        );
+        await producer.emit("cons3", "p", {});
+        await wait(200);
+        await c1.shutdown();
+
+        const c2 = new RemoteManager({
+            appName: "cons3",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 30,
+            autoClaimIdleMs: 1,
+            dlqMaxDeliveries: 2,
+            shutdownDrainMs: 100,
+        });
+        await c2.start();
+        c2.on(
+            "p",
+            async () => {
+                throw new Error("x");
+            },
+            "h1"
+        );
+        await wait(300);
+
+        const dlqEntries = server.xrange("remote:cons3:dlq", "-", "+");
+        expect(dlqEntries.length).toBe(1);
+        const [, fields] = dlqEntries[0]!;
+        // fields = [k1, v1, k2, v2, ...]
+        const flat = fields as string[];
+        const idx = (k: string) => flat.indexOf(k);
+        expect(idx("original_id")).toBeGreaterThanOrEqual(0);
+        expect(idx("delivery_count")).toBeGreaterThanOrEqual(0);
+        expect(idx("moved_at")).toBeGreaterThanOrEqual(0);
+        expect(idx("data")).toBeGreaterThanOrEqual(0);
+
+        await c2.shutdown();
+    });
+});

package/tests/integration/remote/event-dispatch.test.ts

@@ -0,0 +1,114 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { RemoteManager } from "../../../core/remote/RemoteManager";
+import { MockRedisStreamServer } from "../../helpers/MockRedisStreamServer";
+import { createMockRedisFactory } from "../../helpers/MockRedisClient";
+
+const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe("Event round-trip over mock Redis", () => {
+    let server: MockRedisStreamServer;
+    let appA: RemoteManager;
+    let appB: RemoteManager;
+
+    beforeEach(async () => {
+        server = new MockRedisStreamServer();
+        appA = new RemoteManager({
+            appName: "app-a",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 50,
+            autoClaimIdleMs: 0, // skip orphan reclaim
+            dlqMaxDeliveries: 0, // no DLQ for basic tests
+        });
+        appB = new RemoteManager({
+            appName: "app-b",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 50,
+            autoClaimIdleMs: 0,
+            dlqMaxDeliveries: 0,
+        });
+        await appA.start();
+        await appB.start();
+    });
+
+    afterEach(async () => {
+        await appA.shutdown();
+        await appB.shutdown();
+    });
+
+    test("emit from A is received by B's handler", async () => {
+        const received: any[] = [];
+        appB.on(
+            "order.created",
+            async (data, ctx) => {
+                received.push({ data, sourceApp: ctx.sourceApp });
+            },
+            "h1"
+        );
+
+        await appA.emit("app-b", "order.created", { orderId: "abc" });
+        await wait(150);
+
+        expect(received).toHaveLength(1);
+        expect(received[0].data).toEqual({ orderId: "abc" });
+        expect(received[0].sourceApp).toBe("app-a");
+    });
+
+    test("handler receives ctx.attempt=1 on first delivery", async () => {
+        const attempts: number[] = [];
+        appB.on(
+            "x",
+            async (_data, ctx) => {
+                attempts.push(ctx.attempt);
+            },
+            "h1"
+        );
+        await appA.emit("app-b", "x", {});
+        await wait(150);
+        expect(attempts).toEqual([1]);
+    });
+
+    test("no-handler event is ACKed silently", async () => {
+        await appA.emit("app-b", "unhandled.event", {});
+        await wait(150);
+        // PEL should be empty after ACK
+        expect(server.getPelSize("remote:app-b", "app-b")).toBe(0);
+        const snap = appB.getMetrics();
+        expect(snap.events.noHandler).toBeGreaterThan(0);
+    });
+
+    test("multiple handlers all fire for one event", async () => {
+        const log: string[] = [];
+        appB.on("e", async () => { log.push("h1"); }, "h1");
+        appB.on("e", async () => { log.push("h2"); }, "h2");
+        await appA.emit("app-b", "e", {});
+        await wait(150);
+        expect(log.sort()).toEqual(["h1", "h2"]);
+    });
+
+    test("handler failure leaves message in PEL (no ACK)", async () => {
+        appB.on(
+            "fail",
+            async () => {
+                throw new Error("handler boom");
+            },
+            "h1"
+        );
+        await appA.emit("app-b", "fail", {});
+        await wait(150);
+        expect(server.getPelSize("remote:app-b", "app-b")).toBe(1);
+        const snap = appB.getMetrics();
+        expect(snap.events.handlerFailed).toBe(1);
+    });
+
+    test("metrics reflect emit + receive counters", async () => {
+        appB.on("m", async () => {}, "h1");
+        await appA.emit("app-b", "m", {});
+        await appA.emit("app-b", "m", {});
+        await wait(200);
+
+        const aSnap = appA.getMetrics();
+        const bSnap = appB.getMetrics();
+        expect(aSnap.emit.direct).toBe(2);
+        expect(bSnap.events.handled).toBe(2);
+    });
+});

package/tests/integration/remote/outbox.test.ts

@@ -0,0 +1,130 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { RemoteManager } from "../../../core/remote/RemoteManager";
+import { MockRedisStreamServer } from "../../helpers/MockRedisStreamServer";
+import { createMockRedisFactory } from "../../helpers/MockRedisClient";
+import db from "../../../database";
+
+const wait = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe("Transactional Outbox", () => {
+    let server: MockRedisStreamServer;
+    let app: RemoteManager;
+
+    beforeEach(async () => {
+        // Clear any residual outbox rows from earlier tests
+        try {
+            await db`DELETE FROM remote_outbox`;
+        } catch {
+            /* table may not exist yet */
+        }
+        server = new MockRedisStreamServer();
+        app = new RemoteManager({
+            appName: "app",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 30,
+            autoClaimIdleMs: 0,
+            dlqMaxDeliveries: 0,
+            shutdownDrainMs: 100,
+            enableOutbox: true,
+            outboxPollIntervalMs: 50,
+            outboxBatchSize: 10,
+        });
+        await app.start();
+    });
+
+    afterEach(async () => {
+        await app.shutdown();
+    });
+
+    test("emit({ trx }) inserts outbox row within transaction", async () => {
+        await (db as any).begin(async (trx: any) => {
+            const id = await app.emit(
+                "downstream",
+                "order.created",
+                { orderId: "abc" },
+                { trx }
+            );
+            expect(id).toBeDefined();
+        });
+
+        const rows = await db`
+            SELECT target, event, data, published_at
+            FROM remote_outbox
+        `;
+        expect(rows.length).toBe(1);
+        expect(rows[0]!.target).toBe("downstream");
+        expect(rows[0]!.event).toBe("order.created");
+    });
+
+    test("worker publishes committed rows to Redis + marks published_at", async () => {
+        await (db as any).begin(async (trx: any) => {
+            await app.emit(
+                "downstream",
+                "published.event",
+                { n: 1 },
+                { trx }
+            );
+        });
+        await wait(200); // allow at least one poll tick
+
+        // Row should now be marked published
+        const rows = await db`
+            SELECT published_at FROM remote_outbox
+            WHERE event = 'published.event'
+        `;
+        expect(rows[0]!.published_at).not.toBeNull();
+
+        // Stream should have the message
+        expect(server.getStreamLength("remote:downstream")).toBeGreaterThanOrEqual(
+            1
+        );
+    });
+
+    test("rolled-back transaction suppresses publish", async () => {
+        try {
+            await (db as any).begin(async (trx: any) => {
+                await app.emit(
+                    "downstream",
+                    "rolled.back",
+                    { n: 2 },
+                    { trx }
+                );
+                throw new Error("force rollback");
+            });
+        } catch {
+            /* expected */
+        }
+        await wait(200);
+
+        const rows = await db`
+            SELECT COUNT(*)::int AS c FROM remote_outbox
+            WHERE event = 'rolled.back'
+        `;
+        expect(rows[0]!.c).toBe(0);
+        expect(server.getStreamLength("remote:downstream")).toBe(0);
+    });
+
+    test("direct emit + outbox emit hit same target stream", async () => {
+        await app.emit("other", "direct", { n: "a" });
+        await (db as any).begin(async (trx: any) => {
+            await app.emit("other", "outbox", { n: "b" }, { trx });
+        });
+        await wait(200);
+
+        const entries = server.xrange("remote:other", "-", "+");
+        expect(entries.length).toBe(2);
+    });
+
+    test("metrics count emit.direct vs emit.outbox separately", async () => {
+        await app.emit("dst", "direct", {});
+        await (db as any).begin(async (trx: any) => {
+            await app.emit("dst", "outbox", {}, { trx });
+        });
+        await wait(150);
+
+        const snap = app.getMetrics();
+        expect(snap.emit.direct).toBe(1);
+        expect(snap.emit.outbox).toBe(1);
+        expect(snap.outbox.published).toBeGreaterThanOrEqual(1);
+    });
+});

package/tests/integration/remote/rpc.test.ts

@@ -0,0 +1,177 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { RemoteManager } from "../../../core/remote/RemoteManager";
+import { RemoteError } from "../../../core/remote/types";
+import { MockRedisStreamServer } from "../../helpers/MockRedisStreamServer";
+import { createMockRedisFactory } from "../../helpers/MockRedisClient";
+
+describe("RPC round-trip", () => {
+    let server: MockRedisStreamServer;
+    let client: RemoteManager;
+    let server_app: RemoteManager;
+
+    beforeEach(async () => {
+        server = new MockRedisStreamServer();
+        client = new RemoteManager({
+            appName: "client-app",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 50,
+            autoClaimIdleMs: 0,
+            dlqMaxDeliveries: 0,
+            shutdownDrainMs: 100,
+            defaultCallTimeout: 1000,
+        });
+        server_app = new RemoteManager({
+            appName: "server-app",
+            redisFactory: createMockRedisFactory(server),
+            blockMs: 50,
+            autoClaimIdleMs: 0,
+            dlqMaxDeliveries: 0,
+            shutdownDrainMs: 100,
+        });
+        await client.start();
+        await server_app.start();
+    });
+
+    afterEach(async () => {
+        await client.shutdown();
+        await server_app.shutdown();
+    });
+
+    test("call() returns handler result", async () => {
+        server_app.onRpc(
+            "order.get",
+            async (data: any) => ({ id: data.id, status: "ok" }),
+            "h1"
+        );
+        const result = await client.call<{ id: string; status: string }>(
+            "server-app",
+            "order.get",
+            { id: "abc" }
+        );
+        expect(result).toEqual({ id: "abc", status: "ok" });
+    });
+
+    test("call() rejects with TIMEOUT when no handler registered", async () => {
+        // server_app has no handler — still returns NOT_FOUND, not TIMEOUT
+        try {
+            await client.call(
+                "server-app",
+                "nonexistent.method",
+                {},
+                { timeout: 500 }
+            );
+            throw new Error("expected throw");
+        } catch (err) {
+            expect(err).toBeInstanceOf(RemoteError);
+            expect((err as RemoteError).code).toBe("NOT_FOUND");
+        }
+    });
+
+    test("call() rejects with TIMEOUT when target app down", async () => {
+        // Kill server_app — no consumer for the request stream
+        await server_app.shutdown();
+        try {
+            await client.call(
+                "server-app",
+                "anything",
+                {},
+                { timeout: 200 }
+            );
+            throw new Error("expected throw");
+        } catch (err) {
+            expect(err).toBeInstanceOf(RemoteError);
+            expect((err as RemoteError).code).toBe("TIMEOUT");
+        }
+    });
+
+    test("call() to broadcast target * rejects INVALID_TARGET", async () => {
+        try {
+            await client.call("*", "anything", {});
+            throw new Error("expected throw");
+        } catch (err) {
+            expect(err).toBeInstanceOf(RemoteError);
+            expect((err as RemoteError).code).toBe("INVALID_TARGET");
+        }
+    });
+
+    test("handler exception propagates as HANDLER_ERROR", async () => {
+        server_app.onRpc(
+            "fail",
+            async () => {
+                throw new Error("something bad");
+            },
+            "h1"
+        );
+        try {
+            await client.call("server-app", "fail", {});
+            throw new Error("expected throw");
+        } catch (err) {
+            expect(err).toBeInstanceOf(RemoteError);
+            expect((err as RemoteError).code).toBe("HANDLER_ERROR");
+        }
+    });
+
+    test("handler custom RemoteError code flows through", async () => {
+        server_app.onRpc(
+            "forbidden",
+            async () => {
+                throw new RemoteError("no", {
+                    code: "FORBIDDEN",
+                    extensions: { reason: "test" },
+                });
+            },
+            "h1"
+        );
+        try {
+            await client.call("server-app", "forbidden", {});
+            throw new Error("expected throw");
+        } catch (err) {
+            expect(err).toBeInstanceOf(RemoteError);
+            const re = err as RemoteError;
+            expect(re.code).toBe("FORBIDDEN");
+            expect(re.extensions).toEqual({ reason: "test" });
+        }
+    });
+
+    test("ctx carries correlationId + deadline", async () => {
+        let captured: any = null;
+        server_app.onRpc(
+            "ctx-check",
+            async (_data, ctx) => {
+                captured = {
+                    correlationId: ctx.correlationId,
+                    deadline: ctx.deadline,
+                    sourceApp: ctx.sourceApp,
+                };
+                return null;
+            },
+            "h1"
+        );
+        await client.call("server-app", "ctx-check", {}, { timeout: 2000 });
+        expect(captured.correlationId).toMatch(/^[0-9a-f-]{36}$/);
+        expect(captured.deadline).toBeInstanceOf(Date);
+        expect(captured.sourceApp).toBe("client-app");
+    });
+
+    test("metrics track successful + failed RPCs", async () => {
+        server_app.onRpc("ok", async () => "x", "h1");
+        server_app.onRpc(
+            "bad",
+            async () => {
+                throw new Error("x");
+            },
+            "h2"
+        );
+        await client.call("server-app", "ok", {});
+        await client.call("server-app", "bad", {}).catch(() => {});
+
+        const clientSnap = client.getMetrics();
+        expect(clientSnap.rpc.called).toBe(2);
+        expect(clientSnap.rpc.succeeded).toBe(1);
+        expect(clientSnap.rpc.failed).toBe(1);
+
+        const serverSnap = server_app.getMetrics();
+        expect(serverSnap.rpc.handlerExecuted).toBe(1);
+        expect(serverSnap.rpc.handlerFailed).toBe(1);
+    });
+});