@blokjs/trigger-worker 0.2.1 → 0.6.1

package/dist/adapters/NATSAdapter.js

@@ -0,0 +1,394 @@
+/**
+ * NATSAdapter - NATS JetStream worker adapter for WorkerTrigger
+ *
+ * Uses NATS JetStream for persistent background job processing with:
+ * - Pull-based consumers with configurable concurrency
+ * - Server-side retry config (max_deliver)
+ * - Ack wait for job timeouts
+ * - Priority via message headers
+ * - Delayed job scheduling
+ * - Queue statistics via consumer info
+ *
+ * Requires: npm install nats
+ *
+ * Environment variables:
+ * - NATS_SERVERS: Comma-separated NATS server URLs (default: localhost:4222)
+ * - NATS_TOKEN: Authentication token (optional)
+ * - NATS_USER: Username for auth (optional)
+ * - NATS_PASS: Password for auth (optional)
+ * - NATS_STREAM_NAME: JetStream stream name (default: blok-worker)
+ */
+import { v4 as uuid } from "uuid";
+/**
+ * Tier 2 polish — compute the consumer-side hold time for a NATS message
+ * with an `x-delay` header. NATS JetStream stores `x-delay` as opaque
+ * metadata; the broker does NOT defer delivery on it. The consumer is
+ * responsible for honouring the delay between the message's first-publish
+ * timestamp and `createdMs + delay`.
+ *
+ * Returns the milliseconds to wait. Clamps to >= 0; returns 0 when the
+ * delay has already elapsed (the message was queued for longer than the
+ * delay) or when no delay was set.
+ *
+ * Exported for unit testability — the consumer message handler in
+ * `NATSWorkerAdapter.process()` mocks the NATS client extensively, so
+ * isolating the math here keeps the surface easy to verify.
+ */
+export function computeXDelayHoldMs(delay, createdMs, nowMs) {
+    if (!delay || delay <= 0)
+        return 0;
+    const dispatchAt = createdMs + delay;
+    return Math.max(0, dispatchAt - nowMs);
+}
+/**
+ * NATSWorkerAdapter - NATS JetStream implementation of WorkerAdapter
+ */
+export class NATSWorkerAdapter {
+    provider = "nats";
+    // biome-ignore lint/suspicious/noExplicitAny: NATS types are dynamically imported (optional peer dependency)
+    nc = null;
+    // biome-ignore lint/suspicious/noExplicitAny: NATS types are dynamically imported
+    js = null;
+    // biome-ignore lint/suspicious/noExplicitAny: NATS types are dynamically imported
+    jsm = null;
+    connected = false;
+    config;
+    // biome-ignore lint/suspicious/noExplicitAny: NATS consumer instances
+    consumers = new Map();
+    // biome-ignore lint/suspicious/noExplicitAny: NATS consume iterators
+    consumeIterators = new Map();
+    constructor(config) {
+        this.config = {
+            servers: config?.servers || (process.env.NATS_SERVERS || "localhost:4222").split(","),
+            token: config?.token || process.env.NATS_TOKEN,
+            user: config?.user || process.env.NATS_USER,
+            pass: config?.pass || process.env.NATS_PASS,
+            streamName: config?.streamName || process.env.NATS_STREAM_NAME || "blok-worker",
+        };
+    }
+    /**
+     * Connect to NATS and initialize JetStream
+     */
+    async connect() {
+        if (this.connected)
+            return;
+        try {
+            const nats = await import("nats");
+            const connectOpts = {
+                servers: this.config.servers,
+            };
+            if (this.config.token)
+                connectOpts.token = this.config.token;
+            if (this.config.user)
+                connectOpts.user = this.config.user;
+            if (this.config.pass)
+                connectOpts.pass = this.config.pass;
+            this.nc = await nats.connect(connectOpts);
+            this.js = this.nc.jetstream();
+            this.jsm = await this.nc.jetstreamManager();
+            this.connected = true;
+            console.log(`[NATSWorkerAdapter] Connected to NATS: ${this.config.servers.join(", ")}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to connect to NATS: ${error.message}. Make sure nats is installed: npm install nats`);
+        }
+    }
+    /**
+     * Disconnect from NATS
+     */
+    async disconnect() {
+        if (!this.connected)
+            return;
+        try {
+            // Stop all consume iterators
+            for (const [, iter] of this.consumeIterators) {
+                try {
+                    iter.stop();
+                }
+                catch {
+                    // Iterator may already be stopped
+                }
+            }
+            this.consumeIterators.clear();
+            this.consumers.clear();
+            await this.nc.drain();
+            this.connected = false;
+            console.log("[NATSWorkerAdapter] Disconnected from NATS");
+        }
+        catch (error) {
+            console.error(`[NATSWorkerAdapter] Disconnect error: ${error.message}`);
+        }
+    }
+    /**
+     * Start processing jobs from a queue
+     */
+    async process(config, handler) {
+        if (!this.connected) {
+            throw new Error("Not connected. Call connect() first.");
+        }
+        const nats = await import("nats");
+        const queue = config.queue;
+        const streamName = this.config.streamName || "blok-worker";
+        const subject = `worker.${queue}`;
+        const durableName = `blok-worker-${queue}`;
+        // Ensure stream exists with worker subjects
+        await this.ensureStream(streamName, [subject]);
+        // Create or update durable pull consumer with worker semantics
+        const ackWaitNs = ((config.timeout ?? 30000) + 5000) * 1_000_000; // timeout + 5s buffer, in nanoseconds
+        await this.jsm.consumers.add(streamName, {
+            durable_name: durableName,
+            ack_policy: nats.AckPolicy.Explicit,
+            max_deliver: (config.retries ?? 3) + 1, // +1 because first attempt counts
+            ack_wait: ackWaitNs,
+            filter_subjects: [subject],
+        });
+        // Get consumer handle
+        const consumer = await this.js.consumers.get(streamName, durableName);
+        this.consumers.set(queue, consumer);
+        // Start consuming
+        const iter = await consumer.consume();
+        this.consumeIterators.set(queue, iter);
+        // Process jobs in background
+        (async () => {
+            const semaphore = new Semaphore(config.concurrency ?? 1);
+            for await (const msg of iter) {
+                await semaphore.acquire();
+                // Process each job concurrently up to concurrency limit
+                (async () => {
+                    try {
+                        // Parse job data
+                        let data;
+                        try {
+                            const codec = nats.JSONCodec();
+                            data = codec.decode(msg.data);
+                        }
+                        catch {
+                            try {
+                                const sc = nats.StringCodec();
+                                data = JSON.parse(sc.decode(msg.data));
+                            }
+                            catch {
+                                data = msg.data;
+                            }
+                        }
+                        // Extract headers
+                        const headers = {};
+                        if (msg.headers) {
+                            for (const [key, values] of msg.headers) {
+                                headers[key] = Array.isArray(values) ? values[0] : values;
+                            }
+                        }
+                        // Extract job metadata from headers
+                        const jobId = headers["x-job-id"] || msg.headers?.get("Nats-Msg-Id") || uuid();
+                        const priority = Number.parseInt(headers["x-priority"] || "0", 10);
+                        const delay = Number.parseInt(headers["x-delay"] || "0", 10);
+                        const timeout = Number.parseInt(headers["x-timeout"] || "0", 10);
+                        // Get redelivery count (attempts)
+                        const info = msg.info;
+                        const attempts = info.redeliveryCount ?? 0;
+                        const maxRetries = config.retries ?? 3;
+                        // Create WorkerJob
+                        const workerJob = {
+                            id: jobId,
+                            data,
+                            headers,
+                            queue,
+                            priority,
+                            attempts,
+                            maxRetries,
+                            createdAt: new Date(info.timestampNanos ? Math.floor(Number(info.timestampNanos) / 1_000_000) : Date.now()),
+                            delay: delay || undefined,
+                            timeout: timeout || config.timeout || undefined,
+                            raw: msg,
+                            complete: async () => {
+                                msg.ack();
+                            },
+                            fail: async (error, requeue) => {
+                                if (requeue) {
+                                    // nak() tells the server to redeliver
+                                    msg.nak();
+                                }
+                                else {
+                                    // term() terminates delivery — no more retries
+                                    msg.term();
+                                }
+                            },
+                        };
+                        // Tier 2 polish — enforce `x-delay` header on the consumer side.
+                        // NATS JetStream stores `x-delay` as opaque metadata; the broker
+                        // does NOT defer delivery on it. We implement consumer-side
+                        // holding here. createdMs is the message's first-publish timestamp;
+                        // hold until createdMs + delay. Single-process semantics — for
+                        // long deferrals, prefer trigger-level `delay` (DeferredRunScheduler).
+                        const createdMs = info.timestampNanos ? Math.floor(Number(info.timestampNanos) / 1_000_000) : Date.now();
+                        const waitMs = computeXDelayHoldMs(delay, createdMs, Date.now());
+                        if (waitMs > 0) {
+                            await new Promise((resolve) => setTimeout(resolve, waitMs));
+                        }
+                        await handler(workerJob);
+                    }
+                    catch (error) {
+                        console.error(`[NATSWorkerAdapter] Error processing job from ${queue}: ${error.message}`);
+                        try {
+                            msg.nak();
+                        }
+                        catch {
+                            // Already acked/nacked
+                        }
+                    }
+                    finally {
+                        semaphore.release();
+                    }
+                })();
+            }
+        })();
+        console.log(`[NATSWorkerAdapter] Processing queue: ${queue} (concurrency=${config.concurrency ?? 1}, retries=${config.retries ?? 3})`);
+    }
+    /**
+     * Add a job to a worker queue
+     */
+    async addJob(queue, data, opts) {
+        if (!this.connected) {
+            throw new Error("Not connected. Call connect() first.");
+        }
+        const nats = await import("nats");
+        const subject = `worker.${queue}`;
+        const streamName = this.config.streamName || "blok-worker";
+        // Ensure stream has this subject
+        await this.ensureStream(streamName, [subject]);
+        // Build headers with job metadata
+        const hdrs = nats.headers();
+        const jobId = opts?.jobId || uuid();
+        hdrs.set("x-job-id", jobId);
+        hdrs.set("Nats-Msg-Id", jobId); // Deduplication
+        if (opts?.priority)
+            hdrs.set("x-priority", String(opts.priority));
+        if (opts?.delay)
+            hdrs.set("x-delay", String(opts.delay));
+        if (opts?.timeout)
+            hdrs.set("x-timeout", String(opts.timeout));
+        // Encode and publish
+        const codec = nats.JSONCodec();
+        await this.js.publish(subject, codec.encode(data), { headers: hdrs });
+        return jobId;
+    }
+    /**
+     * Stop processing a specific queue
+     */
+    async stopProcessing(queue) {
+        const iter = this.consumeIterators.get(queue);
+        if (iter) {
+            try {
+                iter.stop();
+            }
+            catch {
+                // Already stopped
+            }
+            this.consumeIterators.delete(queue);
+        }
+        this.consumers.delete(queue);
+        console.log(`[NATSWorkerAdapter] Stopped processing queue: ${queue}`);
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Health check
+     */
+    async healthCheck() {
+        if (!this.connected || !this.nc)
+            return false;
+        try {
+            const info = this.nc.info;
+            return info !== undefined;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get queue statistics from JetStream consumer info
+     */
+    async getQueueStats(queue) {
+        if (!this.connected) {
+            return { waiting: 0, active: 0, completed: 0, failed: 0, delayed: 0 };
+        }
+        try {
+            const streamName = this.config.streamName || "blok-worker";
+            const durableName = `blok-worker-${queue}`;
+            const info = await this.jsm.consumers.info(streamName, durableName);
+            return {
+                waiting: info.num_pending ?? 0,
+                active: info.num_ack_pending ?? 0,
+                completed: info.delivered?.consumer_seq ?? 0,
+                failed: info.num_redelivered ?? 0,
+                delayed: 0, // NATS doesn't have a native delayed count
+            };
+        }
+        catch {
+            return { waiting: 0, active: 0, completed: 0, failed: 0, delayed: 0 };
+        }
+    }
+    /**
+     * Ensure a JetStream stream exists with the given subjects
+     */
+    async ensureStream(name, subjects) {
+        try {
+            const info = await this.jsm.streams.info(name);
+            // Merge new subjects with existing
+            const existingSubjects = info.config.subjects || [];
+            const allSubjects = [...new Set([...existingSubjects, ...subjects])];
+            if (allSubjects.length !== existingSubjects.length) {
+                await this.jsm.streams.update(name, {
+                    ...info.config,
+                    subjects: allSubjects,
+                });
+            }
+        }
+        catch {
+            // Stream doesn't exist, create it
+            await this.jsm.streams.add({
+                name,
+                subjects,
+                // biome-ignore lint/suspicious/noExplicitAny: nats JetStream retention policy enum
+                retention: "workqueue",
+                max_deliver: 4, // default: 3 retries + 1 initial attempt
+                // biome-ignore lint/suspicious/noExplicitAny: nats JetStream storage type enum
+                storage: "file",
+            });
+        }
+    }
+}
+/**
+ * Simple semaphore for concurrency control
+ */
+class Semaphore {
+    permits;
+    waiting = [];
+    constructor(permits) {
+        this.permits = permits;
+    }
+    async acquire() {
+        if (this.permits > 0) {
+            this.permits--;
+            return;
+        }
+        return new Promise((resolve) => {
+            this.waiting.push(resolve);
+        });
+    }
+    release() {
+        const next = this.waiting.shift();
+        if (next) {
+            next();
+        }
+        else {
+            this.permits++;
+        }
+    }
+}
+export default NATSWorkerAdapter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"NATSAdapter.js","sourceRoot":"","sources":["../../src/adapters/NATSAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * NATSAdapter - NATS JetStream worker adapter for WorkerTrigger\n *\n * Uses NATS JetStream for persistent background job processing with:\n * - Pull-based consumers with configurable concurrency\n * - Server-side retry config (max_deliver)\n * - Ack wait for job timeouts\n * - Priority via message headers\n * - Delayed job scheduling\n * - Queue statistics via consumer info\n *\n * Requires: npm install nats\n *\n * Environment variables:\n * - NATS_SERVERS: Comma-separated NATS server URLs (default: localhost:4222)\n * - NATS_TOKEN: Authentication token (optional)\n * - NATS_USER: Username for auth (optional)\n * - NATS_PASS: Password for auth (optional)\n * - NATS_STREAM_NAME: JetStream stream name (default: blok-worker)\n */\n\nimport type { WorkerTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { WorkerAdapter, WorkerJob, WorkerQueueStats } from \"../WorkerTrigger\";\n\n/**\n * Tier 2 polish — compute the consumer-side hold time for a NATS message\n * with an `x-delay` header. NATS JetStream stores `x-delay` as opaque\n * metadata; the broker does NOT defer delivery on it. The consumer is\n * responsible for honouring the delay between the message's first-publish\n * timestamp and `createdMs + delay`.\n *\n * Returns the milliseconds to wait. Clamps to >= 0; returns 0 when the\n * delay has already elapsed (the message was queued for longer than the\n * delay) or when no delay was set.\n *\n * Exported for unit testability — the consumer message handler in\n * `NATSWorkerAdapter.process()` mocks the NATS client extensively, so\n * isolating the math here keeps the surface easy to verify.\n */\nexport function computeXDelayHoldMs(delay: number, createdMs: number, nowMs: number): number {\n\tif (!delay || delay <= 0) return 0;\n\tconst dispatchAt = createdMs + delay;\n\treturn Math.max(0, dispatchAt - nowMs);\n}\n\n/**\n * NATS worker adapter configuration\n */\nexport interface NATSWorkerConfig {\n\t/** NATS server URLs */\n\tservers: string[];\n\t/** Authentication token */\n\ttoken?: string;\n\t/** Username */\n\tuser?: string;\n\t/** Password */\n\tpass?: string;\n\t/** JetStream stream name (default: \"blok-worker\") */\n\tstreamName?: string;\n}\n\n/**\n * NATSWorkerAdapter - NATS JetStream implementation of WorkerAdapter\n */\nexport class NATSWorkerAdapter implements WorkerAdapter {\n\treadonly provider = \"nats\" as const;\n\n\t// biome-ignore lint/suspicious/noExplicitAny: NATS types are dynamically imported (optional peer dependency)\n\tprivate nc: any = null;\n\t// biome-ignore lint/suspicious/noExplicitAny: NATS types are dynamically imported\n\tprivate js: any = null;\n\t// biome-ignore lint/suspicious/noExplicitAny: NATS types are dynamically imported\n\tprivate jsm: any = null;\n\tprivate connected = false;\n\tprivate config: NATSWorkerConfig;\n\t// biome-ignore lint/suspicious/noExplicitAny: NATS consumer instances\n\tprivate consumers: Map<string, any> = new Map();\n\t// biome-ignore lint/suspicious/noExplicitAny: NATS consume iterators\n\tprivate consumeIterators: Map<string, any> = new Map();\n\n\tconstructor(config?: Partial<NATSWorkerConfig>) {\n\t\tthis.config = {\n\t\t\tservers: config?.servers || (process.env.NATS_SERVERS || \"localhost:4222\").split(\",\"),\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\tstreamName: config?.streamName || process.env.NATS_STREAM_NAME || \"blok-worker\",\n\t\t};\n\t}\n\n\t/**\n\t * Connect to NATS and initialize JetStream\n\t */\n\tasync connect(): Promise<void> {\n\t\tif (this.connected) return;\n\n\t\ttry {\n\t\t\tconst nats = await import(\"nats\");\n\n\t\t\tconst connectOpts: Record<string, unknown> = {\n\t\t\t\tservers: this.config.servers,\n\t\t\t};\n\n\t\t\tif (this.config.token) connectOpts.token = this.config.token;\n\t\t\tif (this.config.user) connectOpts.user = this.config.user;\n\t\t\tif (this.config.pass) connectOpts.pass = this.config.pass;\n\n\t\t\tthis.nc = await nats.connect(connectOpts);\n\t\t\tthis.js = this.nc.jetstream();\n\t\t\tthis.jsm = await this.nc.jetstreamManager();\n\n\t\t\tthis.connected = true;\n\t\t\tconsole.log(`[NATSWorkerAdapter] Connected to NATS: ${this.config.servers.join(\", \")}`);\n\t\t} catch (error) {\n\t\t\tthrow new Error(\n\t\t\t\t`Failed to connect to NATS: ${(error as Error).message}. Make sure nats is installed: npm install nats`,\n\t\t\t);\n\t\t}\n\t}\n\n\t/**\n\t * Disconnect from NATS\n\t */\n\tasync disconnect(): Promise<void> {\n\t\tif (!this.connected) return;\n\n\t\ttry {\n\t\t\t// Stop all consume iterators\n\t\t\tfor (const [, iter] of this.consumeIterators) {\n\t\t\t\ttry {\n\t\t\t\t\titer.stop();\n\t\t\t\t} catch {\n\t\t\t\t\t// Iterator may already be stopped\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis.consumeIterators.clear();\n\t\t\tthis.consumers.clear();\n\n\t\t\tawait this.nc.drain();\n\t\t\tthis.connected = false;\n\t\t\tconsole.log(\"[NATSWorkerAdapter] Disconnected from NATS\");\n\t\t} catch (error) {\n\t\t\tconsole.error(`[NATSWorkerAdapter] Disconnect error: ${(error as Error).message}`);\n\t\t}\n\t}\n\n\t/**\n\t * Start processing jobs from a queue\n\t */\n\tasync process(config: WorkerTriggerOpts, handler: (job: WorkerJob) => Promise<void>): Promise<void> {\n\t\tif (!this.connected) {\n\t\t\tthrow new Error(\"Not connected. Call connect() first.\");\n\t\t}\n\n\t\tconst nats = await import(\"nats\");\n\t\tconst queue = config.queue;\n\t\tconst streamName = this.config.streamName || \"blok-worker\";\n\t\tconst subject = `worker.${queue}`;\n\t\tconst durableName = `blok-worker-${queue}`;\n\n\t\t// Ensure stream exists with worker subjects\n\t\tawait this.ensureStream(streamName, [subject]);\n\n\t\t// Create or update durable pull consumer with worker semantics\n\t\tconst ackWaitNs = ((config.timeout ?? 30000) + 5000) * 1_000_000; // timeout + 5s buffer, in nanoseconds\n\t\tawait this.jsm.consumers.add(streamName, {\n\t\t\tdurable_name: durableName,\n\t\t\tack_policy: nats.AckPolicy.Explicit,\n\t\t\tmax_deliver: (config.retries ?? 3) + 1, // +1 because first attempt counts\n\t\t\tack_wait: ackWaitNs,\n\t\t\tfilter_subjects: [subject],\n\t\t});\n\n\t\t// Get consumer handle\n\t\tconst consumer = await this.js.consumers.get(streamName, durableName);\n\t\tthis.consumers.set(queue, consumer);\n\n\t\t// Start consuming\n\t\tconst iter = await consumer.consume();\n\t\tthis.consumeIterators.set(queue, iter);\n\n\t\t// Process jobs in background\n\t\t(async () => {\n\t\t\tconst semaphore = new Semaphore(config.concurrency ?? 1);\n\n\t\t\tfor await (const msg of iter) {\n\t\t\t\tawait semaphore.acquire();\n\n\t\t\t\t// Process each job concurrently up to concurrency limit\n\t\t\t\t(async () => {\n\t\t\t\t\ttry {\n\t\t\t\t\t\t// Parse job data\n\t\t\t\t\t\tlet data: unknown;\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tconst codec = nats.JSONCodec();\n\t\t\t\t\t\t\tdata = codec.decode(msg.data);\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\tconst sc = nats.StringCodec();\n\t\t\t\t\t\t\t\tdata = JSON.parse(sc.decode(msg.data));\n\t\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\t\tdata = msg.data;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Extract headers\n\t\t\t\t\t\tconst headers: Record<string, string> = {};\n\t\t\t\t\t\tif (msg.headers) {\n\t\t\t\t\t\t\tfor (const [key, values] of msg.headers) {\n\t\t\t\t\t\t\t\theaders[key] = Array.isArray(values) ? values[0] : values;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Extract job metadata from headers\n\t\t\t\t\t\tconst jobId = headers[\"x-job-id\"] || msg.headers?.get(\"Nats-Msg-Id\") || uuid();\n\t\t\t\t\t\tconst priority = Number.parseInt(headers[\"x-priority\"] || \"0\", 10);\n\t\t\t\t\t\tconst delay = Number.parseInt(headers[\"x-delay\"] || \"0\", 10);\n\t\t\t\t\t\tconst timeout = Number.parseInt(headers[\"x-timeout\"] || \"0\", 10);\n\n\t\t\t\t\t\t// Get redelivery count (attempts)\n\t\t\t\t\t\tconst info = msg.info;\n\t\t\t\t\t\tconst attempts = info.redeliveryCount ?? 0;\n\t\t\t\t\t\tconst maxRetries = config.retries ?? 3;\n\n\t\t\t\t\t\t// Create WorkerJob\n\t\t\t\t\t\tconst workerJob: WorkerJob = {\n\t\t\t\t\t\t\tid: jobId,\n\t\t\t\t\t\t\tdata,\n\t\t\t\t\t\t\theaders,\n\t\t\t\t\t\t\tqueue,\n\t\t\t\t\t\t\tpriority,\n\t\t\t\t\t\t\tattempts,\n\t\t\t\t\t\t\tmaxRetries,\n\t\t\t\t\t\t\tcreatedAt: new Date(\n\t\t\t\t\t\t\t\tinfo.timestampNanos ? Math.floor(Number(info.timestampNanos) / 1_000_000) : Date.now(),\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\tdelay: delay || undefined,\n\t\t\t\t\t\t\ttimeout: timeout || config.timeout || undefined,\n\t\t\t\t\t\t\traw: msg,\n\t\t\t\t\t\t\tcomplete: async () => {\n\t\t\t\t\t\t\t\tmsg.ack();\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tfail: async (error: Error, requeue?: boolean) => {\n\t\t\t\t\t\t\t\tif (requeue) {\n\t\t\t\t\t\t\t\t\t// nak() tells the server to redeliver\n\t\t\t\t\t\t\t\t\tmsg.nak();\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\t// term() terminates delivery — no more retries\n\t\t\t\t\t\t\t\t\tmsg.term();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t};\n\n\t\t\t\t\t\t// Tier 2 polish — enforce `x-delay` header on the consumer side.\n\t\t\t\t\t\t// NATS JetStream stores `x-delay` as opaque metadata; the broker\n\t\t\t\t\t\t// does NOT defer delivery on it. We implement consumer-side\n\t\t\t\t\t\t// holding here. createdMs is the message's first-publish timestamp;\n\t\t\t\t\t\t// hold until createdMs + delay. Single-process semantics — for\n\t\t\t\t\t\t// long deferrals, prefer trigger-level `delay` (DeferredRunScheduler).\n\t\t\t\t\t\tconst createdMs = info.timestampNanos ? Math.floor(Number(info.timestampNanos) / 1_000_000) : Date.now();\n\t\t\t\t\t\tconst waitMs = computeXDelayHoldMs(delay, createdMs, Date.now());\n\t\t\t\t\t\tif (waitMs > 0) {\n\t\t\t\t\t\t\tawait new Promise<void>((resolve) => setTimeout(resolve, waitMs));\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tawait handler(workerJob);\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tconsole.error(`[NATSWorkerAdapter] Error processing job from ${queue}: ${(error as Error).message}`);\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tmsg.nak();\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\t// Already acked/nacked\n\t\t\t\t\t\t}\n\t\t\t\t\t} finally {\n\t\t\t\t\t\tsemaphore.release();\n\t\t\t\t\t}\n\t\t\t\t})();\n\t\t\t}\n\t\t})();\n\n\t\tconsole.log(\n\t\t\t`[NATSWorkerAdapter] Processing queue: ${queue} (concurrency=${config.concurrency ?? 1}, retries=${config.retries ?? 3})`,\n\t\t);\n\t}\n\n\t/**\n\t * Add a job to a worker queue\n\t */\n\tasync addJob(\n\t\tqueue: string,\n\t\tdata: unknown,\n\t\topts?: {\n\t\t\tpriority?: number;\n\t\t\tdelay?: number;\n\t\t\tretries?: number;\n\t\t\ttimeout?: number;\n\t\t\tjobId?: string;\n\t\t},\n\t): Promise<string> {\n\t\tif (!this.connected) {\n\t\t\tthrow new Error(\"Not connected. Call connect() first.\");\n\t\t}\n\n\t\tconst nats = await import(\"nats\");\n\t\tconst subject = `worker.${queue}`;\n\t\tconst streamName = this.config.streamName || \"blok-worker\";\n\n\t\t// Ensure stream has this subject\n\t\tawait this.ensureStream(streamName, [subject]);\n\n\t\t// Build headers with job metadata\n\t\tconst hdrs = nats.headers();\n\t\tconst jobId = opts?.jobId || uuid();\n\t\thdrs.set(\"x-job-id\", jobId);\n\t\thdrs.set(\"Nats-Msg-Id\", jobId); // Deduplication\n\t\tif (opts?.priority) hdrs.set(\"x-priority\", String(opts.priority));\n\t\tif (opts?.delay) hdrs.set(\"x-delay\", String(opts.delay));\n\t\tif (opts?.timeout) hdrs.set(\"x-timeout\", String(opts.timeout));\n\n\t\t// Encode and publish\n\t\tconst codec = nats.JSONCodec();\n\t\tawait this.js.publish(subject, codec.encode(data), { headers: hdrs });\n\n\t\treturn jobId;\n\t}\n\n\t/**\n\t * Stop processing a specific queue\n\t */\n\tasync stopProcessing(queue: string): Promise<void> {\n\t\tconst iter = this.consumeIterators.get(queue);\n\t\tif (iter) {\n\t\t\ttry {\n\t\t\t\titer.stop();\n\t\t\t} catch {\n\t\t\t\t// Already stopped\n\t\t\t}\n\t\t\tthis.consumeIterators.delete(queue);\n\t\t}\n\t\tthis.consumers.delete(queue);\n\t\tconsole.log(`[NATSWorkerAdapter] Stopped processing queue: ${queue}`);\n\t}\n\n\t/**\n\t * Check if connected\n\t */\n\tisConnected(): boolean {\n\t\treturn this.connected;\n\t}\n\n\t/**\n\t * Health check\n\t */\n\tasync healthCheck(): Promise<boolean> {\n\t\tif (!this.connected || !this.nc) return false;\n\t\ttry {\n\t\t\tconst info = this.nc.info;\n\t\t\treturn info !== undefined;\n\t\t} catch {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\t/**\n\t * Get queue statistics from JetStream consumer info\n\t */\n\tasync getQueueStats(queue: string): Promise<WorkerQueueStats> {\n\t\tif (!this.connected) {\n\t\t\treturn { waiting: 0, active: 0, completed: 0, failed: 0, delayed: 0 };\n\t\t}\n\n\t\ttry {\n\t\t\tconst streamName = this.config.streamName || \"blok-worker\";\n\t\t\tconst durableName = `blok-worker-${queue}`;\n\n\t\t\tconst info = await this.jsm.consumers.info(streamName, durableName);\n\n\t\t\treturn {\n\t\t\t\twaiting: info.num_pending ?? 0,\n\t\t\t\tactive: info.num_ack_pending ?? 0,\n\t\t\t\tcompleted: info.delivered?.consumer_seq ?? 0,\n\t\t\t\tfailed: info.num_redelivered ?? 0,\n\t\t\t\tdelayed: 0, // NATS doesn't have a native delayed count\n\t\t\t};\n\t\t} catch {\n\t\t\treturn { waiting: 0, active: 0, completed: 0, failed: 0, delayed: 0 };\n\t\t}\n\t}\n\n\t/**\n\t * Ensure a JetStream stream exists with the given subjects\n\t */\n\tprivate async ensureStream(name: string, subjects: string[]): Promise<void> {\n\t\ttry {\n\t\t\tconst info = await this.jsm.streams.info(name);\n\n\t\t\t// Merge new subjects with existing\n\t\t\tconst existingSubjects = info.config.subjects || [];\n\t\t\tconst allSubjects = [...new Set([...existingSubjects, ...subjects])];\n\n\t\t\tif (allSubjects.length !== existingSubjects.length) {\n\t\t\t\tawait this.jsm.streams.update(name, {\n\t\t\t\t\t...info.config,\n\t\t\t\t\tsubjects: allSubjects,\n\t\t\t\t});\n\t\t\t}\n\t\t} catch {\n\t\t\t// Stream doesn't exist, create it\n\t\t\tawait this.jsm.streams.add({\n\t\t\t\tname,\n\t\t\t\tsubjects,\n\t\t\t\t// biome-ignore lint/suspicious/noExplicitAny: nats JetStream retention policy enum\n\t\t\t\tretention: \"workqueue\" as any,\n\t\t\t\tmax_deliver: 4, // default: 3 retries + 1 initial attempt\n\t\t\t\t// biome-ignore lint/suspicious/noExplicitAny: nats JetStream storage type enum\n\t\t\t\tstorage: \"file\" as any,\n\t\t\t});\n\t\t}\n\t}\n}\n\n/**\n * Simple semaphore for concurrency control\n */\nclass Semaphore {\n\tprivate permits: number;\n\tprivate waiting: Array<() => void> = [];\n\n\tconstructor(permits: number) {\n\t\tthis.permits = permits;\n\t}\n\n\tasync acquire(): Promise<void> {\n\t\tif (this.permits > 0) {\n\t\t\tthis.permits--;\n\t\t\treturn;\n\t\t}\n\t\treturn new Promise<void>((resolve) => {\n\t\t\tthis.waiting.push(resolve);\n\t\t});\n\t}\n\n\trelease(): void {\n\t\tconst next = this.waiting.shift();\n\t\tif (next) {\n\t\t\tnext();\n\t\t} else {\n\t\t\tthis.permits++;\n\t\t}\n\t}\n}\n\nexport default NATSWorkerAdapter;\n"]}

package/dist/adapters/PgBossAdapter.d.ts

@@ -0,0 +1,56 @@
+/**
+ * PgBossAdapter — v0.7 PR 5 — Worker adapter backed by `pg-boss`,
+ * which stores jobs in PostgreSQL. Operationally attractive when
+ * Postgres is already in the stack — no extra broker infra needed.
+ *
+ * Semantics:
+ *   - `pg-boss` handles concurrency, retries, dead-letter, priority,
+ *     delays, and exactly-once scheduling natively — the adapter
+ *     forwards `config.concurrency`, `config.retries`, etc. to the
+ *     `boss.work(queue, opts, handler)` and `boss.send(queue, data, opts)`
+ *     calls directly.
+ *   - **Single connection per process** — `pg-boss` manages its own
+ *     pool; we instantiate one `PgBoss` instance per `PgBossAdapter`.
+ *   - **Schema**: `pg-boss` creates its own schema (`pgboss` by
+ *     default) on first start. Tables are migrated automatically.
+ *
+ * Requires `pg-boss` as a peer dependency:
+ *
+ *     bun add pg-boss
+ *
+ * Environment variables:
+ *   - `DATABASE_URL` — Postgres connection string (default
+ *     `postgres://localhost:5432/blok`).
+ *   - `PG_BOSS_SCHEMA` — schema name (default `"pgboss"`).
+ */
+import type { WorkerTriggerOpts } from "@blokjs/helper";
+import type { WorkerAdapter, WorkerJob, WorkerQueueStats } from "../WorkerTrigger";
+export interface PgBossConfig {
+    connectionString: string;
+    schema?: string;
+}
+export declare class PgBossAdapter implements WorkerAdapter {
+    readonly provider: "pg-boss";
+    private readonly config;
+    private boss;
+    private workIds;
+    private connected;
+    private stats;
+    constructor(config?: Partial<PgBossConfig>);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    process(config: WorkerTriggerOpts, handler: (job: WorkerJob) => Promise<void>): Promise<void>;
+    private runOneJob;
+    private ensureQueue;
+    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>;
+}