@blokjs/trigger-worker 0.4.0 → 0.6.1

package/dist/adapters/SQSAdapter.d.ts

@@ -0,0 +1,61 @@
+/**
+ * SQSAdapter — v0.7 PR 5 — Worker adapter backed by AWS SQS via
+ * `@aws-sdk/client-sqs`. Polls a queue URL (the `queue` field) with
+ * long-polling; processes messages with manual delete (ACK).
+ *
+ * Semantics:
+ *   - **Long polling**: `WaitTimeSeconds=20` by default — minimises
+ *     poll cost. `concurrency` controls how many parallel
+ *     `ReceiveMessage` loops run.
+ *   - **Visibility timeout**: configured via `timeout` (ms → s).
+ *     Messages reappear after this if the worker doesn't delete them.
+ *   - **Retries**: SQS handles retries automatically via redrive
+ *     policy on the queue itself. The adapter doesn't simulate
+ *     retries client-side — set `MaxReceiveCount` on the queue's
+ *     redrive policy and a DLQ via `deadLetterQueue`.
+ *   - **FIFO support**: when the queue URL ends with `.fifo`, the
+ *     adapter passes `MessageGroupId` from `dedupId` or a default.
+ *
+ * Requires `@aws-sdk/client-sqs` as a peer dependency:
+ *
+ *     bun add @aws-sdk/client-sqs
+ *
+ * Environment variables (standard AWS SDK):
+ *   - `AWS_REGION`              — default `us-east-1`.
+ *   - `AWS_ACCESS_KEY_ID`       — credentials (or use a profile).
+ *   - `AWS_SECRET_ACCESS_KEY`
+ *   - `SQS_ENDPOINT_URL`        — for local SQS (LocalStack / ElasticMQ).
+ */
+import type { WorkerTriggerOpts } from "@blokjs/helper";
+import type { WorkerAdapter, WorkerJob, WorkerQueueStats } from "../WorkerTrigger";
+export interface SQSConfig {
+    region: string;
+    endpoint?: string;
+    waitTimeSeconds: number;
+    maxNumberOfMessages: number;
+}
+export declare class SQSAdapter implements WorkerAdapter {
+    readonly provider: "sqs";
+    private readonly config;
+    private client;
+    private commands;
+    private runners;
+    private connected;
+    private stats;
+    constructor(config?: Partial<SQSConfig>);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    process(config: WorkerTriggerOpts, handler: (job: WorkerJob) => Promise<void>): Promise<void>;
+    private runConsumerLoop;
+    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/SQSAdapter.js

@@ -0,0 +1,269 @@
+/**
+ * SQSAdapter — v0.7 PR 5 — Worker adapter backed by AWS SQS via
+ * `@aws-sdk/client-sqs`. Polls a queue URL (the `queue` field) with
+ * long-polling; processes messages with manual delete (ACK).
+ *
+ * Semantics:
+ *   - **Long polling**: `WaitTimeSeconds=20` by default — minimises
+ *     poll cost. `concurrency` controls how many parallel
+ *     `ReceiveMessage` loops run.
+ *   - **Visibility timeout**: configured via `timeout` (ms → s).
+ *     Messages reappear after this if the worker doesn't delete them.
+ *   - **Retries**: SQS handles retries automatically via redrive
+ *     policy on the queue itself. The adapter doesn't simulate
+ *     retries client-side — set `MaxReceiveCount` on the queue's
+ *     redrive policy and a DLQ via `deadLetterQueue`.
+ *   - **FIFO support**: when the queue URL ends with `.fifo`, the
+ *     adapter passes `MessageGroupId` from `dedupId` or a default.
+ *
+ * Requires `@aws-sdk/client-sqs` as a peer dependency:
+ *
+ *     bun add @aws-sdk/client-sqs
+ *
+ * Environment variables (standard AWS SDK):
+ *   - `AWS_REGION`              — default `us-east-1`.
+ *   - `AWS_ACCESS_KEY_ID`       — credentials (or use a profile).
+ *   - `AWS_SECRET_ACCESS_KEY`
+ *   - `SQS_ENDPOINT_URL`        — for local SQS (LocalStack / ElasticMQ).
+ */
+import { v4 as uuid } from "uuid";
+export class SQSAdapter {
+    provider = "sqs";
+    config;
+    // biome-ignore lint/suspicious/noExplicitAny: @aws-sdk/client-sqs client + command types are loose.
+    client = null;
+    // biome-ignore lint/suspicious/noExplicitAny: same as above.
+    commands = null;
+    runners = new Map();
+    connected = false;
+    stats = new Map();
+    constructor(config) {
+        this.config = {
+            region: config?.region ?? process.env.AWS_REGION ?? "us-east-1",
+            endpoint: config?.endpoint ?? process.env.SQS_ENDPOINT_URL,
+            waitTimeSeconds: config?.waitTimeSeconds ?? 20,
+            maxNumberOfMessages: config?.maxNumberOfMessages ?? 10,
+        };
+    }
+    async connect() {
+        if (this.connected)
+            return;
+        try {
+            // biome-ignore lint/suspicious/noExplicitAny: peer dep
+            const sdk = await import("@aws-sdk/client-sqs");
+            this.client = new sdk.SQSClient({ region: this.config.region, endpoint: this.config.endpoint });
+            this.commands = sdk;
+            this.connected = true;
+        }
+        catch (err) {
+            throw new Error(`[blok][sqs] connect failed: ${err.message}. Install @aws-sdk/client-sqs as a peer dependency: bun add @aws-sdk/client-sqs`);
+        }
+    }
+    async disconnect() {
+        if (!this.connected)
+            return;
+        for (const runner of this.runners.values())
+            runner.stop = true;
+        // Wait for in-flight loops to drain — up to 500ms each.
+        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 {
+            this.client?.destroy?.();
+        }
+        catch {
+            /* ignore */
+        }
+        this.client = null;
+        this.connected = false;
+    }
+    async process(config, handler) {
+        if (!this.connected)
+            throw new Error("[blok][sqs] not connected. Call connect() first.");
+        const runner = { stop: false, loops: 0 };
+        this.runners.set(config.queue, runner);
+        this.stats.set(config.queue, { completed: 0, failed: 0, active: 0 });
+        const stats = this.stats.get(config.queue);
+        const concurrency = Math.max(1, config.concurrency ?? 1);
+        for (let i = 0; i < concurrency; i += 1) {
+            void this.runConsumerLoop(config, handler, runner, stats);
+        }
+    }
+    async runConsumerLoop(config, handler, runner, stats) {
+        runner.loops += 1;
+        try {
+            while (!runner.stop) {
+                let response = {};
+                try {
+                    response = await this.client.send(new this.commands.ReceiveMessageCommand({
+                        QueueUrl: config.queue,
+                        MaxNumberOfMessages: Math.min(10, this.config.maxNumberOfMessages),
+                        WaitTimeSeconds: this.config.waitTimeSeconds,
+                        VisibilityTimeout: typeof config.timeout === "number" ? Math.ceil(config.timeout / 1000) : 30,
+                        AttributeNames: ["All"],
+                        MessageAttributeNames: ["All"],
+                    }));
+                }
+                catch (err) {
+                    // Transient — back off briefly then retry.
+                    await new Promise((r) => setTimeout(r, 1000));
+                    continue;
+                }
+                const messages = response.Messages ?? [];
+                for (const m of messages) {
+                    if (runner.stop)
+                        break;
+                    stats.active += 1;
+                    // Tracks whether the message has already been settled via
+                    // the WorkerJob API (`complete` / `fail`). Declared OUTSIDE
+                    // the try so the catch arm can read it and skip its own
+                    // nack/fail bookkeeping when the handler explicitly
+                    // settled. Without this flag we'd double-delete the
+                    // receipt handle AND a `fail()` call would be silently
+                    // overruled by the wrapper deleting the message anyway.
+                    // Caught by the real-broker integration test in
+                    // `__tests__/integration/sqs-adapter.real-sqs.test.ts`.
+                    let settled = false;
+                    try {
+                        const payloadString = m.Body ?? "";
+                        let data;
+                        try {
+                            data = payloadString.length > 0 ? JSON.parse(payloadString) : null;
+                        }
+                        catch {
+                            data = payloadString;
+                        }
+                        const headers = {};
+                        for (const [k, v] of Object.entries(m.MessageAttributes ?? {})) {
+                            if (typeof v.StringValue === "string")
+                                headers[k] = v.StringValue;
+                        }
+                        const job = {
+                            id: m.MessageId ?? `${config.queue}:${uuid()}`,
+                            data,
+                            headers,
+                            queue: config.queue,
+                            priority: config.priority ?? 0,
+                            attempts: Number.parseInt(m.Attributes?.ApproximateReceiveCount ?? "1", 10) - 1,
+                            maxRetries: config.retries ?? 0,
+                            createdAt: new Date(),
+                            timeout: config.timeout,
+                            raw: m,
+                            complete: async () => {
+                                if (settled)
+                                    return;
+                                if (m.ReceiptHandle) {
+                                    await this.client.send(new this.commands.DeleteMessageCommand({
+                                        QueueUrl: config.queue,
+                                        ReceiptHandle: m.ReceiptHandle,
+                                    }));
+                                }
+                                stats.completed += 1;
+                                settled = true;
+                            },
+                            fail: async (_err) => {
+                                if (settled)
+                                    return;
+                                stats.failed += 1;
+                                // No DeleteMessage call — visibility timeout
+                                // expires and SQS returns the message to the
+                                // queue automatically. DLQ takeover happens via
+                                // the queue's RedrivePolicy + MaxReceiveCount.
+                                settled = true;
+                            },
+                        };
+                        await handler(job);
+                        if (!settled && config.ack !== false && m.ReceiptHandle) {
+                            await this.client.send(new this.commands.DeleteMessageCommand({ QueueUrl: config.queue, ReceiptHandle: m.ReceiptHandle }));
+                            stats.completed += 1;
+                            settled = true;
+                        }
+                    }
+                    catch {
+                        if (!settled) {
+                            stats.failed += 1;
+                            // Leave the message in flight — SQS visibility
+                            // timeout expiry returns it to the queue.
+                        }
+                    }
+                    finally {
+                        stats.active = Math.max(0, stats.active - 1);
+                    }
+                }
+            }
+        }
+        finally {
+            runner.loops -= 1;
+        }
+    }
+    async addJob(queue, data, opts) {
+        if (!this.connected)
+            throw new Error("[blok][sqs] not connected. Call connect() first.");
+        const messageId = opts?.jobId ?? uuid();
+        const isFifo = queue.endsWith(".fifo");
+        const params = {
+            QueueUrl: queue,
+            MessageBody: typeof data === "string" ? data : JSON.stringify(data),
+        };
+        if (isFifo) {
+            params.MessageGroupId = opts?.jobId ?? "default";
+            params.MessageDeduplicationId = messageId;
+        }
+        if (typeof opts?.delay === "number" && opts.delay > 0) {
+            params.DelaySeconds = Math.min(900, Math.ceil(opts.delay / 1000));
+        }
+        const result = await this.client.send(new this.commands.SendMessageCommand(params));
+        return result.MessageId ?? messageId;
+    }
+    async stopProcessing(queue) {
+        const runner = this.runners.get(queue);
+        if (runner)
+            runner.stop = true;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    async healthCheck() {
+        if (!this.connected)
+            return false;
+        try {
+            // ListQueues is a cheap permission probe.
+            await this.client.send(new this.commands.ListQueuesCommand({ MaxResults: 1 }));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getQueueStats(queue) {
+        const counters = this.stats.get(queue) ?? { completed: 0, failed: 0, active: 0 };
+        let waiting = 0;
+        let delayed = 0;
+        try {
+            const result = await this.client.send(new this.commands.GetQueueAttributesCommand({
+                QueueUrl: queue,
+                AttributeNames: ["ApproximateNumberOfMessages", "ApproximateNumberOfMessagesDelayed"],
+            }));
+            waiting = Number.parseInt(result.Attributes?.ApproximateNumberOfMessages ?? "0", 10);
+            delayed = Number.parseInt(result.Attributes?.ApproximateNumberOfMessagesDelayed ?? "0", 10);
+        }
+        catch {
+            /* ignore */
+        }
+        return {
+            waiting,
+            active: counters.active,
+            completed: counters.completed,
+            failed: counters.failed,
+            delayed,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SQSAdapter.js","sourceRoot":"","sources":["../../src/adapters/SQSAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAGH,OAAO,EAAE,EAAE,IAAI,IAAI,EAAE,MAAM,MAAM,CAAC;AA6BlC,MAAM,OAAO,UAAU;IACb,QAAQ,GAAG,KAAc,CAAC;IAClB,MAAM,CAAY;IACnC,oGAAoG;IAC5F,MAAM,GAAQ,IAAI,CAAC;IAC3B,6DAA6D;IACrD,QAAQ,GAAQ,IAAI,CAAC;IACrB,OAAO,GAA6B,IAAI,GAAG,EAAE,CAAC;IAC9C,SAAS,GAAG,KAAK,CAAC;IAClB,KAAK,GAAoC,IAAI,GAAG,EAAE,CAAC;IAE3D,YAAY,MAA2B;QACtC,IAAI,CAAC,MAAM,GAAG;YACb,MAAM,EAAE,MAAM,EAAE,MAAM,IAAI,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,WAAW;YAC/D,QAAQ,EAAE,MAAM,EAAE,QAAQ,IAAI,OAAO,CAAC,GAAG,CAAC,gBAAgB;YAC1D,eAAe,EAAE,MAAM,EAAE,eAAe,IAAI,EAAE;YAC9C,mBAAmB,EAAE,MAAM,EAAE,mBAAmB,IAAI,EAAE;SACtD,CAAC;IACH,CAAC;IAED,KAAK,CAAC,OAAO;QACZ,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO;QAC3B,IAAI,CAAC;YACJ,uDAAuD;YACvD,MAAM,GAAG,GAAQ,MAAM,MAAM,CAAC,qBAAqB,CAAC,CAAC;YACrD,IAAI,CAAC,MAAM,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;YAChG,IAAI,CAAC,QAAQ,GAAG,GAAG,CAAC;YACpB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACvB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CACd,+BAAgC,GAAa,CAAC,OAAO,iFAAiF,CACtI,CAAC;QACH,CAAC;IACF,CAAC;IAED,KAAK,CAAC,UAAU;QACf,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,OAAO;QAC5B,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;YAAE,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC;QAC/D,wDAAwD;QACxD,MAAM,aAAa,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC;QACxC,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,aAAa,EAAE,CAAC;YACnC,IAAI,MAAM,GAAG,CAAC,CAAC;YACf,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;gBAAE,MAAM,IAAI,CAAC,CAAC,KAAK,CAAC;YACzD,IAAI,MAAM,KAAK,CAAC;gBAAE,MAAM;YACxB,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QAC7C,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QACrB,IAAI,CAAC;YACJ,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,CAAC;QAC1B,CAAC;QAAC,MAAM,CAAC;YACR,YAAY;QACb,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACxB,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,MAAyB,EAAE,OAA0C;QAClF,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;QACzF,MAAM,MAAM,GAAgB,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;QACtD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;QACvC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;QACrE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAuB,CAAC;QAEjE,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,WAAW,IAAI,CAAC,CAAC,CAAC;QACzD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YACzC,KAAK,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;QAC3D,CAAC;IACF,CAAC;IAEO,KAAK,CAAC,eAAe,CAC5B,MAAyB,EACzB,OAA0C,EAC1C,MAAmB,EACnB,KAAyB;QAEzB,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC;QAClB,IAAI,CAAC;YACJ,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;gBACrB,IAAI,QAAQ,GAAgC,EAAE,CAAC;gBAC/C,IAAI,CAAC;oBACJ,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAChC,IAAI,IAAI,CAAC,QAAQ,CAAC,qBAAqB,CAAC;wBACvC,QAAQ,EAAE,MAAM,CAAC,KAAK;wBACtB,mBAAmB,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC;wBAClE,eAAe,EAAE,IAAI,CAAC,MAAM,CAAC,eAAe;wBAC5C,iBAAiB,EAAE,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE;wBAC7F,cAAc,EAAE,CAAC,KAAK,CAAC;wBACvB,qBAAqB,EAAE,CAAC,KAAK,CAAC;qBAC9B,CAAC,CACF,CAAC;gBACH,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACd,2CAA2C;oBAC3C,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;oBAC9C,SAAS;gBACV,CAAC;gBACD,MAAM,QAAQ,GAAG,QAAQ,CAAC,QAAQ,IAAI,EAAE,CAAC;gBACzC,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;oBAC1B,IAAI,MAAM,CAAC,IAAI;wBAAE,MAAM;oBACvB,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;oBAClB,0DAA0D;oBAC1D,4DAA4D;oBAC5D,wDAAwD;oBACxD,oDAAoD;oBACpD,oDAAoD;oBACpD,uDAAuD;oBACvD,wDAAwD;oBACxD,gDAAgD;oBAChD,wDAAwD;oBACxD,IAAI,OAAO,GAAG,KAAK,CAAC;oBACpB,IAAI,CAAC;wBACJ,MAAM,aAAa,GAAG,CAAC,CAAC,IAAI,IAAI,EAAE,CAAC;wBACnC,IAAI,IAAa,CAAC;wBAClB,IAAI,CAAC;4BACJ,IAAI,GAAG,aAAa,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;wBACpE,CAAC;wBAAC,MAAM,CAAC;4BACR,IAAI,GAAG,aAAa,CAAC;wBACtB,CAAC;wBACD,MAAM,OAAO,GAA2B,EAAE,CAAC;wBAC3C,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,iBAAiB,IAAI,EAAE,CAAC,EAAE,CAAC;4BAChE,IAAI,OAAO,CAAC,CAAC,WAAW,KAAK,QAAQ;gCAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,WAAW,CAAC;wBACnE,CAAC;wBACD,MAAM,GAAG,GAAc;4BACtB,EAAE,EAAE,CAAC,CAAC,SAAS,IAAI,GAAG,MAAM,CAAC,KAAK,IAAI,IAAI,EAAE,EAAE;4BAC9C,IAAI;4BACJ,OAAO;4BACP,KAAK,EAAE,MAAM,CAAC,KAAK;4BACnB,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,CAAC;4BAC9B,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,UAAU,EAAE,uBAAuB,IAAI,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC;4BAC/E,UAAU,EAAE,MAAM,CAAC,OAAO,IAAI,CAAC;4BAC/B,SAAS,EAAE,IAAI,IAAI,EAAE;4BACrB,OAAO,EAAE,MAAM,CAAC,OAAO;4BACvB,GAAG,EAAE,CAAC;4BACN,QAAQ,EAAE,KAAK,IAAI,EAAE;gCACpB,IAAI,OAAO;oCAAE,OAAO;gCACpB,IAAI,CAAC,CAAC,aAAa,EAAE,CAAC;oCACrB,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CACrB,IAAI,IAAI,CAAC,QAAQ,CAAC,oBAAoB,CAAC;wCACtC,QAAQ,EAAE,MAAM,CAAC,KAAK;wCACtB,aAAa,EAAE,CAAC,CAAC,aAAa;qCAC9B,CAAC,CACF,CAAC;gCACH,CAAC;gCACD,KAAK,CAAC,SAAS,IAAI,CAAC,CAAC;gCACrB,OAAO,GAAG,IAAI,CAAC;4BAChB,CAAC;4BACD,IAAI,EAAE,KAAK,EAAE,IAAW,EAAE,EAAE;gCAC3B,IAAI,OAAO;oCAAE,OAAO;gCACpB,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;gCAClB,6CAA6C;gCAC7C,6CAA6C;gCAC7C,gDAAgD;gCAChD,+CAA+C;gCAC/C,OAAO,GAAG,IAAI,CAAC;4BAChB,CAAC;yBACD,CAAC;wBACF,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC;wBACnB,IAAI,CAAC,OAAO,IAAI,MAAM,CAAC,GAAG,KAAK,KAAK,IAAI,CAAC,CAAC,aAAa,EAAE,CAAC;4BACzD,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CACrB,IAAI,IAAI,CAAC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,KAAK,EAAE,aAAa,EAAE,CAAC,CAAC,aAAa,EAAE,CAAC,CAClG,CAAC;4BACF,KAAK,CAAC,SAAS,IAAI,CAAC,CAAC;4BACrB,OAAO,GAAG,IAAI,CAAC;wBAChB,CAAC;oBACF,CAAC;oBAAC,MAAM,CAAC;wBACR,IAAI,CAAC,OAAO,EAAE,CAAC;4BACd,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;4BAClB,+CAA+C;4BAC/C,0CAA0C;wBAC3C,CAAC;oBACF,CAAC;4BAAS,CAAC;wBACV,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;oBAC9C,CAAC;gBACF,CAAC;YACF,CAAC;QACF,CAAC;gBAAS,CAAC;YACV,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC;QACnB,CAAC;IACF,CAAC;IAED,KAAK,CAAC,MAAM,CACX,KAAa,EACb,IAAa,EACb,IAAgG;QAEhG,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;QACzF,MAAM,SAAS,GAAG,IAAI,EAAE,KAAK,IAAI,IAAI,EAAE,CAAC;QACxC,MAAM,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACvC,MAAM,MAAM,GAA4B;YACvC,QAAQ,EAAE,KAAK;YACf,WAAW,EAAE,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;SACnE,CAAC;QACF,IAAI,MAAM,EAAE,CAAC;YACZ,MAAM,CAAC,cAAc,GAAG,IAAI,EAAE,KAAK,IAAI,SAAS,CAAC;YACjD,MAAM,CAAC,sBAAsB,GAAG,SAAS,CAAC;QAC3C,CAAC;QACD,IAAI,OAAO,IAAI,EAAE,KAAK,KAAK,QAAQ,IAAI,IAAI,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC;YACvD,MAAM,CAAC,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC;QACnE,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC;QACpF,OAAQ,MAAM,CAAC,SAAoB,IAAI,SAAS,CAAC;IAClD,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,KAAa;QACjC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACvC,IAAI,MAAM;YAAE,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC;IAChC,CAAC;IAED,WAAW;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,WAAW;QAChB,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,OAAO,KAAK,CAAC;QAClC,IAAI,CAAC;YACJ,0CAA0C;YAC1C,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;YAC/E,OAAO,IAAI,CAAC;QACb,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,KAAK,CAAC;QACd,CAAC;IACF,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,KAAa;QAChC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;QACjF,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,IAAI,CAAC;YACJ,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CACpC,IAAI,IAAI,CAAC,QAAQ,CAAC,yBAAyB,CAAC;gBAC3C,QAAQ,EAAE,KAAK;gBACf,cAAc,EAAE,CAAC,6BAA6B,EAAE,oCAAoC,CAAC;aACrF,CAAC,CACF,CAAC;YACF,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,2BAA2B,IAAI,GAAG,EAAE,EAAE,CAAC,CAAC;YACrF,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,kCAAkC,IAAI,GAAG,EAAE,EAAE,CAAC,CAAC;QAC7F,CAAC;QAAC,MAAM,CAAC;YACR,YAAY;QACb,CAAC;QACD,OAAO;YACN,OAAO;YACP,MAAM,EAAE,QAAQ,CAAC,MAAM;YACvB,SAAS,EAAE,QAAQ,CAAC,SAAS;YAC7B,MAAM,EAAE,QAAQ,CAAC,MAAM;YACvB,OAAO;SACP,CAAC;IACH,CAAC;CACD","sourcesContent":["/**\n * SQSAdapter — v0.7 PR 5 — Worker adapter backed by AWS SQS via\n * `@aws-sdk/client-sqs`. Polls a queue URL (the `queue` field) with\n * long-polling; processes messages with manual delete (ACK).\n *\n * Semantics:\n *   - **Long polling**: `WaitTimeSeconds=20` by default — minimises\n *     poll cost. `concurrency` controls how many parallel\n *     `ReceiveMessage` loops run.\n *   - **Visibility timeout**: configured via `timeout` (ms → s).\n *     Messages reappear after this if the worker doesn't delete them.\n *   - **Retries**: SQS handles retries automatically via redrive\n *     policy on the queue itself. The adapter doesn't simulate\n *     retries client-side — set `MaxReceiveCount` on the queue's\n *     redrive policy and a DLQ via `deadLetterQueue`.\n *   - **FIFO support**: when the queue URL ends with `.fifo`, the\n *     adapter passes `MessageGroupId` from `dedupId` or a default.\n *\n * Requires `@aws-sdk/client-sqs` as a peer dependency:\n *\n *     bun add @aws-sdk/client-sqs\n *\n * Environment variables (standard AWS SDK):\n *   - `AWS_REGION`              — default `us-east-1`.\n *   - `AWS_ACCESS_KEY_ID`       — credentials (or use a profile).\n *   - `AWS_SECRET_ACCESS_KEY`\n *   - `SQS_ENDPOINT_URL`        — for local SQS (LocalStack / ElasticMQ).\n */\n\nimport type { WorkerTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { WorkerAdapter, WorkerJob, WorkerQueueStats } from \"../WorkerTrigger\";\n\nexport interface SQSConfig {\n\tregion: string;\n\tendpoint?: string;\n\twaitTimeSeconds: number;\n\tmaxNumberOfMessages: number;\n}\n\ninterface SqsMessage {\n\tMessageId?: string;\n\tReceiptHandle?: string;\n\tBody?: string;\n\tAttributes?: Record<string, string>;\n\tMessageAttributes?: Record<string, { StringValue?: 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 SQSAdapter implements WorkerAdapter {\n\treadonly provider = \"sqs\" as const;\n\tprivate readonly config: SQSConfig;\n\t// biome-ignore lint/suspicious/noExplicitAny: @aws-sdk/client-sqs client + command types are loose.\n\tprivate client: any = null;\n\t// biome-ignore lint/suspicious/noExplicitAny: same as above.\n\tprivate commands: any = null;\n\tprivate runners: Map<string, QueueRunner> = new Map();\n\tprivate connected = false;\n\tprivate stats: Map<string, QueueStatsCounters> = new Map();\n\n\tconstructor(config?: Partial<SQSConfig>) {\n\t\tthis.config = {\n\t\t\tregion: config?.region ?? process.env.AWS_REGION ?? \"us-east-1\",\n\t\t\tendpoint: config?.endpoint ?? process.env.SQS_ENDPOINT_URL,\n\t\t\twaitTimeSeconds: config?.waitTimeSeconds ?? 20,\n\t\t\tmaxNumberOfMessages: config?.maxNumberOfMessages ?? 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: peer dep\n\t\t\tconst sdk: any = await import(\"@aws-sdk/client-sqs\");\n\t\t\tthis.client = new sdk.SQSClient({ region: this.config.region, endpoint: this.config.endpoint });\n\t\t\tthis.commands = sdk;\n\t\t\tthis.connected = true;\n\t\t} catch (err) {\n\t\t\tthrow new Error(\n\t\t\t\t`[blok][sqs] connect failed: ${(err as Error).message}. Install @aws-sdk/client-sqs as a peer dependency: bun add @aws-sdk/client-sqs`,\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 — up to 500ms each.\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\tthis.client?.destroy?.();\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) throw new Error(\"[blok][sqs] not connected. Call connect() first.\");\n\t\tconst runner: QueueRunner = { stop: false, loops: 0 };\n\t\tthis.runners.set(config.queue, runner);\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\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(config, handler, runner, stats);\n\t\t}\n\t}\n\n\tprivate async runConsumerLoop(\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\trunner.loops += 1;\n\t\ttry {\n\t\t\twhile (!runner.stop) {\n\t\t\t\tlet response: { Messages?: SqsMessage[] } = {};\n\t\t\t\ttry {\n\t\t\t\t\tresponse = await this.client.send(\n\t\t\t\t\t\tnew this.commands.ReceiveMessageCommand({\n\t\t\t\t\t\t\tQueueUrl: config.queue,\n\t\t\t\t\t\t\tMaxNumberOfMessages: Math.min(10, this.config.maxNumberOfMessages),\n\t\t\t\t\t\t\tWaitTimeSeconds: this.config.waitTimeSeconds,\n\t\t\t\t\t\t\tVisibilityTimeout: typeof config.timeout === \"number\" ? Math.ceil(config.timeout / 1000) : 30,\n\t\t\t\t\t\t\tAttributeNames: [\"All\"],\n\t\t\t\t\t\t\tMessageAttributeNames: [\"All\"],\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\t// Transient — back off briefly then retry.\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\tconst messages = response.Messages ?? [];\n\t\t\t\tfor (const m of messages) {\n\t\t\t\t\tif (runner.stop) break;\n\t\t\t\t\tstats.active += 1;\n\t\t\t\t\t// Tracks whether the message has already been settled via\n\t\t\t\t\t// the WorkerJob API (`complete` / `fail`). Declared OUTSIDE\n\t\t\t\t\t// the try so the catch arm can read it and skip its own\n\t\t\t\t\t// nack/fail bookkeeping when the handler explicitly\n\t\t\t\t\t// settled. Without this flag we'd double-delete the\n\t\t\t\t\t// receipt handle AND a `fail()` call would be silently\n\t\t\t\t\t// overruled by the wrapper deleting the message anyway.\n\t\t\t\t\t// Caught by the real-broker integration test in\n\t\t\t\t\t// `__tests__/integration/sqs-adapter.real-sqs.test.ts`.\n\t\t\t\t\tlet settled = false;\n\t\t\t\t\ttry {\n\t\t\t\t\t\tconst payloadString = m.Body ?? \"\";\n\t\t\t\t\t\tlet data: unknown;\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tdata = payloadString.length > 0 ? JSON.parse(payloadString) : null;\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\tdata = payloadString;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tconst headers: Record<string, string> = {};\n\t\t\t\t\t\tfor (const [k, v] of Object.entries(m.MessageAttributes ?? {})) {\n\t\t\t\t\t\t\tif (typeof v.StringValue === \"string\") headers[k] = v.StringValue;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tconst job: WorkerJob = {\n\t\t\t\t\t\t\tid: m.MessageId ?? `${config.queue}:${uuid()}`,\n\t\t\t\t\t\t\tdata,\n\t\t\t\t\t\t\theaders,\n\t\t\t\t\t\t\tqueue: config.queue,\n\t\t\t\t\t\t\tpriority: config.priority ?? 0,\n\t\t\t\t\t\t\tattempts: Number.parseInt(m.Attributes?.ApproximateReceiveCount ?? \"1\", 10) - 1,\n\t\t\t\t\t\t\tmaxRetries: config.retries ?? 0,\n\t\t\t\t\t\t\tcreatedAt: new Date(),\n\t\t\t\t\t\t\ttimeout: config.timeout,\n\t\t\t\t\t\t\traw: m,\n\t\t\t\t\t\t\tcomplete: async () => {\n\t\t\t\t\t\t\t\tif (settled) return;\n\t\t\t\t\t\t\t\tif (m.ReceiptHandle) {\n\t\t\t\t\t\t\t\t\tawait this.client.send(\n\t\t\t\t\t\t\t\t\t\tnew this.commands.DeleteMessageCommand({\n\t\t\t\t\t\t\t\t\t\t\tQueueUrl: config.queue,\n\t\t\t\t\t\t\t\t\t\t\tReceiptHandle: m.ReceiptHandle,\n\t\t\t\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tstats.completed += 1;\n\t\t\t\t\t\t\t\tsettled = true;\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\tfail: async (_err: Error) => {\n\t\t\t\t\t\t\t\tif (settled) return;\n\t\t\t\t\t\t\t\tstats.failed += 1;\n\t\t\t\t\t\t\t\t// No DeleteMessage call — visibility timeout\n\t\t\t\t\t\t\t\t// expires and SQS returns the message to the\n\t\t\t\t\t\t\t\t// queue automatically. DLQ takeover happens via\n\t\t\t\t\t\t\t\t// the queue's RedrivePolicy + MaxReceiveCount.\n\t\t\t\t\t\t\t\tsettled = true;\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t};\n\t\t\t\t\t\tawait handler(job);\n\t\t\t\t\t\tif (!settled && config.ack !== false && m.ReceiptHandle) {\n\t\t\t\t\t\t\tawait this.client.send(\n\t\t\t\t\t\t\t\tnew this.commands.DeleteMessageCommand({ QueueUrl: config.queue, ReceiptHandle: m.ReceiptHandle }),\n\t\t\t\t\t\t\t);\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\t// Leave the message in flight — SQS visibility\n\t\t\t\t\t\t\t// timeout expiry returns it to the queue.\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} finally {\n\t\t\trunner.loops -= 1;\n\t\t}\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) throw new Error(\"[blok][sqs] not connected. Call connect() first.\");\n\t\tconst messageId = opts?.jobId ?? uuid();\n\t\tconst isFifo = queue.endsWith(\".fifo\");\n\t\tconst params: Record<string, unknown> = {\n\t\t\tQueueUrl: queue,\n\t\t\tMessageBody: typeof data === \"string\" ? data : JSON.stringify(data),\n\t\t};\n\t\tif (isFifo) {\n\t\t\tparams.MessageGroupId = opts?.jobId ?? \"default\";\n\t\t\tparams.MessageDeduplicationId = messageId;\n\t\t}\n\t\tif (typeof opts?.delay === \"number\" && opts.delay > 0) {\n\t\t\tparams.DelaySeconds = Math.min(900, Math.ceil(opts.delay / 1000));\n\t\t}\n\t\tconst result = await this.client.send(new this.commands.SendMessageCommand(params));\n\t\treturn (result.MessageId as string) ?? messageId;\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) return false;\n\t\ttry {\n\t\t\t// ListQueues is a cheap permission probe.\n\t\t\tawait this.client.send(new this.commands.ListQueuesCommand({ MaxResults: 1 }));\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\tlet delayed = 0;\n\t\ttry {\n\t\t\tconst result = await this.client.send(\n\t\t\t\tnew this.commands.GetQueueAttributesCommand({\n\t\t\t\t\tQueueUrl: queue,\n\t\t\t\t\tAttributeNames: [\"ApproximateNumberOfMessages\", \"ApproximateNumberOfMessagesDelayed\"],\n\t\t\t\t}),\n\t\t\t);\n\t\t\twaiting = Number.parseInt(result.Attributes?.ApproximateNumberOfMessages ?? \"0\", 10);\n\t\t\tdelayed = Number.parseInt(result.Attributes?.ApproximateNumberOfMessagesDelayed ?? \"0\", 10);\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,\n\t\t};\n\t}\n}\n"]}

package/dist/adapters/factory.d.ts

@@ -0,0 +1,34 @@
+/**
+ * v0.7 PR 5 — adapter factory.
+ *
+ * Resolves a `provider` string to a concrete `WorkerAdapter` instance.
+ * Used by the `WorkerTrigger` (to pick the right adapter per workflow
+ * based on `trigger.worker.provider`) and by the `@blokjs/worker-publish`
+ * helper node (to enqueue jobs from any workflow without bundling all
+ * broker clients).
+ *
+ * Provider resolution order:
+ *   1. Explicit `provider` field on the workflow (highest priority).
+ *   2. `BLOK_WORKER_ADAPTER` env var (per Q7 resolution in the plan).
+ *   3. `"in-memory"` fallback (zero-infra default for dev/tests).
+ *
+ * Each adapter beyond `in-memory` lazy-imports its broker SDK on first
+ * use (BullMQ does this today). Workflows that don't use a given
+ * provider don't pay the install or import cost.
+ */
+import type { WorkerProvider } from "@blokjs/helper";
+import type { WorkerAdapter } from "../WorkerTrigger";
+/**
+ * Resolve the effective provider for a workflow. The trigger's
+ * `provider` field always wins; otherwise fall back to the
+ * `BLOK_WORKER_ADAPTER` env var; otherwise `"in-memory"`.
+ */
+export declare function resolveProvider(provider?: WorkerProvider): WorkerProvider;
+/**
+ * Construct an adapter for the named provider. Throws a clear error
+ * for unknown names — keeps the schema validation and runtime
+ * behaviour in sync (the Zod enum catches typos at workflow load).
+ */
+export declare function createWorkerAdapter(provider: WorkerProvider): WorkerAdapter;
+export declare function getOrCreateAdapter(provider: WorkerProvider): WorkerAdapter;
+export declare function _resetAdapterPoolForTests(): void;

package/dist/adapters/factory.js

@@ -0,0 +1,103 @@
+/**
+ * v0.7 PR 5 — adapter factory.
+ *
+ * Resolves a `provider` string to a concrete `WorkerAdapter` instance.
+ * Used by the `WorkerTrigger` (to pick the right adapter per workflow
+ * based on `trigger.worker.provider`) and by the `@blokjs/worker-publish`
+ * helper node (to enqueue jobs from any workflow without bundling all
+ * broker clients).
+ *
+ * Provider resolution order:
+ *   1. Explicit `provider` field on the workflow (highest priority).
+ *   2. `BLOK_WORKER_ADAPTER` env var (per Q7 resolution in the plan).
+ *   3. `"in-memory"` fallback (zero-infra default for dev/tests).
+ *
+ * Each adapter beyond `in-memory` lazy-imports its broker SDK on first
+ * use (BullMQ does this today). Workflows that don't use a given
+ * provider don't pay the install or import cost.
+ */
+import { BullMQAdapter } from "./BullMQAdapter";
+import { InMemoryAdapter } from "./InMemoryAdapter";
+import { KafkaAdapter } from "./KafkaAdapter";
+import { NATSWorkerAdapter } from "./NATSAdapter";
+import { PgBossAdapter } from "./PgBossAdapter";
+import { RabbitMQAdapter } from "./RabbitMQAdapter";
+import { RedisStreamsAdapter } from "./RedisStreamsAdapter";
+import { SQSAdapter } from "./SQSAdapter";
+/**
+ * Resolve the effective provider for a workflow. The trigger's
+ * `provider` field always wins; otherwise fall back to the
+ * `BLOK_WORKER_ADAPTER` env var; otherwise `"in-memory"`.
+ */
+export function resolveProvider(provider) {
+    if (provider)
+        return provider;
+    const envValue = process.env.BLOK_WORKER_ADAPTER;
+    if (envValue && isWorkerProvider(envValue))
+        return envValue;
+    return "in-memory";
+}
+function isWorkerProvider(value) {
+    return (value === "in-memory" ||
+        value === "nats" ||
+        value === "bullmq" ||
+        value === "kafka" ||
+        value === "rabbitmq" ||
+        value === "sqs" ||
+        value === "redis" ||
+        value === "pg-boss");
+}
+/**
+ * Construct an adapter for the named provider. Throws a clear error
+ * for unknown names — keeps the schema validation and runtime
+ * behaviour in sync (the Zod enum catches typos at workflow load).
+ */
+export function createWorkerAdapter(provider) {
+    switch (provider) {
+        case "in-memory":
+            return new InMemoryAdapter();
+        case "nats":
+            return new NATSWorkerAdapter();
+        case "bullmq":
+            return new BullMQAdapter();
+        case "kafka":
+            return new KafkaAdapter();
+        case "rabbitmq":
+            return new RabbitMQAdapter();
+        case "sqs":
+            return new SQSAdapter();
+        case "redis":
+            return new RedisStreamsAdapter();
+        case "pg-boss":
+            return new PgBossAdapter();
+        default: {
+            const exhaustive = provider;
+            throw new Error(`[blok][worker] unknown provider "${exhaustive}". Check WorkerProviderSchema.`);
+        }
+    }
+}
+/**
+ * Process-singleton adapter pool — one instance per provider. The
+ * trigger calls `getOrCreateAdapter("kafka")` once per workflow, and
+ * subsequent workflows on the same provider share the broker
+ * connection. Adapters are connected lazily — `getOrCreateAdapter`
+ * never connects on its own; the caller calls `adapter.connect()`.
+ *
+ * Reset via `_resetAdapterPoolForTests()` between vitest suites.
+ */
+const pool = new Map();
+export function getOrCreateAdapter(provider) {
+    let adapter = pool.get(provider);
+    if (!adapter) {
+        adapter = createWorkerAdapter(provider);
+        pool.set(provider, adapter);
+    }
+    return adapter;
+}
+export function _resetAdapterPoolForTests() {
+    for (const adapter of pool.values()) {
+        void adapter.disconnect?.().catch(() => { });
+    }
+    pool.clear();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"factory.js","sourceRoot":"","sources":["../../src/adapters/factory.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAIH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,QAAyB;IACxD,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAC9B,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC;IACjD,IAAI,QAAQ,IAAI,gBAAgB,CAAC,QAAQ,CAAC;QAAE,OAAO,QAAQ,CAAC;IAC5D,OAAO,WAAW,CAAC;AACpB,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAa;IACtC,OAAO,CACN,KAAK,KAAK,WAAW;QACrB,KAAK,KAAK,MAAM;QAChB,KAAK,KAAK,QAAQ;QAClB,KAAK,KAAK,OAAO;QACjB,KAAK,KAAK,UAAU;QACpB,KAAK,KAAK,KAAK;QACf,KAAK,KAAK,OAAO;QACjB,KAAK,KAAK,SAAS,CACnB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,QAAwB;IAC3D,QAAQ,QAAQ,EAAE,CAAC;QAClB,KAAK,WAAW;YACf,OAAO,IAAI,eAAe,EAAE,CAAC;QAC9B,KAAK,MAAM;YACV,OAAO,IAAI,iBAAiB,EAAE,CAAC;QAChC,KAAK,QAAQ;YACZ,OAAO,IAAI,aAAa,EAAE,CAAC;QAC5B,KAAK,OAAO;YACX,OAAO,IAAI,YAAY,EAAE,CAAC;QAC3B,KAAK,UAAU;YACd,OAAO,IAAI,eAAe,EAAE,CAAC;QAC9B,KAAK,KAAK;YACT,OAAO,IAAI,UAAU,EAAE,CAAC;QACzB,KAAK,OAAO;YACX,OAAO,IAAI,mBAAmB,EAAE,CAAC;QAClC,KAAK,SAAS;YACb,OAAO,IAAI,aAAa,EAAE,CAAC;QAC5B,OAAO,CAAC,CAAC,CAAC;YACT,MAAM,UAAU,GAAU,QAAQ,CAAC;YACnC,MAAM,IAAI,KAAK,CAAC,oCAAoC,UAAoB,gCAAgC,CAAC,CAAC;QAC3G,CAAC;IACF,CAAC;AACF,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,IAAI,GAAuC,IAAI,GAAG,EAAE,CAAC;AAE3D,MAAM,UAAU,kBAAkB,CAAC,QAAwB;IAC1D,IAAI,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACjC,IAAI,CAAC,OAAO,EAAE,CAAC;QACd,OAAO,GAAG,mBAAmB,CAAC,QAAQ,CAAC,CAAC;QACxC,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC7B,CAAC;IACD,OAAO,OAAO,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,yBAAyB;IACxC,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;QACrC,KAAK,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;IAC7C,CAAC;IACD,IAAI,CAAC,KAAK,EAAE,CAAC;AACd,CAAC","sourcesContent":["/**\n * v0.7 PR 5 — adapter factory.\n *\n * Resolves a `provider` string to a concrete `WorkerAdapter` instance.\n * Used by the `WorkerTrigger` (to pick the right adapter per workflow\n * based on `trigger.worker.provider`) and by the `@blokjs/worker-publish`\n * helper node (to enqueue jobs from any workflow without bundling all\n * broker clients).\n *\n * Provider resolution order:\n *   1. Explicit `provider` field on the workflow (highest priority).\n *   2. `BLOK_WORKER_ADAPTER` env var (per Q7 resolution in the plan).\n *   3. `\"in-memory\"` fallback (zero-infra default for dev/tests).\n *\n * Each adapter beyond `in-memory` lazy-imports its broker SDK on first\n * use (BullMQ does this today). Workflows that don't use a given\n * provider don't pay the install or import cost.\n */\n\nimport type { WorkerProvider } from \"@blokjs/helper\";\nimport type { WorkerAdapter } from \"../WorkerTrigger\";\nimport { BullMQAdapter } from \"./BullMQAdapter\";\nimport { InMemoryAdapter } from \"./InMemoryAdapter\";\nimport { KafkaAdapter } from \"./KafkaAdapter\";\nimport { NATSWorkerAdapter } from \"./NATSAdapter\";\nimport { PgBossAdapter } from \"./PgBossAdapter\";\nimport { RabbitMQAdapter } from \"./RabbitMQAdapter\";\nimport { RedisStreamsAdapter } from \"./RedisStreamsAdapter\";\nimport { SQSAdapter } from \"./SQSAdapter\";\n\n/**\n * Resolve the effective provider for a workflow. The trigger's\n * `provider` field always wins; otherwise fall back to the\n * `BLOK_WORKER_ADAPTER` env var; otherwise `\"in-memory\"`.\n */\nexport function resolveProvider(provider?: WorkerProvider): WorkerProvider {\n\tif (provider) return provider;\n\tconst envValue = process.env.BLOK_WORKER_ADAPTER;\n\tif (envValue && isWorkerProvider(envValue)) return envValue;\n\treturn \"in-memory\";\n}\n\nfunction isWorkerProvider(value: string): value is WorkerProvider {\n\treturn (\n\t\tvalue === \"in-memory\" ||\n\t\tvalue === \"nats\" ||\n\t\tvalue === \"bullmq\" ||\n\t\tvalue === \"kafka\" ||\n\t\tvalue === \"rabbitmq\" ||\n\t\tvalue === \"sqs\" ||\n\t\tvalue === \"redis\" ||\n\t\tvalue === \"pg-boss\"\n\t);\n}\n\n/**\n * Construct an adapter for the named provider. Throws a clear error\n * for unknown names — keeps the schema validation and runtime\n * behaviour in sync (the Zod enum catches typos at workflow load).\n */\nexport function createWorkerAdapter(provider: WorkerProvider): WorkerAdapter {\n\tswitch (provider) {\n\t\tcase \"in-memory\":\n\t\t\treturn new InMemoryAdapter();\n\t\tcase \"nats\":\n\t\t\treturn new NATSWorkerAdapter();\n\t\tcase \"bullmq\":\n\t\t\treturn new BullMQAdapter();\n\t\tcase \"kafka\":\n\t\t\treturn new KafkaAdapter();\n\t\tcase \"rabbitmq\":\n\t\t\treturn new RabbitMQAdapter();\n\t\tcase \"sqs\":\n\t\t\treturn new SQSAdapter();\n\t\tcase \"redis\":\n\t\t\treturn new RedisStreamsAdapter();\n\t\tcase \"pg-boss\":\n\t\t\treturn new PgBossAdapter();\n\t\tdefault: {\n\t\t\tconst exhaustive: never = provider;\n\t\t\tthrow new Error(`[blok][worker] unknown provider \"${exhaustive as string}\". Check WorkerProviderSchema.`);\n\t\t}\n\t}\n}\n\n/**\n * Process-singleton adapter pool — one instance per provider. The\n * trigger calls `getOrCreateAdapter(\"kafka\")` once per workflow, and\n * subsequent workflows on the same provider share the broker\n * connection. Adapters are connected lazily — `getOrCreateAdapter`\n * never connects on its own; the caller calls `adapter.connect()`.\n *\n * Reset via `_resetAdapterPoolForTests()` between vitest suites.\n */\nconst pool: Map<WorkerProvider, WorkerAdapter> = new Map();\n\nexport function getOrCreateAdapter(provider: WorkerProvider): WorkerAdapter {\n\tlet adapter = pool.get(provider);\n\tif (!adapter) {\n\t\tadapter = createWorkerAdapter(provider);\n\t\tpool.set(provider, adapter);\n\t}\n\treturn adapter;\n}\n\nexport function _resetAdapterPoolForTests(): void {\n\tfor (const adapter of pool.values()) {\n\t\tvoid adapter.disconnect?.().catch(() => {});\n\t}\n\tpool.clear();\n}\n"]}

package/dist/index.d.ts

@@ -10,9 +10,20 @@
  * - Delayed job scheduling
  * - Queue statistics and monitoring
  *
- * Adapters:
- * - BullMQ (Redis-backed, production)
- * - InMemory (development/testing)
+ * Adapters (v0.7+):
+ * - BullMQ        — Redis-backed, ops-style queues (`bullmq` peer dep)
+ * - InMemory      — development / tests (no peer deps)
+ * - NATS          — JetStream durable streams (`nats` peer dep)
+ * - Kafka         — high-throughput streaming (`kafkajs` peer dep)
+ * - RabbitMQ      — reliable enterprise queues (`amqplib` peer dep)
+ * - SQS           — AWS cloud queues (`@aws-sdk/client-sqs` peer dep)
+ * - Redis Streams — when Redis is already in stack (`ioredis` peer dep)
+ * - pg-boss       — no extra infra (`pg-boss` peer dep)
+ *
+ * v0.7+ — pick the adapter per workflow via `trigger.worker.provider`.
+ * `BLOK_WORKER_ADAPTER` env var sets the default. Subclasses can still
+ * set `protected adapter` directly for back-compat with the pre-v0.7
+ * single-adapter pattern.
  *
  * @example BullMQ
  * ```typescript
@@ -53,5 +64,11 @@
 export { WorkerTrigger, type WorkerAdapter, type WorkerJob, type WorkerQueueStats, } from "./WorkerTrigger";
 export { BullMQAdapter, type BullMQConfig } from "./adapters/BullMQAdapter";
 export { InMemoryAdapter } from "./adapters/InMemoryAdapter";
+export { KafkaAdapter, type KafkaConfig } from "./adapters/KafkaAdapter";
 export { NATSWorkerAdapter, type NATSWorkerConfig } from "./adapters/NATSAdapter";
-export type { WorkerTriggerOpts } from "@blokjs/helper";
+export { PgBossAdapter, type PgBossConfig } from "./adapters/PgBossAdapter";
+export { RabbitMQAdapter, type RabbitMQConfig } from "./adapters/RabbitMQAdapter";
+export { RedisStreamsAdapter, type RedisStreamsConfig } from "./adapters/RedisStreamsAdapter";
+export { SQSAdapter, type SQSConfig } from "./adapters/SQSAdapter";
+export { _resetAdapterPoolForTests, createWorkerAdapter, getOrCreateAdapter, resolveProvider, } from "./adapters/factory";
+export type { WorkerProvider, WorkerTriggerOpts } from "@blokjs/helper";

package/dist/index.js

@@ -10,9 +10,20 @@
  * - Delayed job scheduling
  * - Queue statistics and monitoring
  *
- * Adapters:
- * - BullMQ (Redis-backed, production)
- * - InMemory (development/testing)
+ * Adapters (v0.7+):
+ * - BullMQ        — Redis-backed, ops-style queues (`bullmq` peer dep)
+ * - InMemory      — development / tests (no peer deps)
+ * - NATS          — JetStream durable streams (`nats` peer dep)
+ * - Kafka         — high-throughput streaming (`kafkajs` peer dep)
+ * - RabbitMQ      — reliable enterprise queues (`amqplib` peer dep)
+ * - SQS           — AWS cloud queues (`@aws-sdk/client-sqs` peer dep)
+ * - Redis Streams — when Redis is already in stack (`ioredis` peer dep)
+ * - pg-boss       — no extra infra (`pg-boss` peer dep)
+ *
+ * v0.7+ — pick the adapter per workflow via `trigger.worker.provider`.
+ * `BLOK_WORKER_ADAPTER` env var sets the default. Subclasses can still
+ * set `protected adapter` directly for back-compat with the pre-v0.7
+ * single-adapter pattern.
  *
  * @example BullMQ
  * ```typescript
@@ -55,5 +66,14 @@ export { WorkerTrigger, } from "./WorkerTrigger";
 // Adapters
 export { BullMQAdapter } from "./adapters/BullMQAdapter";
 export { InMemoryAdapter } from "./adapters/InMemoryAdapter";
+export { KafkaAdapter } from "./adapters/KafkaAdapter";
 export { NATSWorkerAdapter } from "./adapters/NATSAdapter";
-//# sourceMappingURL=data:application/json;base64,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
+export { PgBossAdapter } from "./adapters/PgBossAdapter";
+export { RabbitMQAdapter } from "./adapters/RabbitMQAdapter";
+export { RedisStreamsAdapter } from "./adapters/RedisStreamsAdapter";
+export { SQSAdapter } from "./adapters/SQSAdapter";
+// v0.7 PR 5 — factory + pool. Used by WorkerTrigger and exposed for
+// helper nodes (`@blokjs/worker-publish`) that need to enqueue jobs
+// from any workflow without bundling all broker SDKs.
+export { _resetAdapterPoolForTests, createWorkerAdapter, getOrCreateAdapter, resolveProvider, } from "./adapters/factory";
+//# sourceMappingURL=data:application/json;base64,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