@blokjs/trigger-worker 0.4.0 → 0.6.2

package/dist/adapters/RabbitMQAdapter.js

@@ -0,0 +1,241 @@
+/**
+ * RabbitMQAdapter — v0.7 PR 5 — Worker adapter backed by RabbitMQ via
+ * the `amqplib` driver. Direct-exchange / queue model — the `queue`
+ * field maps to an AMQP queue name; messages are consumed with
+ * manual ACK. The default exchange (`""`) is used for publishing.
+ *
+ * Features:
+ *   - Concurrency via `prefetch(N)` per channel.
+ *   - Retries via `nack` with requeue=true until `retries` is hit, then
+ *     drop or DLQ-route based on `deadLetterQueue` config.
+ *   - Priorities via the `x-max-priority` queue arg (AMQP standard).
+ *   - Delayed delivery via the `x-delayed-message` plugin when
+ *     available; falls back to immediate dispatch otherwise.
+ *
+ * Requires `amqplib` as a peer dependency:
+ *
+ *     bun add amqplib
+ *
+ * Environment variables:
+ *   - `AMQP_URL` — full AMQP connection string (default `amqp://localhost`).
+ *   - `AMQP_VHOST` — virtual host (default `/`).
+ */
+import { v4 as uuid } from "uuid";
+export class RabbitMQAdapter {
+    provider = "rabbitmq";
+    config;
+    conn = null;
+    channels = new Map();
+    connected = false;
+    stats = new Map();
+    constructor(config) {
+        this.config = {
+            url: config?.url ?? process.env.AMQP_URL ?? "amqp://localhost",
+            vhost: config?.vhost ?? process.env.AMQP_VHOST,
+        };
+    }
+    async connect() {
+        if (this.connected)
+            return;
+        try {
+            // biome-ignore lint/suspicious/noExplicitAny: amqplib's connect returns a loose ConnectionLike.
+            const amqp = await import("amqplib");
+            this.conn = (await amqp.connect(this.config.url, { vhost: this.config.vhost }));
+            this.connected = true;
+        }
+        catch (err) {
+            throw new Error(`[blok][rabbitmq] connect failed: ${err.message}. Install amqplib as a peer dependency: bun add amqplib`);
+        }
+    }
+    async disconnect() {
+        if (!this.connected)
+            return;
+        for (const [, entry] of this.channels) {
+            try {
+                if (entry.consumerTag)
+                    await entry.channel.cancel(entry.consumerTag);
+                await entry.channel.close();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        this.channels.clear();
+        try {
+            await this.conn?.close();
+        }
+        catch {
+            /* ignore */
+        }
+        this.conn = null;
+        this.connected = false;
+    }
+    async process(config, handler) {
+        if (!this.connected || !this.conn)
+            throw new Error("[blok][rabbitmq] not connected. Call connect() first.");
+        const channel = await this.conn.createChannel();
+        await channel.prefetch(config.concurrency ?? 1);
+        const queueArgs = {};
+        if (config.deadLetterQueue) {
+            queueArgs["x-dead-letter-exchange"] = "";
+            queueArgs["x-dead-letter-routing-key"] = config.deadLetterQueue;
+            await channel.assertQueue(config.deadLetterQueue, { durable: true });
+        }
+        await channel.assertQueue(config.queue, { durable: true, arguments: queueArgs });
+        this.stats.set(config.queue, { completed: 0, failed: 0, active: 0 });
+        const stats = this.stats.get(config.queue);
+        const maxAttempts = (config.retries ?? 3) + 1;
+        const { consumerTag } = await channel.consume(config.queue, (msg) => {
+            if (!msg)
+                return;
+            void (async () => {
+                const payloadString = msg.content.toString("utf8");
+                let data;
+                try {
+                    data = payloadString.length > 0 ? JSON.parse(payloadString) : null;
+                }
+                catch {
+                    data = payloadString;
+                }
+                const headers = {};
+                for (const [k, v] of Object.entries(msg.properties.headers ?? {}))
+                    headers[k] = String(v);
+                const attempts = Number.parseInt(String(msg.properties.headers?.["x-blok-attempt"] ?? 0), 10);
+                // Tracks whether the message has already been ack/nack'd via
+                // the WorkerJob API (`complete` / `fail`). The wrapping
+                // try/catch below also wants to ack on handler success and
+                // nack on handler throw — without this flag we'd
+                // double-ack the same delivery tag and Rabbit closes the
+                // channel with PRECONDITION_FAILED (caught by the
+                // real-broker integration test in
+                // `__tests__/integration/rabbitmq-adapter.real-rabbitmq.test.ts`).
+                let settled = false;
+                const job = {
+                    id: msg.properties.messageId ?? `${config.queue}:${msg.fields.deliveryTag}`,
+                    data,
+                    headers,
+                    queue: config.queue,
+                    priority: msg.properties.priority ?? config.priority ?? 0,
+                    attempts,
+                    maxRetries: config.retries ?? 3,
+                    createdAt: msg.properties.timestamp ? new Date(msg.properties.timestamp) : new Date(),
+                    timeout: config.timeout,
+                    raw: msg,
+                    complete: async () => {
+                        if (settled)
+                            return;
+                        channel.ack(msg);
+                        stats.completed += 1;
+                        settled = true;
+                    },
+                    fail: async (err, requeue) => {
+                        if (settled)
+                            return;
+                        stats.failed += 1;
+                        const exceeded = attempts + 1 >= maxAttempts;
+                        channel.nack(msg, false, !exceeded && requeue !== false);
+                        settled = true;
+                    },
+                };
+                stats.active += 1;
+                try {
+                    await handler(job);
+                    if (!settled && config.ack !== false) {
+                        channel.ack(msg);
+                        stats.completed += 1;
+                        settled = true;
+                    }
+                }
+                catch {
+                    if (!settled) {
+                        stats.failed += 1;
+                        const exceeded = attempts + 1 >= maxAttempts;
+                        channel.nack(msg, false, !exceeded);
+                        settled = true;
+                    }
+                }
+                finally {
+                    stats.active = Math.max(0, stats.active - 1);
+                }
+            })();
+        }, { noAck: config.ack === false });
+        this.channels.set(config.queue, { channel, consumerTag });
+    }
+    async addJob(queue, data, opts) {
+        if (!this.connected || !this.conn)
+            throw new Error("[blok][rabbitmq] not connected. Call connect() first.");
+        let channel = this.channels.get(queue)?.channel;
+        if (!channel) {
+            channel = await this.conn.createChannel();
+            await channel.assertQueue(queue, { durable: true });
+        }
+        const messageId = opts?.jobId ?? uuid();
+        const headers = {};
+        if (typeof opts?.delay === "number")
+            headers["x-delay"] = opts.delay;
+        const ok = channel.sendToQueue(queue, Buffer.from(typeof data === "string" ? data : JSON.stringify(data)), {
+            persistent: true,
+            messageId,
+            priority: opts?.priority,
+            timestamp: Date.now(),
+            headers,
+        });
+        if (!ok) {
+            // Channel is in flow-controlled state. The send is still
+            // accepted; the channel will emit a 'drain' event when ready.
+            // We don't currently surface backpressure to callers.
+        }
+        return messageId;
+    }
+    async stopProcessing(queue) {
+        const entry = this.channels.get(queue);
+        if (!entry)
+            return;
+        try {
+            if (entry.consumerTag)
+                await entry.channel.cancel(entry.consumerTag);
+            await entry.channel.close();
+        }
+        catch {
+            /* ignore */
+        }
+        this.channels.delete(queue);
+    }
+    isConnected() {
+        return this.connected;
+    }
+    async healthCheck() {
+        if (!this.connected || !this.conn)
+            return false;
+        try {
+            const channel = await this.conn.createChannel();
+            await channel.close();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getQueueStats(queue) {
+        const counters = this.stats.get(queue) ?? { completed: 0, failed: 0, active: 0 };
+        let waiting = 0;
+        const entry = this.channels.get(queue);
+        if (entry) {
+            try {
+                const info = await entry.channel.checkQueue(queue);
+                waiting = info.messageCount;
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        return {
+            waiting,
+            active: counters.active,
+            completed: counters.completed,
+            failed: counters.failed,
+            delayed: 0,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RabbitMQAdapter.js","sourceRoot":"","sources":["../../src/adapters/RabbitMQAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RabbitMQAdapter — v0.7 PR 5 — Worker adapter backed by RabbitMQ via\n * the `amqplib` driver. Direct-exchange / queue model — the `queue`\n * field maps to an AMQP queue name; messages are consumed with\n * manual ACK. The default exchange (`\"\"`) is used for publishing.\n *\n * Features:\n *   - Concurrency via `prefetch(N)` per channel.\n *   - Retries via `nack` with requeue=true until `retries` is hit, then\n *     drop or DLQ-route based on `deadLetterQueue` config.\n *   - Priorities via the `x-max-priority` queue arg (AMQP standard).\n *   - Delayed delivery via the `x-delayed-message` plugin when\n *     available; falls back to immediate dispatch otherwise.\n *\n * Requires `amqplib` as a peer dependency:\n *\n *     bun add amqplib\n *\n * Environment variables:\n *   - `AMQP_URL` — full AMQP connection string (default `amqp://localhost`).\n *   - `AMQP_VHOST` — virtual host (default `/`).\n */\n\nimport type { WorkerTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { WorkerAdapter, WorkerJob, WorkerQueueStats } from \"../WorkerTrigger\";\n\nexport interface RabbitMQConfig {\n\turl: string;\n\tvhost?: string;\n}\n\ninterface RabbitChannel {\n\tprefetch(n: number): Promise<void>;\n\tassertQueue(\n\t\tname: string,\n\t\topts?: Record<string, unknown>,\n\t): Promise<{ queue: string; messageCount: number; consumerCount: number }>;\n\tcheckQueue(name: string): Promise<{ queue: string; messageCount: number; consumerCount: number }>;\n\tconsume(\n\t\tqueue: string,\n\t\tcb: (\n\t\t\tmsg: {\n\t\t\t\tcontent: Buffer;\n\t\t\t\tfields: { deliveryTag: number; redelivered: boolean };\n\t\t\t\tproperties: { messageId?: string; priority?: number; timestamp?: number; headers?: Record<string, unknown> };\n\t\t\t} | null,\n\t\t) => void,\n\t\topts?: { noAck?: boolean; consumerTag?: string },\n\t): Promise<{ consumerTag: string }>;\n\tcancel(consumerTag: string): Promise<void>;\n\tack(msg: { fields: { deliveryTag: number } }): void;\n\tnack(msg: { fields: { deliveryTag: number } }, allUpTo?: boolean, requeue?: boolean): void;\n\tsendToQueue(queue: string, content: Buffer, opts?: Record<string, unknown>): boolean;\n\tclose(): Promise<void>;\n}\n\ninterface RabbitConnection {\n\tcreateChannel(): Promise<RabbitChannel>;\n\tclose(): Promise<void>;\n}\n\ninterface QueueStatsCounters {\n\tcompleted: number;\n\tfailed: number;\n\tactive: number;\n}\n\nexport class RabbitMQAdapter implements WorkerAdapter {\n\treadonly provider = \"rabbitmq\" as const;\n\tprivate readonly config: RabbitMQConfig;\n\tprivate conn: RabbitConnection | null = null;\n\tprivate channels: Map<string, { channel: RabbitChannel; consumerTag?: string }> = new Map();\n\tprivate connected = false;\n\tprivate stats: Map<string, QueueStatsCounters> = new Map();\n\n\tconstructor(config?: Partial<RabbitMQConfig>) {\n\t\tthis.config = {\n\t\t\turl: config?.url ?? process.env.AMQP_URL ?? \"amqp://localhost\",\n\t\t\tvhost: config?.vhost ?? process.env.AMQP_VHOST,\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: amqplib's connect returns a loose ConnectionLike.\n\t\t\tconst amqp: any = await import(\"amqplib\");\n\t\t\tthis.conn = (await amqp.connect(this.config.url, { vhost: this.config.vhost })) as RabbitConnection;\n\t\t\tthis.connected = true;\n\t\t} catch (err) {\n\t\t\tthrow new Error(\n\t\t\t\t`[blok][rabbitmq] connect failed: ${(err as Error).message}. Install amqplib as a peer dependency: bun add amqplib`,\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 [, entry] of this.channels) {\n\t\t\ttry {\n\t\t\t\tif (entry.consumerTag) await entry.channel.cancel(entry.consumerTag);\n\t\t\t\tawait entry.channel.close();\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t}\n\t\tthis.channels.clear();\n\t\ttry {\n\t\t\tawait this.conn?.close();\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 process(config: WorkerTriggerOpts, handler: (job: WorkerJob) => Promise<void>): Promise<void> {\n\t\tif (!this.connected || !this.conn) throw new Error(\"[blok][rabbitmq] not connected. Call connect() first.\");\n\t\tconst channel = await this.conn.createChannel();\n\t\tawait channel.prefetch(config.concurrency ?? 1);\n\n\t\tconst queueArgs: Record<string, unknown> = {};\n\t\tif (config.deadLetterQueue) {\n\t\t\tqueueArgs[\"x-dead-letter-exchange\"] = \"\";\n\t\t\tqueueArgs[\"x-dead-letter-routing-key\"] = config.deadLetterQueue;\n\t\t\tawait channel.assertQueue(config.deadLetterQueue, { durable: true });\n\t\t}\n\t\tawait channel.assertQueue(config.queue, { durable: true, arguments: queueArgs });\n\n\t\tthis.stats.set(config.queue, { completed: 0, failed: 0, active: 0 });\n\t\tconst stats = this.stats.get(config.queue) as QueueStatsCounters;\n\t\tconst maxAttempts = (config.retries ?? 3) + 1;\n\n\t\tconst { consumerTag } = await channel.consume(\n\t\t\tconfig.queue,\n\t\t\t(msg) => {\n\t\t\t\tif (!msg) return;\n\t\t\t\tvoid (async () => {\n\t\t\t\t\tconst payloadString = msg.content.toString(\"utf8\");\n\t\t\t\t\tlet data: unknown;\n\t\t\t\t\ttry {\n\t\t\t\t\t\tdata = payloadString.length > 0 ? JSON.parse(payloadString) : null;\n\t\t\t\t\t} catch {\n\t\t\t\t\t\tdata = payloadString;\n\t\t\t\t\t}\n\t\t\t\t\tconst headers: Record<string, string> = {};\n\t\t\t\t\tfor (const [k, v] of Object.entries(msg.properties.headers ?? {})) headers[k] = String(v);\n\t\t\t\t\tconst attempts = Number.parseInt(String(msg.properties.headers?.[\"x-blok-attempt\"] ?? 0), 10);\n\t\t\t\t\t// Tracks whether the message has already been ack/nack'd via\n\t\t\t\t\t// the WorkerJob API (`complete` / `fail`). The wrapping\n\t\t\t\t\t// try/catch below also wants to ack on handler success and\n\t\t\t\t\t// nack on handler throw — without this flag we'd\n\t\t\t\t\t// double-ack the same delivery tag and Rabbit closes the\n\t\t\t\t\t// channel with PRECONDITION_FAILED (caught by the\n\t\t\t\t\t// real-broker integration test in\n\t\t\t\t\t// `__tests__/integration/rabbitmq-adapter.real-rabbitmq.test.ts`).\n\t\t\t\t\tlet settled = false;\n\t\t\t\t\tconst job: WorkerJob = {\n\t\t\t\t\t\tid: msg.properties.messageId ?? `${config.queue}:${msg.fields.deliveryTag}`,\n\t\t\t\t\t\tdata,\n\t\t\t\t\t\theaders,\n\t\t\t\t\t\tqueue: config.queue,\n\t\t\t\t\t\tpriority: msg.properties.priority ?? config.priority ?? 0,\n\t\t\t\t\t\tattempts,\n\t\t\t\t\t\tmaxRetries: config.retries ?? 3,\n\t\t\t\t\t\tcreatedAt: msg.properties.timestamp ? new Date(msg.properties.timestamp) : new Date(),\n\t\t\t\t\t\ttimeout: config.timeout,\n\t\t\t\t\t\traw: msg,\n\t\t\t\t\t\tcomplete: async () => {\n\t\t\t\t\t\t\tif (settled) return;\n\t\t\t\t\t\t\tchannel.ack(msg);\n\t\t\t\t\t\t\tstats.completed += 1;\n\t\t\t\t\t\t\tsettled = true;\n\t\t\t\t\t\t},\n\t\t\t\t\t\tfail: async (err: Error, requeue?: boolean) => {\n\t\t\t\t\t\t\tif (settled) return;\n\t\t\t\t\t\t\tstats.failed += 1;\n\t\t\t\t\t\t\tconst exceeded = attempts + 1 >= maxAttempts;\n\t\t\t\t\t\t\tchannel.nack(msg, false, !exceeded && requeue !== false);\n\t\t\t\t\t\t\tsettled = true;\n\t\t\t\t\t\t},\n\t\t\t\t\t};\n\t\t\t\t\tstats.active += 1;\n\t\t\t\t\ttry {\n\t\t\t\t\t\tawait handler(job);\n\t\t\t\t\t\tif (!settled && config.ack !== false) {\n\t\t\t\t\t\t\tchannel.ack(msg);\n\t\t\t\t\t\t\tstats.completed += 1;\n\t\t\t\t\t\t\tsettled = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t} catch {\n\t\t\t\t\t\tif (!settled) {\n\t\t\t\t\t\t\tstats.failed += 1;\n\t\t\t\t\t\t\tconst exceeded = attempts + 1 >= maxAttempts;\n\t\t\t\t\t\t\tchannel.nack(msg, false, !exceeded);\n\t\t\t\t\t\t\tsettled = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t} finally {\n\t\t\t\t\t\tstats.active = Math.max(0, stats.active - 1);\n\t\t\t\t\t}\n\t\t\t\t})();\n\t\t\t},\n\t\t\t{ noAck: config.ack === false },\n\t\t);\n\t\tthis.channels.set(config.queue, { channel, consumerTag });\n\t}\n\n\tasync addJob(\n\t\tqueue: string,\n\t\tdata: unknown,\n\t\topts?: { priority?: number; delay?: number; retries?: number; timeout?: number; jobId?: string },\n\t): Promise<string> {\n\t\tif (!this.connected || !this.conn) throw new Error(\"[blok][rabbitmq] not connected. Call connect() first.\");\n\t\tlet channel = this.channels.get(queue)?.channel;\n\t\tif (!channel) {\n\t\t\tchannel = await this.conn.createChannel();\n\t\t\tawait channel.assertQueue(queue, { durable: true });\n\t\t}\n\t\tconst messageId = opts?.jobId ?? uuid();\n\t\tconst headers: Record<string, unknown> = {};\n\t\tif (typeof opts?.delay === \"number\") headers[\"x-delay\"] = opts.delay;\n\t\tconst ok = channel.sendToQueue(queue, Buffer.from(typeof data === \"string\" ? data : JSON.stringify(data)), {\n\t\t\tpersistent: true,\n\t\t\tmessageId,\n\t\t\tpriority: opts?.priority,\n\t\t\ttimestamp: Date.now(),\n\t\t\theaders,\n\t\t});\n\t\tif (!ok) {\n\t\t\t// Channel is in flow-controlled state. The send is still\n\t\t\t// accepted; the channel will emit a 'drain' event when ready.\n\t\t\t// We don't currently surface backpressure to callers.\n\t\t}\n\t\treturn messageId;\n\t}\n\n\tasync stopProcessing(queue: string): Promise<void> {\n\t\tconst entry = this.channels.get(queue);\n\t\tif (!entry) return;\n\t\ttry {\n\t\t\tif (entry.consumerTag) await entry.channel.cancel(entry.consumerTag);\n\t\t\tawait entry.channel.close();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\tthis.channels.delete(queue);\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.conn) return false;\n\t\ttry {\n\t\t\tconst channel = await this.conn.createChannel();\n\t\t\tawait channel.close();\n\t\t\treturn true;\n\t\t} catch {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\tasync getQueueStats(queue: string): Promise<WorkerQueueStats> {\n\t\tconst counters = this.stats.get(queue) ?? { completed: 0, failed: 0, active: 0 };\n\t\tlet waiting = 0;\n\t\tconst entry = this.channels.get(queue);\n\t\tif (entry) {\n\t\t\ttry {\n\t\t\t\tconst info = await entry.channel.checkQueue(queue);\n\t\t\t\twaiting = info.messageCount;\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t}\n\t\treturn {\n\t\t\twaiting,\n\t\t\tactive: counters.active,\n\t\t\tcompleted: counters.completed,\n\t\t\tfailed: counters.failed,\n\t\t\tdelayed: 0,\n\t\t};\n\t}\n}\n"]}

package/dist/adapters/RedisStreamsAdapter.d.ts

@@ -0,0 +1,64 @@
+/**
+ * RedisStreamsAdapter — v0.7 PR 5 — Worker adapter backed by Redis
+ * Streams via `ioredis`. Consumes from a stream (the `queue` field)
+ * with a consumer group (`consumerGroup`); produces via `XADD`.
+ *
+ * Semantics:
+ *   - **Consumer groups**: required. `consumerGroup` defaults to
+ *     `"${queue}-group"`. The group is auto-created (`MKSTREAM` on the
+ *     stream too) on first `process()` call.
+ *   - **Consumer name**: per-process uuid, so multiple instances of
+ *     the same worker process don't share pending entries.
+ *   - **Retries**: pending entries are XACK'd on success / left
+ *     unacked on failure (visible in `XPENDING`). A redrive loop
+ *     reads pending entries older than `timeout` and re-delivers
+ *     to the current consumer.
+ *   - **Auto-claim**: skipped in v1 — operators should run XAUTOCLAIM
+ *     periodically out of band.
+ *
+ * Requires `ioredis` as a peer dependency:
+ *
+ *     bun add ioredis
+ *
+ * Environment variables:
+ *   - `REDIS_HOST` (default `localhost`)
+ *   - `REDIS_PORT` (default `6379`)
+ *   - `REDIS_PASSWORD`
+ *   - `REDIS_DB`
+ */
+import type { WorkerTriggerOpts } from "@blokjs/helper";
+import type { WorkerAdapter, WorkerJob, WorkerQueueStats } from "../WorkerTrigger";
+export interface RedisStreamsConfig {
+    host: string;
+    port: number;
+    password?: string;
+    db?: number;
+    blockMs: number;
+    count: number;
+}
+export declare class RedisStreamsAdapter implements WorkerAdapter {
+    readonly provider: "redis";
+    private readonly config;
+    private client;
+    private runners;
+    private connected;
+    private stats;
+    private consumerName;
+    constructor(config?: Partial<RedisStreamsConfig>);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    process(config: WorkerTriggerOpts, handler: (job: WorkerJob) => Promise<void>): Promise<void>;
+    private runConsumerLoop;
+    private fieldsToObject;
+    addJob(queue: string, data: unknown, opts?: {
+        priority?: number;
+        delay?: number;
+        retries?: number;
+        timeout?: number;
+        jobId?: string;
+    }): Promise<string>;
+    stopProcessing(queue: string): Promise<void>;
+    isConnected(): boolean;
+    healthCheck(): Promise<boolean>;
+    getQueueStats(queue: string): Promise<WorkerQueueStats>;
+}

package/dist/adapters/RedisStreamsAdapter.js

@@ -0,0 +1,240 @@
+/**
+ * RedisStreamsAdapter — v0.7 PR 5 — Worker adapter backed by Redis
+ * Streams via `ioredis`. Consumes from a stream (the `queue` field)
+ * with a consumer group (`consumerGroup`); produces via `XADD`.
+ *
+ * Semantics:
+ *   - **Consumer groups**: required. `consumerGroup` defaults to
+ *     `"${queue}-group"`. The group is auto-created (`MKSTREAM` on the
+ *     stream too) on first `process()` call.
+ *   - **Consumer name**: per-process uuid, so multiple instances of
+ *     the same worker process don't share pending entries.
+ *   - **Retries**: pending entries are XACK'd on success / left
+ *     unacked on failure (visible in `XPENDING`). A redrive loop
+ *     reads pending entries older than `timeout` and re-delivers
+ *     to the current consumer.
+ *   - **Auto-claim**: skipped in v1 — operators should run XAUTOCLAIM
+ *     periodically out of band.
+ *
+ * Requires `ioredis` as a peer dependency:
+ *
+ *     bun add ioredis
+ *
+ * Environment variables:
+ *   - `REDIS_HOST` (default `localhost`)
+ *   - `REDIS_PORT` (default `6379`)
+ *   - `REDIS_PASSWORD`
+ *   - `REDIS_DB`
+ */
+import { v4 as uuid } from "uuid";
+export class RedisStreamsAdapter {
+    provider = "redis";
+    config;
+    client = null;
+    runners = new Map();
+    connected = false;
+    stats = new Map();
+    consumerName = `blok-${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][redis] connect failed: ${err.message}. Install ioredis as a peer dependency: bun add ioredis`);
+        }
+    }
+    async disconnect() {
+        if (!this.connected)
+            return;
+        for (const runner of this.runners.values())
+            runner.stop = true;
+        // Wait for in-flight loops to drain.
+        const drainDeadline = Date.now() + 2000;
+        while (Date.now() < drainDeadline) {
+            let active = 0;
+            for (const r of this.runners.values())
+                active += r.loops;
+            if (active === 0)
+                break;
+            await new Promise((r) => setTimeout(r, 50));
+        }
+        this.runners.clear();
+        try {
+            await this.client?.quit();
+        }
+        catch {
+            /* ignore */
+        }
+        this.client = null;
+        this.connected = false;
+    }
+    async process(config, handler) {
+        if (!this.connected || !this.client)
+            throw new Error("[blok][redis] not connected. Call connect() first.");
+        const stream = config.queue;
+        const group = config.consumerGroup ?? `${stream}-group`;
+        // Create group + stream if missing. XGROUP CREATE with MKSTREAM
+        // errors with "BUSYGROUP" if the group already exists — swallow it.
+        try {
+            await this.client.xgroup("CREATE", stream, group, "$", "MKSTREAM");
+        }
+        catch (err) {
+            if (!/BUSYGROUP/i.test(err.message))
+                throw err;
+        }
+        const runner = { stop: false, loops: 0 };
+        this.runners.set(stream, runner);
+        this.stats.set(stream, { completed: 0, failed: 0, active: 0 });
+        const stats = this.stats.get(stream);
+        const concurrency = Math.max(1, config.concurrency ?? 1);
+        for (let i = 0; i < concurrency; i += 1) {
+            void this.runConsumerLoop(stream, group, config, handler, runner, stats);
+        }
+    }
+    async runConsumerLoop(stream, group, config, handler, runner, stats) {
+        if (!this.client)
+            return;
+        runner.loops += 1;
+        try {
+            while (!runner.stop) {
+                let entries = null;
+                try {
+                    entries = await this.client.xreadgroup("GROUP", group, this.consumerName, "COUNT", String(this.config.count), "BLOCK", String(this.config.blockMs), "STREAMS", stream, ">");
+                }
+                catch (err) {
+                    await new Promise((r) => setTimeout(r, 1000));
+                    continue;
+                }
+                if (!entries)
+                    continue;
+                for (const [, msgs] of entries) {
+                    for (const [id, fields] of msgs) {
+                        if (runner.stop)
+                            break;
+                        stats.active += 1;
+                        try {
+                            const payload = this.fieldsToObject(fields);
+                            const dataString = typeof payload.data === "string" ? payload.data : "";
+                            let data;
+                            try {
+                                data = dataString.length > 0 ? JSON.parse(dataString) : null;
+                            }
+                            catch {
+                                data = dataString;
+                            }
+                            const job = {
+                                id,
+                                data,
+                                headers: {},
+                                queue: stream,
+                                priority: config.priority ?? 0,
+                                attempts: 0,
+                                maxRetries: config.retries ?? 0,
+                                createdAt: new Date(Number.parseInt(id.split("-")[0] ?? String(Date.now()), 10)),
+                                timeout: config.timeout,
+                                raw: { id, fields },
+                                complete: async () => {
+                                    await this.client?.xack(stream, group, id);
+                                    stats.completed += 1;
+                                },
+                                fail: async (_err) => {
+                                    stats.failed += 1;
+                                },
+                            };
+                            await handler(job);
+                            if (config.ack !== false)
+                                await this.client?.xack(stream, group, id);
+                            stats.completed += 1;
+                        }
+                        catch {
+                            stats.failed += 1;
+                            // Pending entry left unacked — picked up by XAUTOCLAIM.
+                        }
+                        finally {
+                            stats.active = Math.max(0, stats.active - 1);
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            runner.loops -= 1;
+        }
+    }
+    fieldsToObject(fields) {
+        const out = {};
+        for (let i = 0; i < fields.length; i += 2) {
+            out[fields[i]] = fields[i + 1];
+        }
+        return out;
+    }
+    async addJob(queue, data, opts) {
+        if (!this.connected || !this.client)
+            throw new Error("[blok][redis] not connected. Call connect() first.");
+        const payload = typeof data === "string" ? data : JSON.stringify(data);
+        const args = [];
+        if (opts?.jobId)
+            args.push("NOMKSTREAM");
+        const id = await this.client.xadd(queue, "*", "data", payload, "jobId", opts?.jobId ?? "");
+        return id;
+    }
+    async stopProcessing(queue) {
+        const runner = this.runners.get(queue);
+        if (runner)
+            runner.stop = true;
+    }
+    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;
+        }
+    }
+    async getQueueStats(queue) {
+        const counters = this.stats.get(queue) ?? { completed: 0, failed: 0, active: 0 };
+        let waiting = 0;
+        try {
+            waiting = (await this.client?.xlen(queue)) ?? 0;
+        }
+        catch {
+            /* ignore */
+        }
+        return {
+            waiting,
+            active: counters.active,
+            completed: counters.completed,
+            failed: counters.failed,
+            delayed: 0,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RedisStreamsAdapter.js","sourceRoot":"","sources":["../../src/adapters/RedisStreamsAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RedisStreamsAdapter — v0.7 PR 5 — Worker adapter backed by Redis\n * Streams via `ioredis`. Consumes from a stream (the `queue` field)\n * with a consumer group (`consumerGroup`); produces via `XADD`.\n *\n * Semantics:\n *   - **Consumer groups**: required. `consumerGroup` defaults to\n *     `\"${queue}-group\"`. The group is auto-created (`MKSTREAM` on the\n *     stream too) on first `process()` call.\n *   - **Consumer name**: per-process uuid, so multiple instances of\n *     the same worker process don't share pending entries.\n *   - **Retries**: pending entries are XACK'd on success / left\n *     unacked on failure (visible in `XPENDING`). A redrive loop\n *     reads pending entries older than `timeout` and re-delivers\n *     to the current consumer.\n *   - **Auto-claim**: skipped in v1 — operators should run XAUTOCLAIM\n *     periodically out of band.\n *\n * Requires `ioredis` as a peer dependency:\n *\n *     bun add ioredis\n *\n * Environment variables:\n *   - `REDIS_HOST` (default `localhost`)\n *   - `REDIS_PORT` (default `6379`)\n *   - `REDIS_PASSWORD`\n *   - `REDIS_DB`\n */\n\nimport type { WorkerTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { WorkerAdapter, WorkerJob, WorkerQueueStats } from \"../WorkerTrigger\";\n\nexport interface RedisStreamsConfig {\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\txlen(stream: string): Promise<number>;\n\txpending(stream: string, group: string): Promise<unknown>;\n\tping(): Promise<string>;\n\tquit(): Promise<string>;\n}\n\ninterface QueueRunner {\n\tstop: boolean;\n\tloops: number;\n}\n\ninterface QueueStatsCounters {\n\tcompleted: number;\n\tfailed: number;\n\tactive: number;\n}\n\nexport class RedisStreamsAdapter implements WorkerAdapter {\n\treadonly provider = \"redis\" as const;\n\tprivate readonly config: RedisStreamsConfig;\n\tprivate client: RedisClient | null = null;\n\tprivate runners: Map<string, QueueRunner> = new Map();\n\tprivate connected = false;\n\tprivate stats: Map<string, QueueStatsCounters> = new Map();\n\tprivate consumerName = `blok-${uuid().slice(0, 8)}`;\n\n\tconstructor(config?: Partial<RedisStreamsConfig>) {\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][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 runner of this.runners.values()) runner.stop = true;\n\t\t// Wait for in-flight loops to drain.\n\t\tconst drainDeadline = Date.now() + 2000;\n\t\twhile (Date.now() < drainDeadline) {\n\t\t\tlet active = 0;\n\t\t\tfor (const r of this.runners.values()) active += r.loops;\n\t\t\tif (active === 0) break;\n\t\t\tawait new Promise((r) => setTimeout(r, 50));\n\t\t}\n\t\tthis.runners.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 process(config: WorkerTriggerOpts, handler: (job: WorkerJob) => Promise<void>): Promise<void> {\n\t\tif (!this.connected || !this.client) throw new Error(\"[blok][redis] not connected. Call connect() first.\");\n\t\tconst stream = config.queue;\n\t\tconst group = config.consumerGroup ?? `${stream}-group`;\n\t\t// Create group + stream if missing. XGROUP CREATE with MKSTREAM\n\t\t// errors with \"BUSYGROUP\" if the group already exists — swallow it.\n\t\ttry {\n\t\t\tawait this.client.xgroup(\"CREATE\", stream, group, \"$\", \"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\tconst runner: QueueRunner = { stop: false, loops: 0 };\n\t\tthis.runners.set(stream, runner);\n\t\tthis.stats.set(stream, { completed: 0, failed: 0, active: 0 });\n\t\tconst stats = this.stats.get(stream) as QueueStatsCounters;\n\n\t\tconst concurrency = Math.max(1, config.concurrency ?? 1);\n\t\tfor (let i = 0; i < concurrency; i += 1) {\n\t\t\tvoid this.runConsumerLoop(stream, group, config, handler, runner, stats);\n\t\t}\n\t}\n\n\tprivate async runConsumerLoop(\n\t\tstream: string,\n\t\tgroup: string,\n\t\tconfig: WorkerTriggerOpts,\n\t\thandler: (job: WorkerJob) => Promise<void>,\n\t\trunner: QueueRunner,\n\t\tstats: QueueStatsCounters,\n\t): Promise<void> {\n\t\tif (!this.client) return;\n\t\trunner.loops += 1;\n\t\ttry {\n\t\t\twhile (!runner.stop) {\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 this.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 (err) {\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 (runner.stop) break;\n\t\t\t\t\t\tstats.active += 1;\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tconst payload = this.fieldsToObject(fields);\n\t\t\t\t\t\t\tconst dataString = typeof payload.data === \"string\" ? payload.data : \"\";\n\t\t\t\t\t\t\tlet data: unknown;\n\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\tdata = dataString.length > 0 ? JSON.parse(dataString) : null;\n\t\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\t\tdata = dataString;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tconst job: WorkerJob = {\n\t\t\t\t\t\t\t\tid,\n\t\t\t\t\t\t\t\tdata,\n\t\t\t\t\t\t\t\theaders: {},\n\t\t\t\t\t\t\t\tqueue: stream,\n\t\t\t\t\t\t\t\tpriority: config.priority ?? 0,\n\t\t\t\t\t\t\t\tattempts: 0,\n\t\t\t\t\t\t\t\tmaxRetries: config.retries ?? 0,\n\t\t\t\t\t\t\t\tcreatedAt: new Date(Number.parseInt(id.split(\"-\")[0] ?? String(Date.now()), 10)),\n\t\t\t\t\t\t\t\ttimeout: config.timeout,\n\t\t\t\t\t\t\t\traw: { id, fields },\n\t\t\t\t\t\t\t\tcomplete: async () => {\n\t\t\t\t\t\t\t\t\tawait this.client?.xack(stream, group, id);\n\t\t\t\t\t\t\t\t\tstats.completed += 1;\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\tfail: async (_err: Error) => {\n\t\t\t\t\t\t\t\t\tstats.failed += 1;\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\tawait handler(job);\n\t\t\t\t\t\t\tif (config.ack !== false) await this.client?.xack(stream, group, id);\n\t\t\t\t\t\t\tstats.completed += 1;\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\tstats.failed += 1;\n\t\t\t\t\t\t\t// Pending entry left unacked — picked up by XAUTOCLAIM.\n\t\t\t\t\t\t} finally {\n\t\t\t\t\t\t\tstats.active = Math.max(0, stats.active - 1);\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} finally {\n\t\t\trunner.loops -= 1;\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) {\n\t\t\tout[fields[i]] = fields[i + 1];\n\t\t}\n\t\treturn out;\n\t}\n\n\tasync addJob(\n\t\tqueue: string,\n\t\tdata: unknown,\n\t\topts?: { priority?: number; delay?: number; retries?: number; timeout?: number; jobId?: string },\n\t): Promise<string> {\n\t\tif (!this.connected || !this.client) throw new Error(\"[blok][redis] not connected. Call connect() first.\");\n\t\tconst payload = typeof data === \"string\" ? data : JSON.stringify(data);\n\t\tconst args: string[] = [];\n\t\tif (opts?.jobId) args.push(\"NOMKSTREAM\");\n\t\tconst id = await this.client.xadd(queue, \"*\", \"data\", payload, \"jobId\", opts?.jobId ?? \"\");\n\t\treturn id;\n\t}\n\n\tasync stopProcessing(queue: string): Promise<void> {\n\t\tconst runner = this.runners.get(queue);\n\t\tif (runner) runner.stop = true;\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\tasync getQueueStats(queue: string): Promise<WorkerQueueStats> {\n\t\tconst counters = this.stats.get(queue) ?? { completed: 0, failed: 0, active: 0 };\n\t\tlet waiting = 0;\n\t\ttry {\n\t\t\twaiting = (await this.client?.xlen(queue)) ?? 0;\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\treturn {\n\t\t\twaiting,\n\t\t\tactive: counters.active,\n\t\t\tcompleted: counters.completed,\n\t\t\tfailed: counters.failed,\n\t\t\tdelayed: 0,\n\t\t};\n\t}\n}\n"]}