@blokjs/trigger-worker 0.4.0 → 0.6.2

package/dist/adapters/InMemoryAdapter.js

@@ -70,8 +70,14 @@ export class InMemoryAdapter {
         if (!this.connected) {
             throw new Error("Not connected. Call connect() first.");
         }
-        if (!this.jobs.has(queue)) {
-            this.jobs.set(queue, []);
+        // Get-or-init the per-queue job list. Same pattern as `stats`
+        // below — the previous code used `set-if-absent` then `.get()!`,
+        // but that non-null assertion is what biome flags. Pulling the
+        // reference once and seeding when missing keeps the type exact.
+        let jobs = this.jobs.get(queue);
+        if (!jobs) {
+            jobs = [];
+            this.jobs.set(queue, jobs);
         }
         if (!this.stats.has(queue)) {
             this.stats.set(queue, { completed: 0, failed: 0 });
@@ -91,7 +97,6 @@ export class InMemoryAdapter {
         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) {
@@ -182,7 +187,7 @@ export class InMemoryAdapter {
                 internalJob.error = error;
                 if (requeue && internalJob.attempts < internalJob.maxRetries) {
                     // Requeue with backoff
-                    const backoff = Math.min(1000 * Math.pow(2, internalJob.attempts), 30000);
+                    const backoff = Math.min(1000 * 2 ** internalJob.attempts, 30000);
                     internalJob.status = "delayed";
                     internalJob.scheduledAt = new Date(Date.now() + backoff);
                 }
@@ -217,4 +222,4 @@ export class InMemoryAdapter {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"InMemoryAdapter.js","sourceRoot":"","sources":["../../src/adapters/InMemoryAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EAAE,EAAE,IAAI,IAAI,EAAE,MAAM,MAAM,CAAC;AAgClC;;GAEG;AACH,MAAM,OAAO,eAAe;IAClB,QAAQ,GAAG,WAAoB,CAAC;IACjC,SAAS,GAAG,KAAK,CAAC;IAClB,IAAI,GAA+B,IAAI,GAAG,EAAE,CAAC;IAC7C,UAAU,GAAgC,IAAI,GAAG,EAAE,CAAC;IACpD,KAAK,GAAuD,IAAI,GAAG,EAAE,CAAC;IAE9E,KAAK,CAAC,OAAO;QACZ,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,UAAU;QACf,sBAAsB;QACtB,KAAK,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAClD,SAAS,CAAC,OAAO,GAAG,KAAK,CAAC;YAC1B,IAAI,SAAS,CAAC,KAAK,EAAE,CAAC;gBACrB,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YAChC,CAAC;QACF,CAAC;QACD,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;QACxB,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;QAClB,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACnB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACxB,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,MAAyB,EAAE,OAA0C;QAClF,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QACzD,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YAClC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjC,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YACnC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;QAC3D,CAAC;QAED,MAAM,SAAS,GAAmB;YACjC,MAAM;YACN,OAAO;YACP,MAAM,EAAE,CAAC;YACT,OAAO,EAAE,IAAI;SACb,CAAC;QAEF,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QAE7C,yBAAyB;QACzB,SAAS,CAAC,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE;YAClC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;gBAC5C,OAAO,CAAC,KAAK,CAAC,sCAAsC,MAAM,CAAC,KAAK,KAAM,GAAa,CAAC,OAAO,EAAE,CAAC,CAAC;YAChG,CAAC,CAAC,CAAC;QACJ,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,kBAAkB;IAC3B,CAAC;IAED,KAAK,CAAC,MAAM,CACX,KAAa,EACb,IAAa,EACb,IAMC;QAED,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QACzD,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YAC3B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAC1B,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YAC5B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,CAAC;QACpD,CAAC;QAED,MAAM,GAAG,GAAgB;YACxB,EAAE,EAAE,IAAI,EAAE,KAAK,IAAI,IAAI,EAAE;YACzB,IAAI;YACJ,KAAK;YACL,QAAQ,EAAE,IAAI,EAAE,QAAQ,IAAI,CAAC;YAC7B,QAAQ,EAAE,CAAC;YACX,UAAU,EAAE,IAAI,EAAE,OAAO,IAAI,CAAC;YAC9B,SAAS,EAAE,IAAI,IAAI,EAAE;YACrB,KAAK,EAAE,IAAI,EAAE,KAAK,IAAI,CAAC;YACvB,OAAO,EAAE,IAAI,EAAE,OAAO,IAAI,CAAC;YAC3B,MAAM,EAAE,IAAI,EAAE,KAAK,IAAI,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS;SAC7D,CAAC;QAEF,IAAI,GAAG,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;YAC9B,GAAG,CAAC,WAAW,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC;QACpD,CAAC;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAE,CAAC;QAEnC,2CAA2C;QAC3C,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS,IAAI,CAAC,CAAC,QAAQ,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC7F,IAAI,SAAS,IAAI,CAAC,EAAE,CAAC;YACpB,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;QAChC,CAAC;aAAM,CAAC;YACP,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAChB,CAAC;QAED,OAAO,GAAG,CAAC,EAAE,CAAC;IACf,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,KAAa;QACjC,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAC7C,IAAI,SAAS,EAAE,CAAC;YACf,SAAS,CAAC,OAAO,GAAG,KAAK,CAAC;YAC1B,IAAI,SAAS,CAAC,KAAK,EAAE,CAAC;gBACrB,aAAa,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YAChC,CAAC;YACD,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC/B,CAAC;IACF,CAAC;IAED,WAAW;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,WAAW;QAChB,OAAO,IAAI,CAAC,SAAS,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,KAAa;QAChC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;QACxC,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;QAExE,OAAO;YACN,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,MAAM;YAC1D,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,QAAQ,CAAC,CAAC,MAAM;YACxD,SAAS,EAAE,UAAU,CAAC,SAAS;YAC/B,MAAM,EAAE,UAAU,CAAC,MAAM;YACzB,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,MAAM;SAC1D,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,WAAW,CAAC,KAAa;QACtC,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAC7C,IAAI,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,OAAO;YAAE,OAAO;QAE7C,MAAM,WAAW,GAAG,SAAS,CAAC,MAAM,CAAC,WAAW,IAAI,CAAC,CAAC;QACtD,IAAI,SAAS,CAAC,MAAM,IAAI,WAAW;YAAE,OAAO;QAE5C,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAClC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QAEvC,wCAAwC;QACxC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACxB,IAAI,GAAG,CAAC,MAAM,KAAK,SAAS,IAAI,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,WAAW,CAAC,OAAO,EAAE,IAAI,GAAG,EAAE,CAAC;gBACrF,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC;YACxB,CAAC;QACF,CAAC;QAED,wBAAwB;QACxB,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC;QAC7D,IAAI,MAAM,GAAG,CAAC;YAAE,OAAO;QAEvB,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;QACjC,WAAW,CAAC,MAAM,GAAG,QAAQ,CAAC;QAC9B,SAAS,CAAC,MAAM,EAAE,CAAC;QAEnB,MAAM,SAAS,GAAc;YAC5B,EAAE,EAAE,WAAW,CAAC,EAAE;YAClB,IAAI,EAAE,WAAW,CAAC,IAAI;YACtB,OAAO,EAAE,EAAE;YACX,KAAK,EAAE,WAAW,CAAC,KAAK;YACxB,QAAQ,EAAE,WAAW,CAAC,QAAQ;YAC9B,QAAQ,EAAE,WAAW,CAAC,QAAQ;YAC9B,UAAU,EAAE,WAAW,CAAC,UAAU;YAClC,SAAS,EAAE,WAAW,CAAC,SAAS;YAChC,KAAK,EAAE,WAAW,CAAC,KAAK;YACxB,OAAO,EAAE,WAAW,CAAC,OAAO;YAC5B,GAAG,EAAE,WAAW;YAChB,QAAQ,EAAE,KAAK,IAAI,EAAE;gBACpB,WAAW,CAAC,MAAM,GAAG,WAAW,CAAC;gBACjC,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;gBACtC,IAAI,GAAG,IAAI,CAAC;oBAAE,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;gBAClC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBAChC,IAAI,CAAC;oBAAE,CAAC,CAAC,SAAS,EAAE,CAAC;YACtB,CAAC;YACD,IAAI,EAAE,KAAK,EAAE,KAAY,EAAE,OAAiB,EAAE,EAAE;gBAC/C,WAAW,CAAC,QAAQ,EAAE,CAAC;gBACvB,WAAW,CAAC,KAAK,GAAG,KAAK,CAAC;gBAE1B,IAAI,OAAO,IAAI,WAAW,CAAC,QAAQ,GAAG,WAAW,CAAC,UAAU,EAAE,CAAC;oBAC9D,uBAAuB;oBACvB,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,WAAW,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,CAAC;oBAC1E,WAAW,CAAC,MAAM,GAAG,SAAS,CAAC;oBAC/B,WAAW,CAAC,WAAW,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,OAAO,CAAC,CAAC;gBAC1D,CAAC;qBAAM,CAAC;oBACP,WAAW,CAAC,MAAM,GAAG,QAAQ,CAAC;oBAC9B,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;oBACtC,IAAI,GAAG,IAAI,CAAC;wBAAE,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;oBAClC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;oBAChC,IAAI,CAAC;wBAAE,CAAC,CAAC,MAAM,EAAE,CAAC;gBACnB,CAAC;YACF,CAAC;SACD,CAAC;QAEF,IAAI,CAAC;YACJ,MAAM,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QACpC,CAAC;QAAC,MAAM,CAAC;YACR,mCAAmC;YACnC,IAAI,WAAW,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;gBACrC,WAAW,CAAC,MAAM,GAAG,QAAQ,CAAC;gBAC9B,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;gBACtC,IAAI,GAAG,IAAI,CAAC;oBAAE,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;gBAClC,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBAChC,IAAI,CAAC;oBAAE,CAAC,CAAC,MAAM,EAAE,CAAC;YACnB,CAAC;QACF,CAAC;gBAAS,CAAC;YACV,SAAS,CAAC,MAAM,EAAE,CAAC;QACpB,CAAC;IACF,CAAC;CACD","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 \"@blokjs/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"]}
+//# 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 \"@blokjs/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\t// Get-or-init the per-queue job list. Same pattern as `stats`\n\t\t// below — the previous code used `set-if-absent` then `.get()!`,\n\t\t// but that non-null assertion is what biome flags. Pulling the\n\t\t// reference once and seeding when missing keeps the type exact.\n\t\tlet jobs = this.jobs.get(queue);\n\t\tif (!jobs) {\n\t\t\tjobs = [];\n\t\t\tthis.jobs.set(queue, jobs);\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\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 * 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/adapters/KafkaAdapter.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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 type { WorkerTriggerOpts } from "@blokjs/helper";
+import type { WorkerAdapter, WorkerJob, WorkerQueueStats } from "../WorkerTrigger";
+export interface KafkaConfig {
+    brokers: string[];
+    clientId: string;
+    saslUsername?: string;
+    saslPassword?: string;
+    ssl: boolean;
+}
+export declare class KafkaAdapter implements WorkerAdapter {
+    readonly provider: "kafka";
+    private readonly config;
+    private kafka;
+    private handle;
+    private connected;
+    private stats;
+    constructor(config?: Partial<KafkaConfig>);
+    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>;
+}

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"]}