@blokjs/trigger-worker 0.2.0

package/dist/adapters/BullMQAdapter.js

@@ -0,0 +1,259 @@
+"use strict";
+/**
+ * BullMQAdapter - Worker adapter using BullMQ (Redis-backed)
+ *
+ * Features:
+ * - Redis-backed persistent job queues
+ * - Configurable concurrency per queue
+ * - Job priority support
+ * - Delayed job scheduling
+ * - Automatic retries with configurable backoff
+ * - Queue statistics
+ *
+ * Requires: bullmq and ioredis as peer dependencies
+ *
+ * @example
+ * ```typescript
+ * const adapter = new BullMQAdapter({
+ *   host: "localhost",
+ *   port: 6379,
+ * });
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BullMQAdapter = void 0;
+/**
+ * BullMQ Worker Adapter
+ *
+ * Uses BullMQ for robust, Redis-backed job processing with support for
+ * priority queues, delayed jobs, retries, and dead letter handling.
+ */
+class BullMQAdapter {
+    provider = "bullmq";
+    connection = null;
+    workers = new Map();
+    queues = new Map();
+    connected = false;
+    config;
+    constructor(config) {
+        this.config = {
+            host: config?.host || process.env.REDIS_HOST || "localhost",
+            port: config?.port ?? Number.parseInt(process.env.REDIS_PORT || "6379", 10),
+            password: config?.password || process.env.REDIS_PASSWORD,
+            db: config?.db ?? Number.parseInt(process.env.REDIS_DB || "0", 10),
+            prefix: config?.prefix || "blok-worker",
+            maxStalledCount: config?.maxStalledCount ?? 2,
+            stalledInterval: config?.stalledInterval ?? 5000,
+        };
+    }
+    async connect() {
+        if (this.connected)
+            return;
+        try {
+            const { default: IORedis } = await Promise.resolve().then(() => __importStar(require("ioredis")));
+            this.connection = new IORedis({
+                host: this.config.host,
+                port: this.config.port,
+                password: this.config.password,
+                db: this.config.db,
+                maxRetriesPerRequest: null, // Required for BullMQ
+            });
+            // Verify connection
+            await this.connection.ping();
+            this.connected = true;
+            console.log(`[BullMQAdapter] Connected to Redis at ${this.config.host}:${this.config.port}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to connect to Redis: ${error.message}. Ensure ioredis and bullmq are installed: npm install ioredis bullmq`);
+        }
+    }
+    async disconnect() {
+        if (!this.connected)
+            return;
+        try {
+            // Close all workers
+            for (const [, worker] of this.workers) {
+                await worker.close();
+            }
+            this.workers.clear();
+            // Close all queues
+            for (const [, queue] of this.queues) {
+                await queue.close();
+            }
+            this.queues.clear();
+            // Close Redis connection
+            if (this.connection) {
+                await this.connection.quit();
+            }
+            this.connected = false;
+            console.log("[BullMQAdapter] Disconnected from Redis");
+        }
+        catch (error) {
+            console.error(`[BullMQAdapter] Disconnect error: ${error.message}`);
+        }
+    }
+    async process(config, handler) {
+        if (!this.connected) {
+            throw new Error("Not connected. Call connect() first.");
+        }
+        try {
+            // Dynamic import to avoid hard dependency on bullmq
+            const bullmq = await Promise.resolve().then(() => __importStar(require("bullmq")));
+            const BullWorker = bullmq.Worker;
+            const BullQueue = bullmq.Queue;
+            // Build worker options
+            const workerOpts = {
+                connection: this.connection,
+                concurrency: config.concurrency ?? 1,
+                prefix: this.config.prefix,
+                stalledInterval: this.config.stalledInterval ?? 5000,
+                maxStalledCount: this.config.maxStalledCount ?? 2,
+            };
+            const worker = new BullWorker(config.queue, 
+            // BullMQ processor callback
+            ((bullJob) => {
+                const job = bullJob;
+                const workerJob = {
+                    id: job.id || `job-${Date.now()}`,
+                    data: job.data,
+                    headers: job.data?._headers || {},
+                    queue: config.queue,
+                    priority: job.opts?.priority ?? config.priority ?? 0,
+                    attempts: job.attemptsMade,
+                    maxRetries: config.retries ?? 3,
+                    createdAt: new Date(job.timestamp),
+                    delay: job.opts?.delay,
+                    timeout: config.timeout,
+                    raw: job,
+                    complete: async () => {
+                        // BullMQ auto-completes when processor resolves
+                    },
+                    fail: async (error, requeue) => {
+                        if (!requeue) {
+                            await job.moveToFailed(error, job.token || "", true);
+                        }
+                        else {
+                            throw error; // BullMQ will auto-retry
+                        }
+                    },
+                };
+                return handler(workerJob);
+            }), workerOpts);
+            this.workers.set(config.queue, worker);
+            // Ensure queue object exists for job dispatching
+            if (!this.queues.has(config.queue)) {
+                const queue = new BullQueue(config.queue, {
+                    connection: this.connection,
+                    prefix: this.config.prefix,
+                });
+                this.queues.set(config.queue, queue);
+            }
+            console.log(`[BullMQAdapter] Processing queue: ${config.queue} (concurrency=${config.concurrency ?? 1})`);
+        }
+        catch (error) {
+            throw new Error(`Failed to start processing: ${error.message}`);
+        }
+    }
+    async addJob(queue, data, opts) {
+        if (!this.connected) {
+            throw new Error("Not connected. Call connect() first.");
+        }
+        try {
+            // Ensure queue exists
+            if (!this.queues.has(queue)) {
+                const { Queue } = await Promise.resolve().then(() => __importStar(require("bullmq")));
+                const q = new Queue(queue, {
+                    connection: this.connection,
+                    prefix: this.config.prefix,
+                });
+                this.queues.set(queue, q);
+            }
+            const q = this.queues.get(queue);
+            const job = await q.add("process", data, {
+                priority: opts?.priority,
+                delay: opts?.delay,
+                attempts: (opts?.retries ?? 3) + 1,
+                jobId: opts?.jobId,
+                backoff: {
+                    type: "exponential",
+                    delay: 1000,
+                },
+            });
+            return job.id;
+        }
+        catch (error) {
+            throw new Error(`Failed to add job: ${error.message}`);
+        }
+    }
+    async stopProcessing(queue) {
+        const worker = this.workers.get(queue);
+        if (worker) {
+            await worker.close();
+            this.workers.delete(queue);
+            console.log(`[BullMQAdapter] Stopped processing queue: ${queue}`);
+        }
+    }
+    isConnected() {
+        return this.connected;
+    }
+    async healthCheck() {
+        if (!this.connected || !this.connection)
+            return false;
+        try {
+            await this.connection.ping();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getQueueStats(queue) {
+        if (!this.queues.has(queue)) {
+            return { waiting: 0, active: 0, completed: 0, failed: 0, delayed: 0 };
+        }
+        const q = this.queues.get(queue);
+        const [waiting, active, completed, failed, delayed] = await Promise.all([
+            q.getWaitingCount(),
+            q.getActiveCount(),
+            q.getCompletedCount(),
+            q.getFailedCount(),
+            q.getDelayedCount(),
+        ]);
+        return { waiting, active, completed, failed, delayed };
+    }
+}
+exports.BullMQAdapter = BullMQAdapter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"BullMQAdapter.js","sourceRoot":"","sources":["../../src/adapters/BullMQAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * BullMQAdapter - Worker adapter using BullMQ (Redis-backed)\n *\n * Features:\n * - Redis-backed persistent job queues\n * - Configurable concurrency per queue\n * - Job priority support\n * - Delayed job scheduling\n * - Automatic retries with configurable backoff\n * - Queue statistics\n *\n * Requires: bullmq and ioredis as peer dependencies\n *\n * @example\n * ```typescript\n * const adapter = new BullMQAdapter({\n *   host: \"localhost\",\n *   port: 6379,\n * });\n * ```\n */\n\nimport type { WorkerAdapter, WorkerJob, WorkerQueueStats } from \"../WorkerTrigger\";\n\nimport type { WorkerTriggerOpts } from \"@blok/helper\";\n\n/**\n * BullMQ adapter configuration\n */\nexport interface BullMQConfig {\n\t/** Redis host (default: from REDIS_HOST env or \"localhost\") */\n\thost: string;\n\t/** Redis port (default: from REDIS_PORT env or 6379) */\n\tport: number;\n\t/** Redis password (default: from REDIS_PASSWORD env) */\n\tpassword?: string;\n\t/** Redis database (default: from REDIS_DB env or 0) */\n\tdb?: number;\n\t/** Key prefix for all BullMQ keys */\n\tprefix?: string;\n\t/** Max stalled count before job fails */\n\tmaxStalledCount?: number;\n\t/** Stalled interval in ms */\n\tstalledInterval?: number;\n}\n\n/**\n * BullMQ Worker Adapter\n *\n * Uses BullMQ for robust, Redis-backed job processing with support for\n * priority queues, delayed jobs, retries, and dead letter handling.\n */\nexport class BullMQAdapter implements WorkerAdapter {\n\treadonly provider = \"bullmq\" as const;\n\tprivate connection: unknown = null;\n\tprivate workers: Map<string, unknown> = new Map();\n\tprivate queues: Map<string, unknown> = new Map();\n\tprivate connected = false;\n\tprivate readonly config: BullMQConfig;\n\n\tconstructor(config?: Partial<BullMQConfig>) {\n\t\tthis.config = {\n\t\t\thost: config?.host || process.env.REDIS_HOST || \"localhost\",\n\t\t\tport: config?.port ?? Number.parseInt(process.env.REDIS_PORT || \"6379\", 10),\n\t\t\tpassword: config?.password || process.env.REDIS_PASSWORD,\n\t\t\tdb: config?.db ?? Number.parseInt(process.env.REDIS_DB || \"0\", 10),\n\t\t\tprefix: config?.prefix || \"blok-worker\",\n\t\t\tmaxStalledCount: config?.maxStalledCount ?? 2,\n\t\t\tstalledInterval: config?.stalledInterval ?? 5000,\n\t\t};\n\t}\n\n\tasync connect(): Promise<void> {\n\t\tif (this.connected) return;\n\n\t\ttry {\n\t\t\tconst { default: IORedis } = await import(\"ioredis\");\n\t\t\tthis.connection = new IORedis({\n\t\t\t\thost: this.config.host,\n\t\t\t\tport: this.config.port,\n\t\t\t\tpassword: this.config.password,\n\t\t\t\tdb: this.config.db,\n\t\t\t\tmaxRetriesPerRequest: null, // Required for BullMQ\n\t\t\t});\n\n\t\t\t// Verify connection\n\t\t\tawait (this.connection as { ping: () => Promise<string> }).ping();\n\t\t\tthis.connected = true;\n\t\t\tconsole.log(`[BullMQAdapter] Connected to Redis at ${this.config.host}:${this.config.port}`);\n\t\t} catch (error) {\n\t\t\tthrow new Error(\n\t\t\t\t`Failed to connect to Redis: ${(error as Error).message}. Ensure ioredis and bullmq are installed: npm install ioredis bullmq`,\n\t\t\t);\n\t\t}\n\t}\n\n\tasync disconnect(): Promise<void> {\n\t\tif (!this.connected) return;\n\n\t\ttry {\n\t\t\t// Close all workers\n\t\t\tfor (const [, worker] of this.workers) {\n\t\t\t\tawait (worker as { close: () => Promise<void> }).close();\n\t\t\t}\n\t\t\tthis.workers.clear();\n\n\t\t\t// Close all queues\n\t\t\tfor (const [, queue] of this.queues) {\n\t\t\t\tawait (queue as { close: () => Promise<void> }).close();\n\t\t\t}\n\t\t\tthis.queues.clear();\n\n\t\t\t// Close Redis connection\n\t\t\tif (this.connection) {\n\t\t\t\tawait (this.connection as { quit: () => Promise<string> }).quit();\n\t\t\t}\n\n\t\t\tthis.connected = false;\n\t\t\tconsole.log(\"[BullMQAdapter] Disconnected from Redis\");\n\t\t} catch (error) {\n\t\t\tconsole.error(`[BullMQAdapter] Disconnect error: ${(error as Error).message}`);\n\t\t}\n\t}\n\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\ttry {\n\t\t\t// Dynamic import to avoid hard dependency on bullmq\n\t\t\tconst bullmq = await import(\"bullmq\");\n\t\t\tconst BullWorker = bullmq.Worker;\n\t\t\tconst BullQueue = bullmq.Queue;\n\n\t\t\t// Build worker options\n\t\t\tconst workerOpts = {\n\t\t\t\tconnection: this.connection,\n\t\t\t\tconcurrency: config.concurrency ?? 1,\n\t\t\t\tprefix: this.config.prefix,\n\t\t\t\tstalledInterval: this.config.stalledInterval ?? 5000,\n\t\t\t\tmaxStalledCount: this.config.maxStalledCount ?? 2,\n\t\t\t};\n\n\t\t\tconst worker = new BullWorker(\n\t\t\t\tconfig.queue,\n\t\t\t\t// BullMQ processor callback\n\t\t\t\t((bullJob: unknown) => {\n\t\t\t\t\tconst job = bullJob as {\n\t\t\t\t\t\tid?: string;\n\t\t\t\t\t\tdata: unknown;\n\t\t\t\t\t\topts?: { priority?: number; delay?: number };\n\t\t\t\t\t\tattemptsMade: number;\n\t\t\t\t\t\ttimestamp: number;\n\t\t\t\t\t\ttoken?: string;\n\t\t\t\t\t\tmoveToFailed: (err: Error, token: string, fetchNext: boolean) => Promise<void>;\n\t\t\t\t\t};\n\t\t\t\t\tconst workerJob: WorkerJob = {\n\t\t\t\t\t\tid: job.id || `job-${Date.now()}`,\n\t\t\t\t\t\tdata: job.data,\n\t\t\t\t\t\theaders: ((job.data as Record<string, unknown>)?._headers as Record<string, string>) || {},\n\t\t\t\t\t\tqueue: config.queue,\n\t\t\t\t\t\tpriority: job.opts?.priority ?? config.priority ?? 0,\n\t\t\t\t\t\tattempts: job.attemptsMade,\n\t\t\t\t\t\tmaxRetries: config.retries ?? 3,\n\t\t\t\t\t\tcreatedAt: new Date(job.timestamp),\n\t\t\t\t\t\tdelay: job.opts?.delay,\n\t\t\t\t\t\ttimeout: config.timeout,\n\t\t\t\t\t\traw: job,\n\t\t\t\t\t\tcomplete: async () => {\n\t\t\t\t\t\t\t// BullMQ auto-completes when processor resolves\n\t\t\t\t\t\t},\n\t\t\t\t\t\tfail: async (error: Error, requeue?: boolean) => {\n\t\t\t\t\t\t\tif (!requeue) {\n\t\t\t\t\t\t\t\tawait job.moveToFailed(error, job.token || \"\", true);\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthrow error; // BullMQ will auto-retry\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t},\n\t\t\t\t\t};\n\t\t\t\t\treturn handler(workerJob);\n\t\t\t\t}) as never,\n\t\t\t\tworkerOpts as never,\n\t\t\t);\n\n\t\t\tthis.workers.set(config.queue, worker);\n\n\t\t\t// Ensure queue object exists for job dispatching\n\t\t\tif (!this.queues.has(config.queue)) {\n\t\t\t\tconst queue = new BullQueue(config.queue, {\n\t\t\t\t\tconnection: this.connection as { host: string; port: number },\n\t\t\t\t\tprefix: this.config.prefix,\n\t\t\t\t} as never);\n\t\t\t\tthis.queues.set(config.queue, queue);\n\t\t\t}\n\n\t\t\tconsole.log(`[BullMQAdapter] Processing queue: ${config.queue} (concurrency=${config.concurrency ?? 1})`);\n\t\t} catch (error) {\n\t\t\tthrow new Error(`Failed to start processing: ${(error as Error).message}`);\n\t\t}\n\t}\n\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\ttry {\n\t\t\t// Ensure queue exists\n\t\t\tif (!this.queues.has(queue)) {\n\t\t\t\tconst { Queue } = await import(\"bullmq\");\n\t\t\t\tconst q = new Queue(queue, {\n\t\t\t\t\tconnection: this.connection as { host: string; port: number },\n\t\t\t\t\tprefix: this.config.prefix,\n\t\t\t\t});\n\t\t\t\tthis.queues.set(queue, q);\n\t\t\t}\n\n\t\t\tconst q = this.queues.get(queue) as {\n\t\t\t\tadd: (name: string, data: unknown, opts: Record<string, unknown>) => Promise<{ id: string }>;\n\t\t\t};\n\n\t\t\tconst job = await q.add(\"process\", data, {\n\t\t\t\tpriority: opts?.priority,\n\t\t\t\tdelay: opts?.delay,\n\t\t\t\tattempts: (opts?.retries ?? 3) + 1,\n\t\t\t\tjobId: opts?.jobId,\n\t\t\t\tbackoff: {\n\t\t\t\t\ttype: \"exponential\",\n\t\t\t\t\tdelay: 1000,\n\t\t\t\t},\n\t\t\t});\n\n\t\t\treturn job.id;\n\t\t} catch (error) {\n\t\t\tthrow new Error(`Failed to add job: ${(error as Error).message}`);\n\t\t}\n\t}\n\n\tasync stopProcessing(queue: string): Promise<void> {\n\t\tconst worker = this.workers.get(queue);\n\t\tif (worker) {\n\t\t\tawait (worker as { close: () => Promise<void> }).close();\n\t\t\tthis.workers.delete(queue);\n\t\t\tconsole.log(`[BullMQAdapter] Stopped processing queue: ${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.connection) return false;\n\t\ttry {\n\t\t\tawait (this.connection as { ping: () => Promise<string> }).ping();\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\tif (!this.queues.has(queue)) {\n\t\t\treturn { waiting: 0, active: 0, completed: 0, failed: 0, delayed: 0 };\n\t\t}\n\n\t\tconst q = this.queues.get(queue) as {\n\t\t\tgetWaitingCount: () => Promise<number>;\n\t\t\tgetActiveCount: () => Promise<number>;\n\t\t\tgetCompletedCount: () => Promise<number>;\n\t\t\tgetFailedCount: () => Promise<number>;\n\t\t\tgetDelayedCount: () => Promise<number>;\n\t\t};\n\n\t\tconst [waiting, active, completed, failed, delayed] = await Promise.all([\n\t\t\tq.getWaitingCount(),\n\t\t\tq.getActiveCount(),\n\t\t\tq.getCompletedCount(),\n\t\t\tq.getFailedCount(),\n\t\t\tq.getDelayedCount(),\n\t\t]);\n\n\t\treturn { waiting, active, completed, failed, delayed };\n\t}\n}\n"]}

package/dist/adapters/InMemoryAdapter.d.ts

@@ -0,0 +1,48 @@
+/**
+ * InMemoryAdapter - Worker adapter using in-process queues
+ *
+ * Ideal for:
+ * - Development and testing
+ * - Simple background job processing
+ * - Single-instance deployments
+ *
+ * Limitations:
+ * - Jobs are lost on process restart
+ * - No distributed processing
+ * - No persistence
+ *
+ * @example
+ * ```typescript
+ * const adapter = new InMemoryAdapter();
+ * ```
+ */
+import type { WorkerTriggerOpts } from "@blok/helper";
+import type { WorkerAdapter, WorkerJob, WorkerQueueStats } from "../WorkerTrigger";
+/**
+ * InMemoryAdapter - Simple in-process worker queue
+ */
+export declare class InMemoryAdapter implements WorkerAdapter {
+    readonly provider: "in-memory";
+    private connected;
+    private jobs;
+    private processors;
+    private stats;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    process(config: WorkerTriggerOpts, handler: (job: WorkerJob) => Promise<void>): Promise<void>;
+    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>;
+    /**
+     * Process the next available job from a queue
+     */
+    private processNext;
+}

package/dist/adapters/InMemoryAdapter.js

@@ -0,0 +1,224 @@
+"use strict";
+/**
+ * InMemoryAdapter - Worker adapter using in-process queues
+ *
+ * Ideal for:
+ * - Development and testing
+ * - Simple background job processing
+ * - Single-instance deployments
+ *
+ * Limitations:
+ * - Jobs are lost on process restart
+ * - No distributed processing
+ * - No persistence
+ *
+ * @example
+ * ```typescript
+ * const adapter = new InMemoryAdapter();
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryAdapter = void 0;
+const uuid_1 = require("uuid");
+/**
+ * InMemoryAdapter - Simple in-process worker queue
+ */
+class InMemoryAdapter {
+    provider = "in-memory";
+    connected = false;
+    jobs = new Map();
+    processors = new Map();
+    stats = new Map();
+    async connect() {
+        this.connected = true;
+    }
+    async disconnect() {
+        // Stop all processors
+        for (const [queue, processor] of this.processors) {
+            processor.running = false;
+            if (processor.timer) {
+                clearInterval(processor.timer);
+            }
+        }
+        this.processors.clear();
+        this.jobs.clear();
+        this.stats.clear();
+        this.connected = false;
+    }
+    async process(config, handler) {
+        if (!this.connected) {
+            throw new Error("Not connected. Call connect() first.");
+        }
+        if (!this.jobs.has(config.queue)) {
+            this.jobs.set(config.queue, []);
+        }
+        if (!this.stats.has(config.queue)) {
+            this.stats.set(config.queue, { completed: 0, failed: 0 });
+        }
+        const processor = {
+            config,
+            handler,
+            active: 0,
+            running: true,
+        };
+        this.processors.set(config.queue, processor);
+        // Start polling for jobs
+        processor.timer = setInterval(() => {
+            this.processNext(config.queue).catch((err) => {
+                console.error(`[InMemoryAdapter] Error processing ${config.queue}: ${err.message}`);
+            });
+        }, 50); // Poll every 50ms
+    }
+    async addJob(queue, data, opts) {
+        if (!this.connected) {
+            throw new Error("Not connected. Call connect() first.");
+        }
+        if (!this.jobs.has(queue)) {
+            this.jobs.set(queue, []);
+        }
+        if (!this.stats.has(queue)) {
+            this.stats.set(queue, { completed: 0, failed: 0 });
+        }
+        const job = {
+            id: opts?.jobId || (0, uuid_1.v4)(),
+            data,
+            queue,
+            priority: opts?.priority ?? 0,
+            attempts: 0,
+            maxRetries: opts?.retries ?? 3,
+            createdAt: new Date(),
+            delay: opts?.delay ?? 0,
+            timeout: opts?.timeout ?? 0,
+            status: opts?.delay && opts.delay > 0 ? "delayed" : "waiting",
+        };
+        if (job.status === "delayed") {
+            job.scheduledAt = new Date(Date.now() + job.delay);
+        }
+        const jobs = this.jobs.get(queue);
+        // Insert sorted by priority (higher first)
+        const insertIdx = jobs.findIndex((j) => j.status === "waiting" && j.priority < job.priority);
+        if (insertIdx >= 0) {
+            jobs.splice(insertIdx, 0, job);
+        }
+        else {
+            jobs.push(job);
+        }
+        return job.id;
+    }
+    async stopProcessing(queue) {
+        const processor = this.processors.get(queue);
+        if (processor) {
+            processor.running = false;
+            if (processor.timer) {
+                clearInterval(processor.timer);
+            }
+            this.processors.delete(queue);
+        }
+    }
+    isConnected() {
+        return this.connected;
+    }
+    async healthCheck() {
+        return this.connected;
+    }
+    async getQueueStats(queue) {
+        const jobs = this.jobs.get(queue) || [];
+        const queueStats = this.stats.get(queue) || { completed: 0, failed: 0 };
+        return {
+            waiting: jobs.filter((j) => j.status === "waiting").length,
+            active: jobs.filter((j) => j.status === "active").length,
+            completed: queueStats.completed,
+            failed: queueStats.failed,
+            delayed: jobs.filter((j) => j.status === "delayed").length,
+        };
+    }
+    /**
+     * Process the next available job from a queue
+     */
+    async processNext(queue) {
+        const processor = this.processors.get(queue);
+        if (!processor || !processor.running)
+            return;
+        const concurrency = processor.config.concurrency ?? 1;
+        if (processor.active >= concurrency)
+            return;
+        const jobs = this.jobs.get(queue);
+        if (!jobs || jobs.length === 0)
+            return;
+        // Check for delayed jobs that are ready
+        const now = Date.now();
+        for (const job of jobs) {
+            if (job.status === "delayed" && job.scheduledAt && job.scheduledAt.getTime() <= now) {
+                job.status = "waiting";
+            }
+        }
+        // Find next waiting job
+        const jobIdx = jobs.findIndex((j) => j.status === "waiting");
+        if (jobIdx < 0)
+            return;
+        const internalJob = jobs[jobIdx];
+        internalJob.status = "active";
+        processor.active++;
+        const workerJob = {
+            id: internalJob.id,
+            data: internalJob.data,
+            headers: {},
+            queue: internalJob.queue,
+            priority: internalJob.priority,
+            attempts: internalJob.attempts,
+            maxRetries: internalJob.maxRetries,
+            createdAt: internalJob.createdAt,
+            delay: internalJob.delay,
+            timeout: internalJob.timeout,
+            raw: internalJob,
+            complete: async () => {
+                internalJob.status = "completed";
+                const idx = jobs.indexOf(internalJob);
+                if (idx >= 0)
+                    jobs.splice(idx, 1);
+                const s = this.stats.get(queue);
+                if (s)
+                    s.completed++;
+            },
+            fail: async (error, requeue) => {
+                internalJob.attempts++;
+                internalJob.error = error;
+                if (requeue && internalJob.attempts < internalJob.maxRetries) {
+                    // Requeue with backoff
+                    const backoff = Math.min(1000 * Math.pow(2, internalJob.attempts), 30000);
+                    internalJob.status = "delayed";
+                    internalJob.scheduledAt = new Date(Date.now() + backoff);
+                }
+                else {
+                    internalJob.status = "failed";
+                    const idx = jobs.indexOf(internalJob);
+                    if (idx >= 0)
+                        jobs.splice(idx, 1);
+                    const s = this.stats.get(queue);
+                    if (s)
+                        s.failed++;
+                }
+            },
+        };
+        try {
+            await processor.handler(workerJob);
+        }
+        catch {
+            // Handler threw - treat as failure
+            if (internalJob.status === "active") {
+                internalJob.status = "failed";
+                const idx = jobs.indexOf(internalJob);
+                if (idx >= 0)
+                    jobs.splice(idx, 1);
+                const s = this.stats.get(queue);
+                if (s)
+                    s.failed++;
+            }
+        }
+        finally {
+            processor.active--;
+        }
+    }
+}
+exports.InMemoryAdapter = InMemoryAdapter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"InMemoryAdapter.js","sourceRoot":"","sources":["../../src/adapters/InMemoryAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * InMemoryAdapter - Worker adapter using in-process queues\n *\n * Ideal for:\n * - Development and testing\n * - Simple background job processing\n * - Single-instance deployments\n *\n * Limitations:\n * - Jobs are lost on process restart\n * - No distributed processing\n * - No persistence\n *\n * @example\n * ```typescript\n * const adapter = new InMemoryAdapter();\n * ```\n */\n\nimport type { WorkerTriggerOpts } from \"@blok/helper\";\nimport { v4 as uuid } from \"uuid\";\nimport type { WorkerAdapter, WorkerJob, WorkerQueueStats } from \"../WorkerTrigger\";\n\n/**\n * Internal job representation\n */\ninterface InternalJob {\n\tid: string;\n\tdata: unknown;\n\tqueue: string;\n\tpriority: number;\n\tattempts: number;\n\tmaxRetries: number;\n\tcreatedAt: Date;\n\tdelay: number;\n\ttimeout: number;\n\tstatus: \"waiting\" | \"active\" | \"completed\" | \"failed\" | \"delayed\";\n\tscheduledAt?: Date;\n\terror?: Error;\n}\n\n/**\n * Queue processor entry\n */\ninterface QueueProcessor {\n\tconfig: WorkerTriggerOpts;\n\thandler: (job: WorkerJob) => Promise<void>;\n\tactive: number;\n\trunning: boolean;\n\ttimer?: ReturnType<typeof setInterval>;\n}\n\n/**\n * InMemoryAdapter - Simple in-process worker queue\n */\nexport class InMemoryAdapter implements WorkerAdapter {\n\treadonly provider = \"in-memory\" as const;\n\tprivate connected = false;\n\tprivate jobs: Map<string, InternalJob[]> = new Map();\n\tprivate processors: Map<string, QueueProcessor> = new Map();\n\tprivate stats: Map<string, { completed: number; failed: number }> = new Map();\n\n\tasync connect(): Promise<void> {\n\t\tthis.connected = true;\n\t}\n\n\tasync disconnect(): Promise<void> {\n\t\t// Stop all processors\n\t\tfor (const [queue, processor] of this.processors) {\n\t\t\tprocessor.running = false;\n\t\t\tif (processor.timer) {\n\t\t\t\tclearInterval(processor.timer);\n\t\t\t}\n\t\t}\n\t\tthis.processors.clear();\n\t\tthis.jobs.clear();\n\t\tthis.stats.clear();\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) {\n\t\t\tthrow new Error(\"Not connected. Call connect() first.\");\n\t\t}\n\n\t\tif (!this.jobs.has(config.queue)) {\n\t\t\tthis.jobs.set(config.queue, []);\n\t\t}\n\t\tif (!this.stats.has(config.queue)) {\n\t\t\tthis.stats.set(config.queue, { completed: 0, failed: 0 });\n\t\t}\n\n\t\tconst processor: QueueProcessor = {\n\t\t\tconfig,\n\t\t\thandler,\n\t\t\tactive: 0,\n\t\t\trunning: true,\n\t\t};\n\n\t\tthis.processors.set(config.queue, processor);\n\n\t\t// Start polling for jobs\n\t\tprocessor.timer = setInterval(() => {\n\t\t\tthis.processNext(config.queue).catch((err) => {\n\t\t\t\tconsole.error(`[InMemoryAdapter] Error processing ${config.queue}: ${(err as Error).message}`);\n\t\t\t});\n\t\t}, 50); // Poll every 50ms\n\t}\n\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\tif (!this.jobs.has(queue)) {\n\t\t\tthis.jobs.set(queue, []);\n\t\t}\n\t\tif (!this.stats.has(queue)) {\n\t\t\tthis.stats.set(queue, { completed: 0, failed: 0 });\n\t\t}\n\n\t\tconst job: InternalJob = {\n\t\t\tid: opts?.jobId || uuid(),\n\t\t\tdata,\n\t\t\tqueue,\n\t\t\tpriority: opts?.priority ?? 0,\n\t\t\tattempts: 0,\n\t\t\tmaxRetries: opts?.retries ?? 3,\n\t\t\tcreatedAt: new Date(),\n\t\t\tdelay: opts?.delay ?? 0,\n\t\t\ttimeout: opts?.timeout ?? 0,\n\t\t\tstatus: opts?.delay && opts.delay > 0 ? \"delayed\" : \"waiting\",\n\t\t};\n\n\t\tif (job.status === \"delayed\") {\n\t\t\tjob.scheduledAt = new Date(Date.now() + job.delay);\n\t\t}\n\n\t\tconst jobs = this.jobs.get(queue)!;\n\n\t\t// Insert sorted by priority (higher first)\n\t\tconst insertIdx = jobs.findIndex((j) => j.status === \"waiting\" && j.priority < job.priority);\n\t\tif (insertIdx >= 0) {\n\t\t\tjobs.splice(insertIdx, 0, job);\n\t\t} else {\n\t\t\tjobs.push(job);\n\t\t}\n\n\t\treturn job.id;\n\t}\n\n\tasync stopProcessing(queue: string): Promise<void> {\n\t\tconst processor = this.processors.get(queue);\n\t\tif (processor) {\n\t\t\tprocessor.running = false;\n\t\t\tif (processor.timer) {\n\t\t\t\tclearInterval(processor.timer);\n\t\t\t}\n\t\t\tthis.processors.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\treturn this.connected;\n\t}\n\n\tasync getQueueStats(queue: string): Promise<WorkerQueueStats> {\n\t\tconst jobs = this.jobs.get(queue) || [];\n\t\tconst queueStats = this.stats.get(queue) || { completed: 0, failed: 0 };\n\n\t\treturn {\n\t\t\twaiting: jobs.filter((j) => j.status === \"waiting\").length,\n\t\t\tactive: jobs.filter((j) => j.status === \"active\").length,\n\t\t\tcompleted: queueStats.completed,\n\t\t\tfailed: queueStats.failed,\n\t\t\tdelayed: jobs.filter((j) => j.status === \"delayed\").length,\n\t\t};\n\t}\n\n\t/**\n\t * Process the next available job from a queue\n\t */\n\tprivate async processNext(queue: string): Promise<void> {\n\t\tconst processor = this.processors.get(queue);\n\t\tif (!processor || !processor.running) return;\n\n\t\tconst concurrency = processor.config.concurrency ?? 1;\n\t\tif (processor.active >= concurrency) return;\n\n\t\tconst jobs = this.jobs.get(queue);\n\t\tif (!jobs || jobs.length === 0) return;\n\n\t\t// Check for delayed jobs that are ready\n\t\tconst now = Date.now();\n\t\tfor (const job of jobs) {\n\t\t\tif (job.status === \"delayed\" && job.scheduledAt && job.scheduledAt.getTime() <= now) {\n\t\t\t\tjob.status = \"waiting\";\n\t\t\t}\n\t\t}\n\n\t\t// Find next waiting job\n\t\tconst jobIdx = jobs.findIndex((j) => j.status === \"waiting\");\n\t\tif (jobIdx < 0) return;\n\n\t\tconst internalJob = jobs[jobIdx];\n\t\tinternalJob.status = \"active\";\n\t\tprocessor.active++;\n\n\t\tconst workerJob: WorkerJob = {\n\t\t\tid: internalJob.id,\n\t\t\tdata: internalJob.data,\n\t\t\theaders: {},\n\t\t\tqueue: internalJob.queue,\n\t\t\tpriority: internalJob.priority,\n\t\t\tattempts: internalJob.attempts,\n\t\t\tmaxRetries: internalJob.maxRetries,\n\t\t\tcreatedAt: internalJob.createdAt,\n\t\t\tdelay: internalJob.delay,\n\t\t\ttimeout: internalJob.timeout,\n\t\t\traw: internalJob,\n\t\t\tcomplete: async () => {\n\t\t\t\tinternalJob.status = \"completed\";\n\t\t\t\tconst idx = jobs.indexOf(internalJob);\n\t\t\t\tif (idx >= 0) jobs.splice(idx, 1);\n\t\t\t\tconst s = this.stats.get(queue);\n\t\t\t\tif (s) s.completed++;\n\t\t\t},\n\t\t\tfail: async (error: Error, requeue?: boolean) => {\n\t\t\t\tinternalJob.attempts++;\n\t\t\t\tinternalJob.error = error;\n\n\t\t\t\tif (requeue && internalJob.attempts < internalJob.maxRetries) {\n\t\t\t\t\t// Requeue with backoff\n\t\t\t\t\tconst backoff = Math.min(1000 * Math.pow(2, internalJob.attempts), 30000);\n\t\t\t\t\tinternalJob.status = \"delayed\";\n\t\t\t\t\tinternalJob.scheduledAt = new Date(Date.now() + backoff);\n\t\t\t\t} else {\n\t\t\t\t\tinternalJob.status = \"failed\";\n\t\t\t\t\tconst idx = jobs.indexOf(internalJob);\n\t\t\t\t\tif (idx >= 0) jobs.splice(idx, 1);\n\t\t\t\t\tconst s = this.stats.get(queue);\n\t\t\t\t\tif (s) s.failed++;\n\t\t\t\t}\n\t\t\t},\n\t\t};\n\n\t\ttry {\n\t\t\tawait processor.handler(workerJob);\n\t\t} catch {\n\t\t\t// Handler threw - treat as failure\n\t\t\tif (internalJob.status === \"active\") {\n\t\t\t\tinternalJob.status = \"failed\";\n\t\t\t\tconst idx = jobs.indexOf(internalJob);\n\t\t\t\tif (idx >= 0) jobs.splice(idx, 1);\n\t\t\t\tconst s = this.stats.get(queue);\n\t\t\t\tif (s) s.failed++;\n\t\t\t}\n\t\t} finally {\n\t\t\tprocessor.active--;\n\t\t}\n\t}\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * @blok/trigger-worker
+ *
+ * Worker-based trigger for Blok workflows.
+ * Supports background job processing with:
+ * - Configurable concurrency per queue
+ * - Automatic retries with exponential backoff
+ * - Job timeouts
+ * - Priority-based job ordering
+ * - Delayed job scheduling
+ * - Queue statistics and monitoring
+ *
+ * Adapters:
+ * - BullMQ (Redis-backed, production)
+ * - InMemory (development/testing)
+ *
+ * @example BullMQ
+ * ```typescript
+ * import { WorkerTrigger, BullMQAdapter } from "@blok/trigger-worker";
+ *
+ * class MyWorkerTrigger extends WorkerTrigger {
+ *   protected adapter = new BullMQAdapter({
+ *     host: "localhost",
+ *     port: 6379,
+ *   });
+ *
+ *   protected nodes = myNodes;
+ *   protected workflows = myWorkflows;
+ * }
+ *
+ * const trigger = new MyWorkerTrigger();
+ * await trigger.listen();
+ *
+ * // Dispatch a job
+ * await trigger.dispatch("background-jobs", { userId: "123" }, {
+ *   priority: 10,
+ *   retries: 3,
+ *   delay: 5000, // delay 5 seconds
+ * });
+ * ```
+ *
+ * @example InMemory (development)
+ * ```typescript
+ * import { WorkerTrigger, InMemoryAdapter } from "@blok/trigger-worker";
+ *
+ * class DevWorkerTrigger extends WorkerTrigger {
+ *   protected adapter = new InMemoryAdapter();
+ *   protected nodes = myNodes;
+ *   protected workflows = myWorkflows;
+ * }
+ * ```
+ */
+export { WorkerTrigger, type WorkerAdapter, type WorkerJob, type WorkerQueueStats, } from "./WorkerTrigger";
+export { BullMQAdapter, type BullMQConfig } from "./adapters/BullMQAdapter";
+export { InMemoryAdapter } from "./adapters/InMemoryAdapter";
+export type { WorkerTriggerOpts } from "@blok/helper";