@blokjs/trigger-worker 0.2.1 → 0.6.1

package/dist/adapters/KafkaAdapter.js

@@ -0,0 +1,236 @@
+/**
+ * KafkaAdapter — v0.7 PR 5 — Worker adapter backed by Apache Kafka via
+ * `kafkajs`. Consumes from a topic (the `queue` field) with a
+ * consumer-group identifier; produces via the same client.
+ *
+ * Kafka is fundamentally a streaming platform — not a queue — so a
+ * few semantics differ from BullMQ/SQS/RabbitMQ:
+ *
+ *   - **Ordering**: per-partition, not per-topic. Set the partition
+ *     key via the `dedupId` field on `addJob` to keep related
+ *     messages on the same partition.
+ *   - **Retries**: Kafka doesn't have a broker-side retry concept.
+ *     The adapter re-throws on handler failure; offset commit is
+ *     suppressed so the consumer re-polls the message on the next
+ *     cycle. For real retry semantics, layer a dead-letter topic.
+ *   - **Stats**: KafkaJS exposes consumer-group lag via its admin
+ *     client; the lag count is reported as `waiting`. Other stats
+ *     are tracked locally per consumer.
+ *
+ * Requires `kafkajs` as a peer dependency:
+ *
+ *     bun add kafkajs
+ *
+ * Environment variables (read at adapter construction):
+ *   - `KAFKA_BROKERS`           — comma-separated list (default `localhost:9092`).
+ *   - `KAFKA_CLIENT_ID`         — client.id (default `"blok-worker"`).
+ *   - `KAFKA_SASL_USERNAME`     — SASL/PLAIN username (optional).
+ *   - `KAFKA_SASL_PASSWORD`     — SASL/PLAIN password (optional).
+ *   - `KAFKA_SSL`               — when `"true"`, enable TLS.
+ */
+import { v4 as uuid } from "uuid";
+export class KafkaAdapter {
+    provider = "kafka";
+    config;
+    // biome-ignore lint/suspicious/noExplicitAny: kafkajs's exported `Kafka` constructor is loosely typed.
+    kafka = null;
+    handle = { consumers: new Map() };
+    connected = false;
+    stats = new Map();
+    constructor(config) {
+        this.config = {
+            brokers: config?.brokers ?? (process.env.KAFKA_BROKERS ?? "localhost:9092").split(",").map((s) => s.trim()),
+            clientId: config?.clientId ?? process.env.KAFKA_CLIENT_ID ?? "blok-worker",
+            saslUsername: config?.saslUsername ?? process.env.KAFKA_SASL_USERNAME,
+            saslPassword: config?.saslPassword ?? process.env.KAFKA_SASL_PASSWORD,
+            ssl: config?.ssl ?? process.env.KAFKA_SSL === "true",
+        };
+    }
+    async connect() {
+        if (this.connected)
+            return;
+        try {
+            // biome-ignore lint/suspicious/noExplicitAny: kafkajs is a runtime-loaded peer dep.
+            const kafkajs = await import("kafkajs");
+            const sasl = this.config.saslUsername && this.config.saslPassword
+                ? { mechanism: "plain", username: this.config.saslUsername, password: this.config.saslPassword }
+                : undefined;
+            this.kafka = new kafkajs.Kafka({
+                clientId: this.config.clientId,
+                brokers: this.config.brokers,
+                ssl: this.config.ssl,
+                sasl,
+            });
+            this.handle.producer = this.kafka.producer();
+            await this.handle.producer?.connect();
+            this.handle.admin = this.kafka.admin();
+            await this.handle.admin?.connect();
+            this.connected = true;
+        }
+        catch (err) {
+            throw new Error(`[blok][kafka] connect failed: ${err.message}. Install kafkajs as a peer dependency: bun add kafkajs`);
+        }
+    }
+    async disconnect() {
+        if (!this.connected)
+            return;
+        for (const [, consumer] of this.handle.consumers) {
+            try {
+                await consumer.disconnect();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        this.handle.consumers.clear();
+        try {
+            await this.handle.producer?.disconnect();
+        }
+        catch {
+            /* ignore */
+        }
+        try {
+            await this.handle.admin?.disconnect();
+        }
+        catch {
+            /* ignore */
+        }
+        this.connected = false;
+    }
+    async process(config, handler) {
+        if (!this.connected)
+            throw new Error("[blok][kafka] not connected. Call connect() first.");
+        const groupId = config.consumerGroup ?? `${config.queue}-group`;
+        const consumer = this.kafka.consumer({ groupId });
+        await consumer.connect();
+        await consumer.subscribe({ topic: config.queue, fromBeginning: config.fromBeginning === true });
+        this.handle.consumers.set(config.queue, consumer);
+        this.stats.set(config.queue, { completed: 0, failed: 0, active: 0 });
+        const stats = this.stats.get(config.queue);
+        await consumer.run({
+            autoCommit: config.ack !== false,
+            eachMessage: async ({ message, }) => {
+                const payloadString = message.value?.toString("utf8") ?? "";
+                let data;
+                try {
+                    data = payloadString.length > 0 ? JSON.parse(payloadString) : null;
+                }
+                catch {
+                    data = payloadString;
+                }
+                const headers = {};
+                if (message.headers) {
+                    for (const [k, v] of Object.entries(message.headers))
+                        headers[k] = v?.toString("utf8") ?? "";
+                }
+                const job = {
+                    id: message.key?.toString("utf8") ?? `${config.queue}:${message.offset}`,
+                    data,
+                    headers,
+                    queue: config.queue,
+                    priority: config.priority ?? 0,
+                    attempts: 0,
+                    maxRetries: config.retries ?? 0,
+                    createdAt: new Date(Number.parseInt(message.timestamp, 10)),
+                    timeout: config.timeout,
+                    raw: message,
+                    complete: async () => {
+                        stats.completed += 1;
+                    },
+                    fail: async (_err) => {
+                        stats.failed += 1;
+                        throw _err;
+                    },
+                };
+                stats.active += 1;
+                try {
+                    await handler(job);
+                    stats.completed += 1;
+                }
+                catch (err) {
+                    stats.failed += 1;
+                    throw err;
+                }
+                finally {
+                    stats.active = Math.max(0, stats.active - 1);
+                }
+            },
+        });
+    }
+    async addJob(queue, data, opts) {
+        if (!this.connected)
+            throw new Error("[blok][kafka] not connected. Call connect() first.");
+        if (!this.handle.producer)
+            throw new Error("[blok][kafka] producer not initialized");
+        const key = opts?.jobId ?? uuid();
+        const payload = typeof data === "string" ? data : JSON.stringify(data);
+        await this.handle.producer.send({
+            topic: queue,
+            messages: [
+                {
+                    key,
+                    value: payload,
+                    headers: opts?.delay ? { "x-blok-delay-ms": String(opts.delay) } : undefined,
+                },
+            ],
+        });
+        return key;
+    }
+    async stopProcessing(queue) {
+        const consumer = this.handle.consumers.get(queue);
+        if (consumer) {
+            try {
+                await consumer.stop();
+            }
+            catch {
+                /* ignore */
+            }
+            try {
+                await consumer.disconnect();
+            }
+            catch {
+                /* ignore */
+            }
+            this.handle.consumers.delete(queue);
+        }
+    }
+    isConnected() {
+        return this.connected;
+    }
+    async healthCheck() {
+        if (!this.connected || !this.handle.admin)
+            return false;
+        try {
+            await this.handle.admin.fetchTopicOffsets("__consumer_offsets");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getQueueStats(queue) {
+        const counters = this.stats.get(queue) ?? { completed: 0, failed: 0, active: 0 };
+        let waiting = 0;
+        if (this.handle.admin) {
+            try {
+                const offsets = await this.handle.admin.fetchTopicOffsets(queue);
+                // Approximate: total committed offsets across partitions. Real lag
+                // requires admin.fetchOffsets({ groupId }) — skipped here to keep
+                // the call cheap; production deployments should use Kafka's
+                // dedicated lag metrics anyway.
+                waiting = offsets.reduce((sum, p) => sum + Number.parseInt(p.offset, 10), 0);
+            }
+            catch {
+                waiting = 0;
+            }
+        }
+        return {
+            waiting,
+            active: counters.active,
+            completed: counters.completed,
+            failed: counters.failed,
+            delayed: 0,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"KafkaAdapter.js","sourceRoot":"","sources":["../../src/adapters/KafkaAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * KafkaAdapter — v0.7 PR 5 — Worker adapter backed by Apache Kafka via\n * `kafkajs`. Consumes from a topic (the `queue` field) with a\n * consumer-group identifier; produces via the same client.\n *\n * Kafka is fundamentally a streaming platform — not a queue — so a\n * few semantics differ from BullMQ/SQS/RabbitMQ:\n *\n *   - **Ordering**: per-partition, not per-topic. Set the partition\n *     key via the `dedupId` field on `addJob` to keep related\n *     messages on the same partition.\n *   - **Retries**: Kafka doesn't have a broker-side retry concept.\n *     The adapter re-throws on handler failure; offset commit is\n *     suppressed so the consumer re-polls the message on the next\n *     cycle. For real retry semantics, layer a dead-letter topic.\n *   - **Stats**: KafkaJS exposes consumer-group lag via its admin\n *     client; the lag count is reported as `waiting`. Other stats\n *     are tracked locally per consumer.\n *\n * Requires `kafkajs` as a peer dependency:\n *\n *     bun add kafkajs\n *\n * Environment variables (read at adapter construction):\n *   - `KAFKA_BROKERS`           — comma-separated list (default `localhost:9092`).\n *   - `KAFKA_CLIENT_ID`         — client.id (default `\"blok-worker\"`).\n *   - `KAFKA_SASL_USERNAME`     — SASL/PLAIN username (optional).\n *   - `KAFKA_SASL_PASSWORD`     — SASL/PLAIN password (optional).\n *   - `KAFKA_SSL`               — when `\"true\"`, enable TLS.\n */\n\nimport type { WorkerTriggerOpts } from \"@blokjs/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { WorkerAdapter, WorkerJob, WorkerQueueStats } from \"../WorkerTrigger\";\n\nexport interface KafkaConfig {\n\tbrokers: string[];\n\tclientId: string;\n\tsaslUsername?: string;\n\tsaslPassword?: string;\n\tssl: boolean;\n}\n\ninterface KafkaJsHandle {\n\tproducer?: {\n\t\tconnect: () => Promise<void>;\n\t\tdisconnect: () => Promise<void>;\n\t\tsend: (args: unknown) => Promise<unknown>;\n\t};\n\tconsumers: Map<\n\t\tstring,\n\t\t{\n\t\t\tdisconnect: () => Promise<void>;\n\t\t\tstop: () => Promise<void>;\n\t\t\trun: (opts: unknown) => Promise<void>;\n\t\t}\n\t>;\n\tadmin?: {\n\t\tconnect: () => Promise<void>;\n\t\tdisconnect: () => Promise<void>;\n\t\tfetchTopicOffsets: (topic: string) => Promise<Array<{ partition: number; offset: string }>>;\n\t};\n}\n\ninterface QueueStatsCounters {\n\tcompleted: number;\n\tfailed: number;\n\tactive: number;\n}\n\nexport class KafkaAdapter implements WorkerAdapter {\n\treadonly provider = \"kafka\" as const;\n\tprivate readonly config: KafkaConfig;\n\t// biome-ignore lint/suspicious/noExplicitAny: kafkajs's exported `Kafka` constructor is loosely typed.\n\tprivate kafka: any = null;\n\tprivate handle: KafkaJsHandle = { consumers: new Map() };\n\tprivate connected = false;\n\tprivate stats: Map<string, QueueStatsCounters> = new Map();\n\n\tconstructor(config?: Partial<KafkaConfig>) {\n\t\tthis.config = {\n\t\t\tbrokers: config?.brokers ?? (process.env.KAFKA_BROKERS ?? \"localhost:9092\").split(\",\").map((s) => s.trim()),\n\t\t\tclientId: config?.clientId ?? process.env.KAFKA_CLIENT_ID ?? \"blok-worker\",\n\t\t\tsaslUsername: config?.saslUsername ?? process.env.KAFKA_SASL_USERNAME,\n\t\t\tsaslPassword: config?.saslPassword ?? process.env.KAFKA_SASL_PASSWORD,\n\t\t\tssl: config?.ssl ?? process.env.KAFKA_SSL === \"true\",\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: kafkajs is a runtime-loaded peer dep.\n\t\t\tconst kafkajs: any = await import(\"kafkajs\");\n\t\t\tconst sasl =\n\t\t\t\tthis.config.saslUsername && this.config.saslPassword\n\t\t\t\t\t? { mechanism: \"plain\", username: this.config.saslUsername, password: this.config.saslPassword }\n\t\t\t\t\t: undefined;\n\t\t\tthis.kafka = new kafkajs.Kafka({\n\t\t\t\tclientId: this.config.clientId,\n\t\t\t\tbrokers: this.config.brokers,\n\t\t\t\tssl: this.config.ssl,\n\t\t\t\tsasl,\n\t\t\t});\n\t\t\tthis.handle.producer = this.kafka.producer();\n\t\t\tawait this.handle.producer?.connect();\n\t\t\tthis.handle.admin = this.kafka.admin();\n\t\t\tawait this.handle.admin?.connect();\n\t\t\tthis.connected = true;\n\t\t} catch (err) {\n\t\t\tthrow new Error(\n\t\t\t\t`[blok][kafka] connect failed: ${(err as Error).message}. Install kafkajs as a peer dependency: bun add kafkajs`,\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 [, consumer] of this.handle.consumers) {\n\t\t\ttry {\n\t\t\t\tawait consumer.disconnect();\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t}\n\t\tthis.handle.consumers.clear();\n\t\ttry {\n\t\t\tawait this.handle.producer?.disconnect();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\n\t\ttry {\n\t\t\tawait this.handle.admin?.disconnect();\n\t\t} catch {\n\t\t\t/* ignore */\n\t\t}\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][kafka] not connected. Call connect() first.\");\n\t\tconst groupId = config.consumerGroup ?? `${config.queue}-group`;\n\t\tconst consumer = this.kafka.consumer({ groupId });\n\t\tawait consumer.connect();\n\t\tawait consumer.subscribe({ topic: config.queue, fromBeginning: config.fromBeginning === true });\n\t\tthis.handle.consumers.set(config.queue, consumer);\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\tawait consumer.run({\n\t\t\tautoCommit: config.ack !== false,\n\t\t\teachMessage: async ({\n\t\t\t\tmessage,\n\t\t\t}: {\n\t\t\t\tmessage: { key?: Buffer; value?: Buffer; offset: string; timestamp: string; headers?: Record<string, Buffer> };\n\t\t\t}) => {\n\t\t\t\tconst payloadString = message.value?.toString(\"utf8\") ?? \"\";\n\t\t\t\tlet data: unknown;\n\t\t\t\ttry {\n\t\t\t\t\tdata = payloadString.length > 0 ? JSON.parse(payloadString) : null;\n\t\t\t\t} catch {\n\t\t\t\t\tdata = payloadString;\n\t\t\t\t}\n\t\t\t\tconst headers: Record<string, string> = {};\n\t\t\t\tif (message.headers) {\n\t\t\t\t\tfor (const [k, v] of Object.entries(message.headers)) headers[k] = v?.toString(\"utf8\") ?? \"\";\n\t\t\t\t}\n\t\t\t\tconst job: WorkerJob = {\n\t\t\t\t\tid: message.key?.toString(\"utf8\") ?? `${config.queue}:${message.offset}`,\n\t\t\t\t\tdata,\n\t\t\t\t\theaders,\n\t\t\t\t\tqueue: config.queue,\n\t\t\t\t\tpriority: config.priority ?? 0,\n\t\t\t\t\tattempts: 0,\n\t\t\t\t\tmaxRetries: config.retries ?? 0,\n\t\t\t\t\tcreatedAt: new Date(Number.parseInt(message.timestamp, 10)),\n\t\t\t\t\ttimeout: config.timeout,\n\t\t\t\t\traw: message,\n\t\t\t\t\tcomplete: async () => {\n\t\t\t\t\t\tstats.completed += 1;\n\t\t\t\t\t},\n\t\t\t\t\tfail: async (_err: Error) => {\n\t\t\t\t\t\tstats.failed += 1;\n\t\t\t\t\t\tthrow _err;\n\t\t\t\t\t},\n\t\t\t\t};\n\t\t\t\tstats.active += 1;\n\t\t\t\ttry {\n\t\t\t\t\tawait handler(job);\n\t\t\t\t\tstats.completed += 1;\n\t\t\t\t} catch (err) {\n\t\t\t\t\tstats.failed += 1;\n\t\t\t\t\tthrow err;\n\t\t\t\t} finally {\n\t\t\t\t\tstats.active = Math.max(0, stats.active - 1);\n\t\t\t\t}\n\t\t\t},\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][kafka] not connected. Call connect() first.\");\n\t\tif (!this.handle.producer) throw new Error(\"[blok][kafka] producer not initialized\");\n\t\tconst key = opts?.jobId ?? uuid();\n\t\tconst payload = typeof data === \"string\" ? data : JSON.stringify(data);\n\t\tawait this.handle.producer.send({\n\t\t\ttopic: queue,\n\t\t\tmessages: [\n\t\t\t\t{\n\t\t\t\t\tkey,\n\t\t\t\t\tvalue: payload,\n\t\t\t\t\theaders: opts?.delay ? { \"x-blok-delay-ms\": String(opts.delay) } : undefined,\n\t\t\t\t},\n\t\t\t],\n\t\t});\n\t\treturn key;\n\t}\n\n\tasync stopProcessing(queue: string): Promise<void> {\n\t\tconst consumer = this.handle.consumers.get(queue);\n\t\tif (consumer) {\n\t\t\ttry {\n\t\t\t\tawait consumer.stop();\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t\ttry {\n\t\t\t\tawait consumer.disconnect();\n\t\t\t} catch {\n\t\t\t\t/* ignore */\n\t\t\t}\n\t\t\tthis.handle.consumers.delete(queue);\n\t\t}\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.handle.admin) return false;\n\t\ttry {\n\t\t\tawait this.handle.admin.fetchTopicOffsets(\"__consumer_offsets\");\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\tif (this.handle.admin) {\n\t\t\ttry {\n\t\t\t\tconst offsets = await this.handle.admin.fetchTopicOffsets(queue);\n\t\t\t\t// Approximate: total committed offsets across partitions. Real lag\n\t\t\t\t// requires admin.fetchOffsets({ groupId }) — skipped here to keep\n\t\t\t\t// the call cheap; production deployments should use Kafka's\n\t\t\t\t// dedicated lag metrics anyway.\n\t\t\t\twaiting = offsets.reduce((sum, p) => sum + Number.parseInt(p.offset, 10), 0);\n\t\t\t} catch {\n\t\t\t\twaiting = 0;\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/NATSAdapter.d.ts

@@ -0,0 +1,110 @@
+/**
+ * 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 type { WorkerTriggerOpts } from "@blokjs/helper";
+import type { WorkerAdapter, WorkerJob, WorkerQueueStats } from "../WorkerTrigger";
+/**
+ * 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 declare function computeXDelayHoldMs(delay: number, createdMs: number, nowMs: number): number;
+/**
+ * NATS worker adapter configuration
+ */
+export interface NATSWorkerConfig {
+    /** NATS server URLs */
+    servers: string[];
+    /** Authentication token */
+    token?: string;
+    /** Username */
+    user?: string;
+    /** Password */
+    pass?: string;
+    /** JetStream stream name (default: "blok-worker") */
+    streamName?: string;
+}
+/**
+ * NATSWorkerAdapter - NATS JetStream implementation of WorkerAdapter
+ */
+export declare class NATSWorkerAdapter implements WorkerAdapter {
+    readonly provider: "nats";
+    private nc;
+    private js;
+    private jsm;
+    private connected;
+    private config;
+    private consumers;
+    private consumeIterators;
+    constructor(config?: Partial<NATSWorkerConfig>);
+    /**
+     * Connect to NATS and initialize JetStream
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from NATS
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Start processing jobs from a queue
+     */
+    process(config: WorkerTriggerOpts, handler: (job: WorkerJob) => Promise<void>): Promise<void>;
+    /**
+     * Add a job to a worker queue
+     */
+    addJob(queue: string, data: unknown, opts?: {
+        priority?: number;
+        delay?: number;
+        retries?: number;
+        timeout?: number;
+        jobId?: string;
+    }): Promise<string>;
+    /**
+     * Stop processing a specific queue
+     */
+    stopProcessing(queue: string): Promise<void>;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Health check
+     */
+    healthCheck(): Promise<boolean>;
+    /**
+     * Get queue statistics from JetStream consumer info
+     */
+    getQueueStats(queue: string): Promise<WorkerQueueStats>;
+    /**
+     * Ensure a JetStream stream exists with the given subjects
+     */
+    private ensureStream;
+}
+export default NATSWorkerAdapter;