@blokjs/trigger-pubsub 0.2.3 → 0.6.2

package/dist/adapters/NATSPubSubAdapter.d.ts

@@ -0,0 +1,52 @@
+/**
+ * NATSPubSubAdapter — v0.7 PR 6 — Pub/Sub adapter backed by NATS.
+ *
+ * Two modes:
+ *   - **Fan-out** (default, when `consumerGroup` is absent): every
+ *     subscriber receives every message on the subject. NATS Core
+ *     publish/subscribe semantics — cheapest path, no persistence.
+ *   - **Competing-consumer** (when `consumerGroup` is set): NATS
+ *     Queue Group — exactly one subscriber in the named group
+ *     receives each message. Pure NATS Core.
+ *   - **Durable** (when `durable: true`): subscribe via NATS
+ *     JetStream consumer so the subscription survives restarts and
+ *     replays missed messages from `startFrom`. Required for the
+ *     `{seq}` / `{timestamp}` replay cursors.
+ *
+ * Subject wildcards (`orders.*.created`, `orders.>`) are honored by
+ * NATS natively in both modes.
+ *
+ * Requires `nats` as a peer dependency:
+ *
+ *     bun add nats
+ *
+ * Environment variables:
+ *   - `NATS_SERVERS`   — comma-separated URLs (default `localhost:4222`).
+ *   - `NATS_TOKEN`     — bearer token authentication.
+ *   - `NATS_USER` / `NATS_PASS`  — userpass authentication.
+ */
+import type { PubSubTriggerOpts } from "@blokjs/helper";
+import type { PubSubAdapter, PubSubMessage } from "../PubSubTrigger";
+export interface NATSPubSubConfig {
+    servers: string[];
+    token?: string;
+    user?: string;
+    pass?: string;
+}
+export declare class NATSPubSubAdapter implements PubSubAdapter {
+    readonly provider: "nats";
+    private readonly config;
+    private conn;
+    private subscriptions;
+    private connected;
+    constructor(config?: Partial<NATSPubSubConfig>);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    subscribe(config: PubSubTriggerOpts, handler: (message: PubSubMessage) => Promise<void>): Promise<void>;
+    private dispatchJsMessage;
+    private dispatchCoreMessage;
+    unsubscribe(subscription: string): Promise<void>;
+    publish(topic: string, payload: unknown): Promise<void>;
+    isConnected(): boolean;
+    healthCheck(): Promise<boolean>;
+}

package/dist/adapters/NATSPubSubAdapter.js

@@ -0,0 +1,260 @@
+/**
+ * NATSPubSubAdapter — v0.7 PR 6 — Pub/Sub adapter backed by NATS.
+ *
+ * Two modes:
+ *   - **Fan-out** (default, when `consumerGroup` is absent): every
+ *     subscriber receives every message on the subject. NATS Core
+ *     publish/subscribe semantics — cheapest path, no persistence.
+ *   - **Competing-consumer** (when `consumerGroup` is set): NATS
+ *     Queue Group — exactly one subscriber in the named group
+ *     receives each message. Pure NATS Core.
+ *   - **Durable** (when `durable: true`): subscribe via NATS
+ *     JetStream consumer so the subscription survives restarts and
+ *     replays missed messages from `startFrom`. Required for the
+ *     `{seq}` / `{timestamp}` replay cursors.
+ *
+ * Subject wildcards (`orders.*.created`, `orders.>`) are honored by
+ * NATS natively in both modes.
+ *
+ * Requires `nats` as a peer dependency:
+ *
+ *     bun add nats
+ *
+ * Environment variables:
+ *   - `NATS_SERVERS`   — comma-separated URLs (default `localhost:4222`).
+ *   - `NATS_TOKEN`     — bearer token authentication.
+ *   - `NATS_USER` / `NATS_PASS`  — userpass authentication.
+ */
+import { v4 as uuid } from "uuid";
+const TEXT_DECODER = new TextDecoder();
+const TEXT_ENCODER = new TextEncoder();
+export class NATSPubSubAdapter {
+    provider = "nats";
+    config;
+    conn = null;
+    subscriptions = new Map();
+    connected = false;
+    constructor(config) {
+        this.config = {
+            servers: config?.servers ?? (process.env.NATS_SERVERS ?? "localhost:4222").split(",").map((s) => s.trim()),
+            token: config?.token ?? process.env.NATS_TOKEN,
+            user: config?.user ?? process.env.NATS_USER,
+            pass: config?.pass ?? process.env.NATS_PASS,
+        };
+    }
+    async connect() {
+        if (this.connected)
+            return;
+        try {
+            // biome-ignore lint/suspicious/noExplicitAny: nats is a runtime peer dep.
+            const nats = await import("nats");
+            this.conn = (await nats.connect({
+                servers: this.config.servers,
+                token: this.config.token,
+                user: this.config.user,
+                pass: this.config.pass,
+            }));
+            this.connected = true;
+        }
+        catch (err) {
+            throw new Error(`[blok][pubsub-nats] connect failed: ${err.message}. Install nats as a peer dependency: bun add nats`);
+        }
+    }
+    async disconnect() {
+        if (!this.connected)
+            return;
+        for (const sub of this.subscriptions.values()) {
+            try {
+                const result = sub.unsubscribe();
+                if (result instanceof Promise)
+                    await result;
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        this.subscriptions.clear();
+        try {
+            await this.conn?.drain();
+        }
+        catch {
+            /* ignore */
+        }
+        this.conn = null;
+        this.connected = false;
+    }
+    async subscribe(config, handler) {
+        if (!this.connected || !this.conn)
+            throw new Error("[blok][pubsub-nats] not connected. Call connect() first.");
+        const subKey = `${config.topic}#${config.consumerGroup ?? ""}`;
+        if (config.durable === true) {
+            // JetStream durable subscription — survives restarts.
+            if (!this.conn.jetstream) {
+                throw new Error("[blok][pubsub-nats] durable subscriptions require JetStream support in the nats client");
+            }
+            const jsm = await this.conn.jetstreamManager?.();
+            if (jsm) {
+                // Auto-create a stream covering the subject if one doesn't
+                // exist. Production deployments should pre-provision via
+                // `nats stream add` to control retention.
+                try {
+                    await jsm.streams.add({
+                        name: `blok-${(config.topic ?? "").replace(/[^a-zA-Z0-9_]/g, "_")}`,
+                        subjects: [config.topic],
+                    });
+                }
+                catch {
+                    /* stream already exists — ignore */
+                }
+            }
+            const js = this.conn.jetstream();
+            const startSeq = typeof config.startFrom === "object" && config.startFrom && "seq" in config.startFrom
+                ? config.startFrom.seq
+                : undefined;
+            const deliverPolicy = config.startFrom === "earliest"
+                ? "all"
+                : config.startFrom === "latest"
+                    ? "new"
+                    : startSeq !== undefined
+                        ? "by_start_sequence"
+                        : "all";
+            const sub = await js.subscribe(config.topic, {
+                config: {
+                    durable_name: config.consumerGroup ??
+                        `blok-${(config.subscription ?? config.topic ?? "default").replace(/[^a-zA-Z0-9_]/g, "_")}`,
+                    deliver_policy: deliverPolicy,
+                    opt_start_seq: startSeq,
+                    ack_policy: config.ack === false ? "none" : "explicit",
+                },
+            });
+            this.subscriptions.set(subKey, { unsubscribe: () => sub.unsubscribe() });
+            // Drive the async iterator in a background loop.
+            void (async () => {
+                try {
+                    for await (const msg of sub) {
+                        await this.dispatchJsMessage(msg, config, handler);
+                    }
+                }
+                catch (err) {
+                    // Subscription closed or connection lost — let the trigger
+                    // re-listen via HMR/reconnect logic. Log for visibility.
+                    console.error(`[blok][pubsub-nats] subscription error: ${err.message}`);
+                }
+            })();
+            return;
+        }
+        // Core NATS subscription — fire-and-forget, with optional queue
+        // group for competing-consumer semantics.
+        const sub = this.conn.subscribe(config.topic, {
+            queue: config.consumerGroup,
+            callback: (err, msg) => {
+                if (err) {
+                    console.error(`[blok][pubsub-nats] subscribe error: ${err.message}`);
+                    return;
+                }
+                void this.dispatchCoreMessage(msg, config, handler);
+            },
+        });
+        this.subscriptions.set(subKey, sub);
+    }
+    async dispatchJsMessage(msg, config, handler) {
+        const text = TEXT_DECODER.decode(msg.data);
+        let body = text;
+        try {
+            body = text.length > 0 ? JSON.parse(text) : null;
+        }
+        catch {
+            /* leave as text */
+        }
+        const message = {
+            id: `${msg.info.stream}:${msg.seq}`,
+            body,
+            attributes: { subject: msg.subject },
+            raw: msg,
+            topic: msg.subject,
+            subscription: msg.info.consumer,
+            publishTime: msg.info.timestampNanos ? new Date(msg.info.timestampNanos / 1e6) : undefined,
+            ack: async () => {
+                msg.ack();
+            },
+            nack: async () => {
+                msg.nak();
+            },
+        };
+        try {
+            await handler(message);
+            if (config.ack !== false)
+                msg.ack();
+        }
+        catch {
+            msg.nak();
+        }
+    }
+    async dispatchCoreMessage(msg, _config, handler) {
+        const text = TEXT_DECODER.decode(msg.data);
+        let body = text;
+        try {
+            body = text.length > 0 ? JSON.parse(text) : null;
+        }
+        catch {
+            /* leave as text */
+        }
+        const message = {
+            id: `${msg.subject}:${msg.sid}:${uuid()}`,
+            body,
+            attributes: { subject: msg.subject },
+            raw: msg,
+            topic: msg.subject,
+            ack: async () => {
+                /* core NATS has no explicit ack */
+            },
+            nack: async () => {
+                /* core NATS has no explicit nack */
+            },
+        };
+        try {
+            await handler(message);
+        }
+        catch (err) {
+            console.error(`[blok][pubsub-nats] handler error: ${err.message}`);
+        }
+    }
+    async unsubscribe(subscription) {
+        const sub = this.subscriptions.get(subscription);
+        if (!sub)
+            return;
+        try {
+            const result = sub.unsubscribe();
+            if (result instanceof Promise)
+                await result;
+        }
+        catch {
+            /* ignore */
+        }
+        this.subscriptions.delete(subscription);
+    }
+    async publish(topic, payload) {
+        if (!this.connected || !this.conn)
+            throw new Error("[blok][pubsub-nats] not connected. Call connect() first.");
+        const body = typeof payload === "string" ? payload : JSON.stringify(payload);
+        const data = TEXT_ENCODER.encode(body);
+        // Use core NATS publish. When a durable subscriber has been
+        // installed for this subject, the subscribe() path created a
+        // JetStream stream with a subject filter that captures any
+        // publish to `topic` — so durable consumers see the message via
+        // the stream while core subscribers see it directly. The earlier
+        // "try js.publish first, fall back to core" logic caused
+        // **double-delivery**: js.publish to a subject covered by a
+        // stream goes to BOTH the stream and core subscribers, then the
+        // fallback would publish AGAIN if js.publish timed out (vs
+        // returning 503 fast). Sticking to core publish avoids the race.
+        this.conn.publish(topic, data);
+    }
+    isConnected() {
+        return this.connected;
+    }
+    async healthCheck() {
+        return this.connected;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NATSPubSubAdapter.js","sourceRoot":"","sources":["../../src/adapters/NATSPubSubAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * NATSPubSubAdapter — v0.7 PR 6 — Pub/Sub adapter backed by NATS.\n *\n * Two modes:\n *   - **Fan-out** (default, when `consumerGroup` is absent): every\n *     subscriber receives every message on the subject. NATS Core\n *     publish/subscribe semantics — cheapest path, no persistence.\n *   - **Competing-consumer** (when `consumerGroup` is set): NATS\n *     Queue Group — exactly one subscriber in the named group\n *     receives each message. Pure NATS Core.\n *   - **Durable** (when `durable: true`): subscribe via NATS\n *     JetStream consumer so the subscription survives restarts and\n *     replays missed messages from `startFrom`. Required for the\n *     `{seq}` / `{timestamp}` replay cursors.\n *\n * Subject wildcards (`orders.*.created`, `orders.>`) are honored by\n * NATS natively in both modes.\n *\n * Requires `nats` as a peer dependency:\n *\n *     bun add nats\n *\n * Environment variables:\n *   - `NATS_SERVERS`   — comma-separated URLs (default `localhost:4222`).\n *   - `NATS_TOKEN`     — bearer token authentication.\n *   - `NATS_USER` / `NATS_PASS`  — userpass authentication.\n */\n\nimport type { PubSubTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { PubSubAdapter, PubSubMessage } from \"../PubSubTrigger\";\n\nexport interface NATSPubSubConfig {\n\tservers: string[];\n\ttoken?: string;\n\tuser?: string;\n\tpass?: string;\n}\n\ninterface NatsSubscription {\n\tunsubscribe: () => void | Promise<void>;\n}\n\ninterface NatsConnection {\n\tclose: () => Promise<void>;\n\tdrain: () => Promise<void>;\n\tsubscribe: (\n\t\tsubject: string,\n\t\topts?: { queue?: string; callback?: (err: Error | null, msg: NatsMsg) => void },\n\t) => NatsSubscription;\n\tpublish: (subject: string, payload: Uint8Array) => void;\n\tjetstream?: () => NatsJetStream;\n\tjetstreamManager?: () => Promise<NatsJetStreamManager>;\n}\n\ninterface NatsJetStream {\n\tsubscribe: (\n\t\tsubject: string,\n\t\topts?: unknown,\n\t) => Promise<{\n\t\t[Symbol.asyncIterator]: () => AsyncIterator<NatsJsMsg>;\n\t\tunsubscribe: () => Promise<void> | void;\n\t}>;\n\tpublish: (subject: string, payload: Uint8Array) => Promise<unknown>;\n}\n\ninterface NatsJetStreamManager {\n\tstreams: { add: (config: unknown) => Promise<unknown>; info: (name: string) => Promise<unknown> };\n\tconsumers: { add: (stream: string, config: unknown) => Promise<unknown> };\n}\n\ninterface NatsMsg {\n\tsubject: string;\n\tdata: Uint8Array;\n\tsid: number;\n\trespond?: (data?: Uint8Array) => boolean;\n}\n\ninterface NatsJsMsg {\n\tsubject: string;\n\tdata: Uint8Array;\n\tseq: number;\n\tack: () => void;\n\tnak: (millis?: number) => void;\n\tinfo: { stream: string; consumer: string; redeliveryCount: number; timestampNanos?: number };\n}\n\nconst TEXT_DECODER = new TextDecoder();\nconst TEXT_ENCODER = new TextEncoder();\n\nexport class NATSPubSubAdapter implements PubSubAdapter {\n\treadonly provider = \"nats\" as const;\n\tprivate readonly config: NATSPubSubConfig;\n\tprivate conn: NatsConnection | null = null;\n\tprivate subscriptions: Map<string, NatsSubscription | { unsubscribe: () => Promise<void> | void }> = new Map();\n\tprivate connected = false;\n\n\tconstructor(config?: Partial<NATSPubSubConfig>) {\n\t\tthis.config = {\n\t\t\tservers: config?.servers ?? (process.env.NATS_SERVERS ?? \"localhost:4222\").split(\",\").map((s) => s.trim()),\n\t\t\ttoken: config?.token ?? process.env.NATS_TOKEN,\n\t\t\tuser: config?.user ?? process.env.NATS_USER,\n\t\t\tpass: config?.pass ?? process.env.NATS_PASS,\n\t\t};\n\t}\n\n\tasync connect(): Promise<void> {\n\t\tif (this.connected) return;\n\t\ttry {\n\t\t\t// biome-ignore lint/suspicious/noExplicitAny: nats is a runtime peer dep.\n\t\t\tconst nats: any = await import(\"nats\");\n\t\t\tthis.conn = (await nats.connect({\n\t\t\t\tservers: this.config.servers,\n\t\t\t\ttoken: this.config.token,\n\t\t\t\tuser: this.config.user,\n\t\t\t\tpass: this.config.pass,\n\t\t\t})) as NatsConnection;\n\t\t\tthis.connected = true;\n\t\t} catch (err) {\n\t\t\tthrow new Error(\n\t\t\t\t`[blok][pubsub-nats] connect failed: ${(err as Error).message}. Install nats as a peer dependency: bun add nats`,\n\t\t\t);\n\t\t}\n\t}\n\n\tasync disconnect(): Promise<void> {\n\t\tif (!this.connected) return;\n\t\tfor (const sub of this.subscriptions.values()) {\n\t\t\ttry {\n\t\t\t\tconst result = sub.unsubscribe();\n\t\t\t\tif (result instanceof Promise) await result;\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t}\n\t\tthis.subscriptions.clear();\n\t\ttry {\n\t\t\tawait this.conn?.drain();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.conn = null;\n\t\tthis.connected = false;\n\t}\n\n\tasync subscribe(config: PubSubTriggerOpts, handler: (message: PubSubMessage) => Promise<void>): Promise<void> {\n\t\tif (!this.connected || !this.conn) throw new Error(\"[blok][pubsub-nats] not connected. Call connect() first.\");\n\t\tconst subKey = `${config.topic}#${config.consumerGroup ?? \"\"}`;\n\n\t\tif (config.durable === true) {\n\t\t\t// JetStream durable subscription — survives restarts.\n\t\t\tif (!this.conn.jetstream) {\n\t\t\t\tthrow new Error(\"[blok][pubsub-nats] durable subscriptions require JetStream support in the nats client\");\n\t\t\t}\n\t\t\tconst jsm = await this.conn.jetstreamManager?.();\n\t\t\tif (jsm) {\n\t\t\t\t// Auto-create a stream covering the subject if one doesn't\n\t\t\t\t// exist. Production deployments should pre-provision via\n\t\t\t\t// `nats stream add` to control retention.\n\t\t\t\ttry {\n\t\t\t\t\tawait jsm.streams.add({\n\t\t\t\t\t\tname: `blok-${(config.topic ?? \"\").replace(/[^a-zA-Z0-9_]/g, \"_\")}`,\n\t\t\t\t\t\tsubjects: [config.topic],\n\t\t\t\t\t});\n\t\t\t\t} catch {\n\t\t\t\t\t/* stream already exists — ignore */\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst js = this.conn.jetstream();\n\t\t\tconst startSeq =\n\t\t\t\ttypeof config.startFrom === \"object\" && config.startFrom && \"seq\" in config.startFrom\n\t\t\t\t\t? config.startFrom.seq\n\t\t\t\t\t: undefined;\n\t\t\tconst deliverPolicy =\n\t\t\t\tconfig.startFrom === \"earliest\"\n\t\t\t\t\t? \"all\"\n\t\t\t\t\t: config.startFrom === \"latest\"\n\t\t\t\t\t\t? \"new\"\n\t\t\t\t\t\t: startSeq !== undefined\n\t\t\t\t\t\t\t? \"by_start_sequence\"\n\t\t\t\t\t\t\t: \"all\";\n\t\t\tconst sub = await js.subscribe(config.topic, {\n\t\t\t\tconfig: {\n\t\t\t\t\tdurable_name:\n\t\t\t\t\t\tconfig.consumerGroup ??\n\t\t\t\t\t\t`blok-${(config.subscription ?? config.topic ?? \"default\").replace(/[^a-zA-Z0-9_]/g, \"_\")}`,\n\t\t\t\t\tdeliver_policy: deliverPolicy,\n\t\t\t\t\topt_start_seq: startSeq,\n\t\t\t\t\tack_policy: config.ack === false ? \"none\" : \"explicit\",\n\t\t\t\t},\n\t\t\t});\n\t\t\tthis.subscriptions.set(subKey, { unsubscribe: () => sub.unsubscribe() });\n\t\t\t// Drive the async iterator in a background loop.\n\t\t\tvoid (async () => {\n\t\t\t\ttry {\n\t\t\t\t\tfor await (const msg of sub as unknown as AsyncIterable<NatsJsMsg>) {\n\t\t\t\t\t\tawait this.dispatchJsMessage(msg, config, handler);\n\t\t\t\t\t}\n\t\t\t\t} catch (err) {\n\t\t\t\t\t// Subscription closed or connection lost — let the trigger\n\t\t\t\t\t// re-listen via HMR/reconnect logic. Log for visibility.\n\t\t\t\t\tconsole.error(`[blok][pubsub-nats] subscription error: ${(err as Error).message}`);\n\t\t\t\t}\n\t\t\t})();\n\t\t\treturn;\n\t\t}\n\n\t\t// Core NATS subscription — fire-and-forget, with optional queue\n\t\t// group for competing-consumer semantics.\n\t\tconst sub = this.conn.subscribe(config.topic, {\n\t\t\tqueue: config.consumerGroup,\n\t\t\tcallback: (err, msg) => {\n\t\t\t\tif (err) {\n\t\t\t\t\tconsole.error(`[blok][pubsub-nats] subscribe error: ${err.message}`);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tvoid this.dispatchCoreMessage(msg, config, handler);\n\t\t\t},\n\t\t});\n\t\tthis.subscriptions.set(subKey, sub);\n\t}\n\n\tprivate async dispatchJsMessage(\n\t\tmsg: NatsJsMsg,\n\t\tconfig: PubSubTriggerOpts,\n\t\thandler: (message: PubSubMessage) => Promise<void>,\n\t): Promise<void> {\n\t\tconst text = TEXT_DECODER.decode(msg.data);\n\t\tlet body: unknown = text;\n\t\ttry {\n\t\t\tbody = text.length > 0 ? JSON.parse(text) : null;\n\t\t} catch {\n\t\t\t/* leave as text */\n\t\t}\n\t\tconst message: PubSubMessage = {\n\t\t\tid: `${msg.info.stream}:${msg.seq}`,\n\t\t\tbody,\n\t\t\tattributes: { subject: msg.subject },\n\t\t\traw: msg,\n\t\t\ttopic: msg.subject,\n\t\t\tsubscription: msg.info.consumer,\n\t\t\tpublishTime: msg.info.timestampNanos ? new Date(msg.info.timestampNanos / 1e6) : undefined,\n\t\t\tack: async () => {\n\t\t\t\tmsg.ack();\n\t\t\t},\n\t\t\tnack: async () => {\n\t\t\t\tmsg.nak();\n\t\t\t},\n\t\t};\n\t\ttry {\n\t\t\tawait handler(message);\n\t\t\tif (config.ack !== false) msg.ack();\n\t\t} catch {\n\t\t\tmsg.nak();\n\t\t}\n\t}\n\n\tprivate async dispatchCoreMessage(\n\t\tmsg: NatsMsg,\n\t\t_config: PubSubTriggerOpts,\n\t\thandler: (message: PubSubMessage) => Promise<void>,\n\t): Promise<void> {\n\t\tconst text = TEXT_DECODER.decode(msg.data);\n\t\tlet body: unknown = text;\n\t\ttry {\n\t\t\tbody = text.length > 0 ? JSON.parse(text) : null;\n\t\t} catch {\n\t\t\t/* leave as text */\n\t\t}\n\t\tconst message: PubSubMessage = {\n\t\t\tid: `${msg.subject}:${msg.sid}:${uuid()}`,\n\t\t\tbody,\n\t\t\tattributes: { subject: msg.subject },\n\t\t\traw: msg,\n\t\t\ttopic: msg.subject,\n\t\t\tack: async () => {\n\t\t\t\t/* core NATS has no explicit ack */\n\t\t\t},\n\t\t\tnack: async () => {\n\t\t\t\t/* core NATS has no explicit nack */\n\t\t\t},\n\t\t};\n\t\ttry {\n\t\t\tawait handler(message);\n\t\t} catch (err) {\n\t\t\tconsole.error(`[blok][pubsub-nats] handler error: ${(err as Error).message}`);\n\t\t}\n\t}\n\n\tasync unsubscribe(subscription: string): Promise<void> {\n\t\tconst sub = this.subscriptions.get(subscription);\n\t\tif (!sub) return;\n\t\ttry {\n\t\t\tconst result = sub.unsubscribe();\n\t\t\tif (result instanceof Promise) await result;\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.subscriptions.delete(subscription);\n\t}\n\n\tasync publish(topic: string, payload: unknown): Promise<void> {\n\t\tif (!this.connected || !this.conn) throw new Error(\"[blok][pubsub-nats] not connected. Call connect() first.\");\n\t\tconst body = typeof payload === \"string\" ? payload : JSON.stringify(payload);\n\t\tconst data = TEXT_ENCODER.encode(body);\n\t\t// Use core NATS publish. When a durable subscriber has been\n\t\t// installed for this subject, the subscribe() path created a\n\t\t// JetStream stream with a subject filter that captures any\n\t\t// publish to `topic` — so durable consumers see the message via\n\t\t// the stream while core subscribers see it directly. The earlier\n\t\t// \"try js.publish first, fall back to core\" logic caused\n\t\t// **double-delivery**: js.publish to a subject covered by a\n\t\t// stream goes to BOTH the stream and core subscribers, then the\n\t\t// fallback would publish AGAIN if js.publish timed out (vs\n\t\t// returning 503 fast). Sticking to core publish avoids the race.\n\t\tthis.conn.publish(topic, data);\n\t}\n\n\tisConnected(): boolean {\n\t\treturn this.connected;\n\t}\n\n\tasync healthCheck(): Promise<boolean> {\n\t\treturn this.connected;\n\t}\n}\n"]}

package/dist/adapters/RedisStreamsPubSubAdapter.d.ts

@@ -0,0 +1,49 @@
+/**
+ * RedisStreamsPubSubAdapter — v0.7 PR 6 — Pub/Sub adapter backed by
+ * Redis Streams via `ioredis`.
+ *
+ * Pub/Sub vs Worker semantics: this adapter uses **distinct consumer
+ * groups per subscriber** so multiple subscribers each receive every
+ * message (fan-out). When `consumerGroup` is explicitly set on the
+ * workflow, all subscribers in the group compete (1 of N gets each).
+ *
+ * Replay cursors:
+ *   - `"earliest"` / unset → `$` (only new messages by default).
+ *   - `"earliest"` with explicit intent → `0` (replay full stream).
+ *   - `{seq: N}` → resume from stream id `N-0`.
+ *
+ * Requires `ioredis` as a peer dependency.
+ *
+ * Environment variables:
+ *   - `REDIS_HOST` (default `localhost`).
+ *   - `REDIS_PORT` (default `6379`).
+ *   - `REDIS_PASSWORD`.
+ *   - `REDIS_DB`.
+ */
+import type { PubSubTriggerOpts } from "@blokjs/helper";
+import type { PubSubAdapter, PubSubMessage } from "../PubSubTrigger";
+export interface RedisStreamsPubSubConfig {
+    host: string;
+    port: number;
+    password?: string;
+    db?: number;
+    blockMs: number;
+    count: number;
+}
+export declare class RedisStreamsPubSubAdapter implements PubSubAdapter {
+    readonly provider: "redis-streams";
+    private readonly config;
+    private client;
+    private subscriptions;
+    private connected;
+    private consumerName;
+    constructor(config?: Partial<RedisStreamsPubSubConfig>);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    subscribe(config: PubSubTriggerOpts, handler: (message: PubSubMessage) => Promise<void>): Promise<void>;
+    private fieldsToObject;
+    unsubscribe(subscription: string): Promise<void>;
+    publish(topic: string, payload: unknown): Promise<void>;
+    isConnected(): boolean;
+    healthCheck(): Promise<boolean>;
+}

package/dist/adapters/RedisStreamsPubSubAdapter.js

@@ -0,0 +1,193 @@
+/**
+ * RedisStreamsPubSubAdapter — v0.7 PR 6 — Pub/Sub adapter backed by
+ * Redis Streams via `ioredis`.
+ *
+ * Pub/Sub vs Worker semantics: this adapter uses **distinct consumer
+ * groups per subscriber** so multiple subscribers each receive every
+ * message (fan-out). When `consumerGroup` is explicitly set on the
+ * workflow, all subscribers in the group compete (1 of N gets each).
+ *
+ * Replay cursors:
+ *   - `"earliest"` / unset → `$` (only new messages by default).
+ *   - `"earliest"` with explicit intent → `0` (replay full stream).
+ *   - `{seq: N}` → resume from stream id `N-0`.
+ *
+ * Requires `ioredis` as a peer dependency.
+ *
+ * Environment variables:
+ *   - `REDIS_HOST` (default `localhost`).
+ *   - `REDIS_PORT` (default `6379`).
+ *   - `REDIS_PASSWORD`.
+ *   - `REDIS_DB`.
+ */
+import { v4 as uuid } from "uuid";
+export class RedisStreamsPubSubAdapter {
+    provider = "redis-streams";
+    config;
+    client = null;
+    subscriptions = new Map();
+    connected = false;
+    consumerName = `blok-pubsub-${uuid().slice(0, 8)}`;
+    constructor(config) {
+        this.config = {
+            host: config?.host ?? process.env.REDIS_HOST ?? "localhost",
+            port: config?.port ?? Number.parseInt(process.env.REDIS_PORT ?? "6379", 10),
+            password: config?.password ?? process.env.REDIS_PASSWORD,
+            db: config?.db ?? Number.parseInt(process.env.REDIS_DB ?? "0", 10),
+            blockMs: config?.blockMs ?? 5000,
+            count: config?.count ?? 10,
+        };
+    }
+    async connect() {
+        if (this.connected)
+            return;
+        try {
+            // biome-ignore lint/suspicious/noExplicitAny: ioredis is a runtime peer dep.
+            const ioredis = await import("ioredis");
+            const IORedis = ioredis.default ?? ioredis.Redis ?? ioredis;
+            this.client = new IORedis({
+                host: this.config.host,
+                port: this.config.port,
+                password: this.config.password,
+                db: this.config.db,
+            });
+            await this.client.ping();
+            this.connected = true;
+        }
+        catch (err) {
+            throw new Error(`[blok][pubsub-redis] connect failed: ${err.message}. Install ioredis as a peer dependency: bun add ioredis`);
+        }
+    }
+    async disconnect() {
+        if (!this.connected)
+            return;
+        for (const sub of this.subscriptions.values())
+            sub.stop();
+        this.subscriptions.clear();
+        try {
+            await this.client?.quit();
+        }
+        catch {
+            /* ignore */
+        }
+        this.client = null;
+        this.connected = false;
+    }
+    async subscribe(config, handler) {
+        if (!this.connected || !this.client)
+            throw new Error("[blok][pubsub-redis] not connected. Call connect() first.");
+        const client = this.client;
+        const stream = config.topic;
+        // Fan-out: each subscriber gets its own group (unique per instance).
+        // Competing-consumer: explicit `consumerGroup` makes all subscribers
+        // share work.
+        const group = config.consumerGroup ?? `blok-fanout-${this.consumerName}-${stream.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+        const startId = config.startFrom === "earliest"
+            ? "0"
+            : config.startFrom === "latest" || config.startFrom === undefined
+                ? "$"
+                : typeof config.startFrom === "object" && "seq" in config.startFrom
+                    ? `${config.startFrom.seq}-0`
+                    : "$";
+        try {
+            await client.xgroup("CREATE", stream, group, startId, "MKSTREAM");
+        }
+        catch (err) {
+            if (!/BUSYGROUP/i.test(err.message))
+                throw err;
+        }
+        let stopped = false;
+        const sub = {
+            stop: () => {
+                stopped = true;
+            },
+        };
+        this.subscriptions.set(`${stream}#${group}`, sub);
+        void (async () => {
+            while (!stopped) {
+                let entries = null;
+                try {
+                    entries = await client.xreadgroup("GROUP", group, this.consumerName, "COUNT", String(this.config.count), "BLOCK", String(this.config.blockMs), "STREAMS", stream, ">");
+                }
+                catch {
+                    await new Promise((r) => setTimeout(r, 1000));
+                    continue;
+                }
+                if (!entries)
+                    continue;
+                for (const [, msgs] of entries) {
+                    for (const [id, fields] of msgs) {
+                        if (stopped)
+                            break;
+                        const payload = this.fieldsToObject(fields);
+                        const dataString = typeof payload.data === "string" ? payload.data : "";
+                        let body;
+                        try {
+                            body = dataString.length > 0 ? JSON.parse(dataString) : null;
+                        }
+                        catch {
+                            body = dataString;
+                        }
+                        const message = {
+                            id,
+                            body,
+                            attributes: payload,
+                            raw: { id, fields },
+                            topic: stream,
+                            subscription: group,
+                            publishTime: new Date(Number.parseInt(id.split("-")[0] ?? String(Date.now()), 10)),
+                            ack: async () => {
+                                await client.xack(stream, group, id);
+                            },
+                            nack: async () => {
+                                /* leave unacked — picked up by XAUTOCLAIM */
+                            },
+                        };
+                        try {
+                            await handler(message);
+                            if (config.ack !== false)
+                                await client.xack(stream, group, id);
+                        }
+                        catch {
+                            // Leave unacked — pending entries are visible in XPENDING.
+                        }
+                    }
+                }
+            }
+        })();
+    }
+    fieldsToObject(fields) {
+        const out = {};
+        for (let i = 0; i < fields.length; i += 2)
+            out[fields[i]] = fields[i + 1];
+        return out;
+    }
+    async unsubscribe(subscription) {
+        const sub = this.subscriptions.get(subscription);
+        if (!sub)
+            return;
+        sub.stop();
+        this.subscriptions.delete(subscription);
+    }
+    async publish(topic, payload) {
+        if (!this.connected || !this.client)
+            throw new Error("[blok][pubsub-redis] not connected. Call connect() first.");
+        const body = typeof payload === "string" ? payload : JSON.stringify(payload);
+        await this.client.xadd(topic, "*", "data", body);
+    }
+    isConnected() {
+        return this.connected;
+    }
+    async healthCheck() {
+        if (!this.connected || !this.client)
+            return false;
+        try {
+            const pong = await this.client.ping();
+            return pong === "PONG";
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RedisStreamsPubSubAdapter.js","sourceRoot":"","sources":["../../src/adapters/RedisStreamsPubSubAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RedisStreamsPubSubAdapter — v0.7 PR 6 — Pub/Sub adapter backed by\n * Redis Streams via `ioredis`.\n *\n * Pub/Sub vs Worker semantics: this adapter uses **distinct consumer\n * groups per subscriber** so multiple subscribers each receive every\n * message (fan-out). When `consumerGroup` is explicitly set on the\n * workflow, all subscribers in the group compete (1 of N gets each).\n *\n * Replay cursors:\n *   - `\"earliest\"` / unset → `$` (only new messages by default).\n *   - `\"earliest\"` with explicit intent → `0` (replay full stream).\n *   - `{seq: N}` → resume from stream id `N-0`.\n *\n * Requires `ioredis` as a peer dependency.\n *\n * Environment variables:\n *   - `REDIS_HOST` (default `localhost`).\n *   - `REDIS_PORT` (default `6379`).\n *   - `REDIS_PASSWORD`.\n *   - `REDIS_DB`.\n */\n\nimport type { PubSubTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { PubSubAdapter, PubSubMessage } from \"../PubSubTrigger\";\n\nexport interface RedisStreamsPubSubConfig {\n\thost: string;\n\tport: number;\n\tpassword?: string;\n\tdb?: number;\n\tblockMs: number;\n\tcount: number;\n}\n\ninterface RedisClient {\n\txadd(stream: string, ...args: string[]): Promise<string>;\n\txreadgroup(...args: string[]): Promise<Array<[string, Array<[string, string[]]>]> | null>;\n\txgroup(...args: string[]): Promise<string>;\n\txack(stream: string, group: string, ...ids: string[]): Promise<number>;\n\tping(): Promise<string>;\n\tquit(): Promise<string>;\n}\n\ninterface ActiveSubscription {\n\tstop: () => void;\n}\n\nexport class RedisStreamsPubSubAdapter implements PubSubAdapter {\n\treadonly provider = \"redis-streams\" as const;\n\tprivate readonly config: RedisStreamsPubSubConfig;\n\tprivate client: RedisClient | null = null;\n\tprivate subscriptions: Map<string, ActiveSubscription> = new Map();\n\tprivate connected = false;\n\tprivate consumerName = `blok-pubsub-${uuid().slice(0, 8)}`;\n\n\tconstructor(config?: Partial<RedisStreamsPubSubConfig>) {\n\t\tthis.config = {\n\t\t\thost: config?.host ?? process.env.REDIS_HOST ?? \"localhost\",\n\t\t\tport: config?.port ?? Number.parseInt(process.env.REDIS_PORT ?? \"6379\", 10),\n\t\t\tpassword: config?.password ?? process.env.REDIS_PASSWORD,\n\t\t\tdb: config?.db ?? Number.parseInt(process.env.REDIS_DB ?? \"0\", 10),\n\t\t\tblockMs: config?.blockMs ?? 5000,\n\t\t\tcount: config?.count ?? 10,\n\t\t};\n\t}\n\n\tasync connect(): Promise<void> {\n\t\tif (this.connected) return;\n\t\ttry {\n\t\t\t// biome-ignore lint/suspicious/noExplicitAny: ioredis is a runtime peer dep.\n\t\t\tconst ioredis: any = await import(\"ioredis\");\n\t\t\tconst IORedis = ioredis.default ?? ioredis.Redis ?? ioredis;\n\t\t\tthis.client = new IORedis({\n\t\t\t\thost: this.config.host,\n\t\t\t\tport: this.config.port,\n\t\t\t\tpassword: this.config.password,\n\t\t\t\tdb: this.config.db,\n\t\t\t}) as RedisClient;\n\t\t\tawait this.client.ping();\n\t\t\tthis.connected = true;\n\t\t} catch (err) {\n\t\t\tthrow new Error(\n\t\t\t\t`[blok][pubsub-redis] connect failed: ${(err as Error).message}. Install ioredis as a peer dependency: bun add ioredis`,\n\t\t\t);\n\t\t}\n\t}\n\n\tasync disconnect(): Promise<void> {\n\t\tif (!this.connected) return;\n\t\tfor (const sub of this.subscriptions.values()) sub.stop();\n\t\tthis.subscriptions.clear();\n\t\ttry {\n\t\t\tawait this.client?.quit();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.client = null;\n\t\tthis.connected = false;\n\t}\n\n\tasync subscribe(config: PubSubTriggerOpts, handler: (message: PubSubMessage) => Promise<void>): Promise<void> {\n\t\tif (!this.connected || !this.client) throw new Error(\"[blok][pubsub-redis] not connected. Call connect() first.\");\n\t\tconst client = this.client;\n\t\tconst stream = config.topic;\n\t\t// Fan-out: each subscriber gets its own group (unique per instance).\n\t\t// Competing-consumer: explicit `consumerGroup` makes all subscribers\n\t\t// share work.\n\t\tconst group = config.consumerGroup ?? `blok-fanout-${this.consumerName}-${stream.replace(/[^a-zA-Z0-9_]/g, \"_\")}`;\n\t\tconst startId =\n\t\t\tconfig.startFrom === \"earliest\"\n\t\t\t\t? \"0\"\n\t\t\t\t: config.startFrom === \"latest\" || config.startFrom === undefined\n\t\t\t\t\t? \"$\"\n\t\t\t\t\t: typeof config.startFrom === \"object\" && \"seq\" in config.startFrom\n\t\t\t\t\t\t? `${config.startFrom.seq}-0`\n\t\t\t\t\t\t: \"$\";\n\n\t\ttry {\n\t\t\tawait client.xgroup(\"CREATE\", stream, group, startId, \"MKSTREAM\");\n\t\t} catch (err) {\n\t\t\tif (!/BUSYGROUP/i.test((err as Error).message)) throw err;\n\t\t}\n\n\t\tlet stopped = false;\n\t\tconst sub: ActiveSubscription = {\n\t\t\tstop: () => {\n\t\t\t\tstopped = true;\n\t\t\t},\n\t\t};\n\t\tthis.subscriptions.set(`${stream}#${group}`, sub);\n\n\t\tvoid (async () => {\n\t\t\twhile (!stopped) {\n\t\t\t\tlet entries: Array<[string, Array<[string, string[]]>]> | null = null;\n\t\t\t\ttry {\n\t\t\t\t\tentries = await client.xreadgroup(\n\t\t\t\t\t\t\"GROUP\",\n\t\t\t\t\t\tgroup,\n\t\t\t\t\t\tthis.consumerName,\n\t\t\t\t\t\t\"COUNT\",\n\t\t\t\t\t\tString(this.config.count),\n\t\t\t\t\t\t\"BLOCK\",\n\t\t\t\t\t\tString(this.config.blockMs),\n\t\t\t\t\t\t\"STREAMS\",\n\t\t\t\t\t\tstream,\n\t\t\t\t\t\t\">\",\n\t\t\t\t\t);\n\t\t\t\t} catch {\n\t\t\t\t\tawait new Promise((r) => setTimeout(r, 1000));\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tif (!entries) continue;\n\t\t\t\tfor (const [, msgs] of entries) {\n\t\t\t\t\tfor (const [id, fields] of msgs) {\n\t\t\t\t\t\tif (stopped) break;\n\t\t\t\t\t\tconst payload = this.fieldsToObject(fields);\n\t\t\t\t\t\tconst dataString = typeof payload.data === \"string\" ? payload.data : \"\";\n\t\t\t\t\t\tlet body: unknown;\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tbody = dataString.length > 0 ? JSON.parse(dataString) : null;\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\tbody = dataString;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tconst message: PubSubMessage = {\n\t\t\t\t\t\t\tid,\n\t\t\t\t\t\t\tbody,\n\t\t\t\t\t\t\tattributes: payload,\n\t\t\t\t\t\t\traw: { id, fields },\n\t\t\t\t\t\t\ttopic: stream,\n\t\t\t\t\t\t\tsubscription: group,\n\t\t\t\t\t\t\tpublishTime: new Date(Number.parseInt(id.split(\"-\")[0] ?? String(Date.now()), 10)),\n\t\t\t\t\t\t\tack: async () => {\n\t\t\t\t\t\t\t\tawait client.xack(stream, group, id);\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tnack: async () => {\n\t\t\t\t\t\t\t\t/* leave unacked — picked up by XAUTOCLAIM */\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t};\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tawait handler(message);\n\t\t\t\t\t\t\tif (config.ack !== false) await client.xack(stream, group, id);\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\t// Leave unacked — pending entries are visible in XPENDING.\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t})();\n\t}\n\n\tprivate fieldsToObject(fields: string[]): Record<string, string> {\n\t\tconst out: Record<string, string> = {};\n\t\tfor (let i = 0; i < fields.length; i += 2) out[fields[i]] = fields[i + 1];\n\t\treturn out;\n\t}\n\n\tasync unsubscribe(subscription: string): Promise<void> {\n\t\tconst sub = this.subscriptions.get(subscription);\n\t\tif (!sub) return;\n\t\tsub.stop();\n\t\tthis.subscriptions.delete(subscription);\n\t}\n\n\tasync publish(topic: string, payload: unknown): Promise<void> {\n\t\tif (!this.connected || !this.client) throw new Error(\"[blok][pubsub-redis] not connected. Call connect() first.\");\n\t\tconst body = typeof payload === \"string\" ? payload : JSON.stringify(payload);\n\t\tawait this.client.xadd(topic, \"*\", \"data\", body);\n\t}\n\n\tisConnected(): boolean {\n\t\treturn this.connected;\n\t}\n\n\tasync healthCheck(): Promise<boolean> {\n\t\tif (!this.connected || !this.client) return false;\n\t\ttry {\n\t\t\tconst pong = await this.client.ping();\n\t\t\treturn pong === \"PONG\";\n\t\t} catch {\n\t\t\treturn false;\n\t\t}\n\t}\n}\n"]}

package/dist/adapters/factory.d.ts

@@ -0,0 +1,22 @@
+/**
+ * v0.7 PR 6 — pub/sub adapter factory.
+ *
+ * Resolves a `provider` string to a concrete `PubSubAdapter` instance.
+ * Used by `PubSubTrigger` (per-workflow provider dispatch) and by the
+ * `@blokjs/pubsub-publish` helper.
+ *
+ * Provider resolution order:
+ *   1. Explicit `provider` field on the workflow.
+ *   2. `BLOK_PUBSUB_ADAPTER` env var.
+ *   3. `"nats"` fallback (cheapest infra; matches the v0.7 plan's
+ *      "default for pub/sub" recommendation).
+ *
+ * Each adapter lazy-imports its broker SDK on first use; workflows
+ * that don't use a given provider don't pay the install cost.
+ */
+import type { PubSubProvider } from "@blokjs/helper";
+import type { PubSubAdapter } from "../PubSubTrigger";
+export declare function resolveProvider(provider?: PubSubProvider): PubSubProvider;
+export declare function createPubSubAdapter(provider: PubSubProvider): PubSubAdapter;
+export declare function getOrCreateAdapter(provider: PubSubProvider): PubSubAdapter;
+export declare function _resetAdapterPoolForTests(): void;