bunsane 0.2.8 → 0.2.10

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);
+    });
+});

package/tests/pglite-setup.ts

@@ -35,6 +35,7 @@ const proc = spawn('bun', ['test', ...testDirs], {
     env: {
         ...process.env,
         USE_PGLITE: 'true',
+        DB_CONNECTION_URL: '', // Clear to use POSTGRES_* vars
         POSTGRES_HOST: 'localhost',
         POSTGRES_PORT: String(PORT),
         POSTGRES_USER: 'postgres',

package/tests/unit/query/JsonbArrayBuilder.test.ts

@@ -0,0 +1,178 @@
+/**
+ * Unit tests for JSONB Array Filter Builders
+ */
+import { describe, test, expect } from 'bun:test';
+import { buildJSONBPath } from '../../../query/FilterBuilder';
+import { QueryContext } from '../../../query/QueryContext';
+import {
+    jsonbContainsBuilder,
+    jsonbContainedByBuilder,
+    jsonbHasAnyBuilder,
+    jsonbHasAllBuilder,
+    jsonbArrayOptions,
+} from '../../../query/builders/JsonbArrayBuilder';
+
+describe('buildJSONBPath', () => {
+    test('simple field returns JSONB node path', () => {
+        expect(buildJSONBPath('tags', 'c')).toBe("c.data->'tags'");
+    });
+
+    test('nested field returns JSONB node path', () => {
+        expect(buildJSONBPath('metadata.tags', 'c')).toBe("c.data->'metadata'->'tags'");
+    });
+
+    test('deeply nested field', () => {
+        expect(buildJSONBPath('a.b.c', 'c')).toBe("c.data->'a'->'b'->'c'");
+    });
+
+    test('uses provided alias', () => {
+        expect(buildJSONBPath('tags', 'comp')).toBe("comp.data->'tags'");
+    });
+});
+
+describe('jsonbContainsBuilder (@>)', () => {
+    test('single string value is auto-wrapped in array', () => {
+        const ctx = new QueryContext();
+        const result = jsonbContainsBuilder(
+            { field: 'tags', operator: 'CONTAINS', value: 'urgent' },
+            'c', ctx
+        );
+        expect(result.sql).toBe("c.data->'tags' @> $1::jsonb");
+        expect(ctx.params[0]).toEqual(['urgent']);
+        expect(result.addedParams).toBe(1);
+    });
+
+    test('array value is passed as raw array', () => {
+        const ctx = new QueryContext();
+        const result = jsonbContainsBuilder(
+            { field: 'tags', operator: 'CONTAINS', value: ['a', 'b'] },
+            'c', ctx
+        );
+        expect(result.sql).toBe("c.data->'tags' @> $1::jsonb");
+        expect(ctx.params[0]).toEqual(['a', 'b']);
+    });
+
+    test('nested field path', () => {
+        const ctx = new QueryContext();
+        const result = jsonbContainsBuilder(
+            { field: 'meta.tags', operator: 'CONTAINS', value: 'x' },
+            'c', ctx
+        );
+        expect(result.sql).toBe("c.data->'meta'->'tags' @> $1::jsonb");
+    });
+
+    test('numeric value', () => {
+        const ctx = new QueryContext();
+        jsonbContainsBuilder(
+            { field: 'scores', operator: 'CONTAINS', value: 42 },
+            'c', ctx
+        );
+        expect(ctx.params[0]).toEqual([42]);
+    });
+});
+
+describe('jsonbContainedByBuilder (<@)', () => {
+    test('generates correct SQL', () => {
+        const ctx = new QueryContext();
+        const result = jsonbContainedByBuilder(
+            { field: 'tags', operator: 'CONTAINED_BY', value: ['a', 'b', 'c'] },
+            'c', ctx
+        );
+        expect(result.sql).toBe("c.data->'tags' <@ $1::jsonb");
+        expect(ctx.params[0]).toEqual(['a', 'b', 'c']);
+        expect(result.addedParams).toBe(1);
+    });
+
+    test('single value is auto-wrapped', () => {
+        const ctx = new QueryContext();
+        jsonbContainedByBuilder(
+            { field: 'tags', operator: 'CONTAINED_BY', value: 'only' },
+            'c', ctx
+        );
+        expect(ctx.params[0]).toEqual(['only']);
+    });
+});
+
+describe('jsonbHasAnyBuilder (?|)', () => {
+    test('generates correct SQL with text[] cast', () => {
+        const ctx = new QueryContext();
+        const result = jsonbHasAnyBuilder(
+            { field: 'tags', operator: 'HAS_ANY', value: ['a', 'b'] },
+            'c', ctx
+        );
+        expect(result.sql).toBe("c.data->'tags' ?| $1::text[]");
+        expect(ctx.params[0]).toEqual(['a', 'b']);
+        expect(result.addedParams).toBe(1);
+    });
+
+    test('single value is auto-wrapped and stringified', () => {
+        const ctx = new QueryContext();
+        jsonbHasAnyBuilder(
+            { field: 'tags', operator: 'HAS_ANY', value: 'solo' },
+            'c', ctx
+        );
+        expect(ctx.params[0]).toEqual(['solo']);
+    });
+
+    test('numeric values are cast to strings', () => {
+        const ctx = new QueryContext();
+        jsonbHasAnyBuilder(
+            { field: 'ids', operator: 'HAS_ANY', value: [1, 2, 3] },
+            'c', ctx
+        );
+        expect(ctx.params[0]).toEqual(['1', '2', '3']);
+    });
+});
+
+describe('jsonbHasAllBuilder (?&)', () => {
+    test('generates correct SQL with text[] cast', () => {
+        const ctx = new QueryContext();
+        const result = jsonbHasAllBuilder(
+            { field: 'tags', operator: 'HAS_ALL', value: ['x', 'y'] },
+            'c', ctx
+        );
+        expect(result.sql).toBe("c.data->'tags' ?& $1::text[]");
+        expect(ctx.params[0]).toEqual(['x', 'y']);
+        expect(result.addedParams).toBe(1);
+    });
+});
+
+describe('validation', () => {
+    const validate = jsonbArrayOptions.validate!;
+
+    test('rejects null value', () => {
+        expect(validate({ field: 'f', operator: 'CONTAINS', value: null })).toBe(false);
+    });
+
+    test('rejects undefined value', () => {
+        expect(validate({ field: 'f', operator: 'CONTAINS', value: undefined })).toBe(false);
+    });
+
+    test('rejects empty array', () => {
+        expect(validate({ field: 'f', operator: 'CONTAINS', value: [] })).toBe(false);
+    });
+
+    test('accepts string value', () => {
+        expect(validate({ field: 'f', operator: 'CONTAINS', value: 'tag' })).toBe(true);
+    });
+
+    test('accepts number value', () => {
+        expect(validate({ field: 'f', operator: 'CONTAINS', value: 42 })).toBe(true);
+    });
+
+    test('accepts boolean value', () => {
+        expect(validate({ field: 'f', operator: 'CONTAINS', value: true })).toBe(true);
+    });
+
+    test('accepts array of strings', () => {
+        expect(validate({ field: 'f', operator: 'CONTAINS', value: ['a', 'b'] })).toBe(true);
+    });
+
+    test('rejects object value', () => {
+        expect(validate({ field: 'f', operator: 'CONTAINS', value: { key: 'val' } })).toBe(false);
+    });
+
+    test('rejects array with non-primitive elements', () => {
+        expect(validate({ field: 'f', operator: 'CONTAINS', value: [{ a: 1 }] })).toBe(false);
+    });
+});

package/tests/unit/remote/CircuitBreaker.test.ts

@@ -0,0 +1,159 @@
+import { describe, test, expect } from "bun:test";
+import {
+    CircuitBreaker,
+    CircuitOpenError,
+} from "../../../core/remote/CircuitBreaker";
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+describe("CircuitBreaker", () => {
+    describe("state transitions", () => {
+        test("starts closed", () => {
+            const cb = new CircuitBreaker();
+            expect(cb.getState()).toBe("closed");
+        });
+
+        test("stays closed below threshold", () => {
+            const cb = new CircuitBreaker({ threshold: 3 });
+            cb.recordFailure();
+            cb.recordFailure();
+            expect(cb.getState()).toBe("closed");
+        });
+
+        test("opens at threshold", () => {
+            const cb = new CircuitBreaker({ threshold: 3 });
+            cb.recordFailure();
+            cb.recordFailure();
+            cb.recordFailure();
+            expect(cb.getState()).toBe("open");
+        });
+
+        test("transitions to half-open after reset window", async () => {
+            const cb = new CircuitBreaker({ threshold: 1, resetTimeoutMs: 50 });
+            cb.recordFailure();
+            expect(cb.getState()).toBe("open");
+            await sleep(60);
+            expect(cb.getState()).toBe("half-open");
+        });
+
+        test("half-open success closes breaker", async () => {
+            const cb = new CircuitBreaker({ threshold: 1, resetTimeoutMs: 50 });
+            cb.recordFailure();
+            await sleep(60);
+            expect(cb.getState()).toBe("half-open");
+            cb.recordSuccess();
+            expect(cb.getState()).toBe("closed");
+        });
+
+        test("half-open failure reopens breaker", async () => {
+            const cb = new CircuitBreaker({ threshold: 1, resetTimeoutMs: 50 });
+            cb.recordFailure();
+            await sleep(60);
+            expect(cb.getState()).toBe("half-open");
+            cb.recordFailure();
+            expect(cb.getState()).toBe("open");
+        });
+
+        test("success in closed state zeroes failure count", () => {
+            const cb = new CircuitBreaker({ threshold: 3 });
+            cb.recordFailure();
+            cb.recordFailure();
+            cb.recordSuccess();
+            cb.recordFailure();
+            cb.recordFailure();
+            // Still closed — counter reset to 0 on success, only 2 new failures
+            expect(cb.getState()).toBe("closed");
+        });
+    });
+
+    describe("exec()", () => {
+        test("passes result on success", async () => {
+            const cb = new CircuitBreaker();
+            const result = await cb.exec(async () => 42);
+            expect(result).toBe(42);
+        });
+
+        test("records failure on thrown error", async () => {
+            const cb = new CircuitBreaker({ threshold: 2 });
+            await expect(
+                cb.exec(async () => {
+                    throw new Error("boom");
+                })
+            ).rejects.toThrow("boom");
+            expect(cb.getStats().failures).toBe(1);
+        });
+
+        test("rejects immediately when open", async () => {
+            const cb = new CircuitBreaker({ threshold: 1 });
+            await expect(
+                cb.exec(async () => {
+                    throw new Error("fail");
+                })
+            ).rejects.toThrow();
+            // Now open
+            await expect(cb.exec(async () => "should not run")).rejects.toBeInstanceOf(
+                CircuitOpenError
+            );
+        });
+
+        test("open-state rejection does not call fn", async () => {
+            const cb = new CircuitBreaker({ threshold: 1 });
+            await cb.exec(async () => { throw new Error("x"); }).catch(() => {});
+            let called = false;
+            await cb.exec(async () => { called = true; }).catch(() => {});
+            expect(called).toBe(false);
+        });
+    });
+
+    describe("hooks", () => {
+        test("onTrip fires once when opening", () => {
+            const cb = new CircuitBreaker({ threshold: 2 });
+            let trips = 0;
+            cb.onTrip = () => trips++;
+            cb.recordFailure();
+            expect(trips).toBe(0);
+            cb.recordFailure();
+            expect(trips).toBe(1);
+        });
+
+        test("onTrip fires again on half-open→open transition", async () => {
+            const cb = new CircuitBreaker({ threshold: 1, resetTimeoutMs: 30 });
+            let trips = 0;
+            cb.onTrip = () => trips++;
+            cb.recordFailure();
+            expect(trips).toBe(1);
+            await sleep(40);
+            // half-open trial fails
+            cb.recordFailure();
+            expect(trips).toBe(2);
+        });
+
+        test("onReject fires when exec rejected by open breaker", async () => {
+            const cb = new CircuitBreaker({ threshold: 1 });
+            let rejects = 0;
+            cb.onReject = () => rejects++;
+            await cb.exec(async () => { throw new Error("x"); }).catch(() => {});
+            await cb.exec(async () => 1).catch(() => {});
+            expect(rejects).toBe(1);
+        });
+    });
+
+    describe("reset()", () => {
+        test("force-closes an open breaker", () => {
+            const cb = new CircuitBreaker({ threshold: 1 });
+            cb.recordFailure();
+            expect(cb.getState()).toBe("open");
+            cb.reset();
+            expect(cb.getState()).toBe("closed");
+            expect(cb.getStats().failures).toBe(0);
+        });
+    });
+
+    describe("CircuitOpenError", () => {
+        test("has CIRCUIT_OPEN code", () => {
+            const err = new CircuitOpenError();
+            expect(err.code).toBe("CIRCUIT_OPEN");
+            expect(err).toBeInstanceOf(Error);
+        });
+    });
+});