@supaproxy/bullmq 1.0.0

package/dist/BullMqService.d.ts

@@ -0,0 +1,28 @@
+import type { QueueService, QueueJobCounts, FailedJob, LifecycleHandler } from '@supaproxy/core/ports/queue';
+export declare class BullMqService implements QueueService {
+    private readonly redisHost;
+    private readonly redisPort;
+    private readonly lifecycleQueue;
+    private readonly coldMessageQueue;
+    private readonly statsQueue;
+    private readonly queues;
+    private lifecycleWorker;
+    private coldMessageWorker;
+    private statsWorker;
+    constructor(redisHost: string, redisPort: number);
+    addColdMessage(data: {
+        conversationId: string;
+        consumerType: string;
+        channel: string;
+        externalThreadId: string;
+    }): Promise<void>;
+    addStatsJob(conversationId: string): Promise<void>;
+    getJobCounts(queueName: string): Promise<QueueJobCounts>;
+    getFailedJobs(queueName: string, limit: number): Promise<FailedJob[]>;
+    retryAllFailed(queueName: string): Promise<number>;
+    drainQueue(queueName: string): Promise<void>;
+    listQueueNames(): string[];
+    queueExists(name: string): boolean;
+    startWorkers(handler: LifecycleHandler): Promise<void>;
+    stopWorkers(): Promise<void>;
+}

package/dist/BullMqService.js

@@ -0,0 +1,110 @@
+import { Queue, Worker } from 'bullmq';
+import { QUEUE_LIFECYCLE, QUEUE_COLD_MESSAGES, QUEUE_CONVERSATION_STATS, LIFECYCLE_SCAN_INTERVAL_MS, COLD_MESSAGE_CONCURRENCY, STATS_WORKER_CONCURRENCY } from '@supaproxy/core/defaults';
+import pino from 'pino';
+const log = pino({ name: 'bullmq-service' });
+export class BullMqService {
+    redisHost;
+    redisPort;
+    lifecycleQueue;
+    coldMessageQueue;
+    statsQueue;
+    queues;
+    lifecycleWorker = null;
+    coldMessageWorker = null;
+    statsWorker = null;
+    constructor(redisHost, redisPort) {
+        this.redisHost = redisHost;
+        this.redisPort = redisPort;
+        const connection = { host: this.redisHost, port: this.redisPort };
+        this.lifecycleQueue = new Queue(QUEUE_LIFECYCLE, { connection });
+        this.coldMessageQueue = new Queue(QUEUE_COLD_MESSAGES, { connection });
+        this.statsQueue = new Queue(QUEUE_CONVERSATION_STATS, { connection });
+        this.queues = {
+            [QUEUE_LIFECYCLE]: this.lifecycleQueue,
+            [QUEUE_COLD_MESSAGES]: this.coldMessageQueue,
+            [QUEUE_CONVERSATION_STATS]: this.statsQueue,
+        };
+    }
+    async addColdMessage(data) {
+        await this.coldMessageQueue.add('send-cold-message', data);
+    }
+    async addStatsJob(conversationId) {
+        await this.statsQueue.add('generate-stats', { conversationId });
+    }
+    async getJobCounts(queueName) {
+        const queue = this.queues[queueName];
+        if (!queue)
+            return { waiting: 0, active: 0, completed: 0, failed: 0, delayed: 0 };
+        const counts = await queue.getJobCounts();
+        return {
+            waiting: counts.waiting ?? 0,
+            active: counts.active ?? 0,
+            completed: counts.completed ?? 0,
+            failed: counts.failed ?? 0,
+            delayed: counts.delayed ?? 0,
+        };
+    }
+    async getFailedJobs(queueName, limit) {
+        const queue = this.queues[queueName];
+        if (!queue)
+            return [];
+        const failed = await queue.getFailed(0, limit);
+        return failed.map(j => ({
+            id: j.id,
+            data: j.data,
+            failedReason: j.failedReason,
+            timestamp: j.timestamp,
+            attemptsMade: j.attemptsMade,
+        }));
+    }
+    async retryAllFailed(queueName) {
+        const queue = this.queues[queueName];
+        if (!queue)
+            return 0;
+        const failed = await queue.getFailed(0, 100);
+        let retried = 0;
+        for (const job of failed) {
+            await job.retry();
+            retried++;
+        }
+        return retried;
+    }
+    async drainQueue(queueName) {
+        const queue = this.queues[queueName];
+        if (queue)
+            await queue.drain();
+    }
+    listQueueNames() {
+        return Object.keys(this.queues);
+    }
+    queueExists(name) {
+        return name in this.queues;
+    }
+    async startWorkers(handler) {
+        const connection = { host: this.redisHost, port: this.redisPort };
+        this.lifecycleWorker = new Worker(QUEUE_LIFECYCLE, async () => {
+            try {
+                await handler.runLifecycleScan();
+            }
+            catch (err) {
+                log.error({ error: err.message }, 'Lifecycle scan failed');
+            }
+        }, { connection });
+        this.coldMessageWorker = new Worker(QUEUE_COLD_MESSAGES, async (job) => {
+            await handler.sendColdMessage(job.data);
+        }, { connection, concurrency: COLD_MESSAGE_CONCURRENCY });
+        this.statsWorker = new Worker(QUEUE_CONVERSATION_STATS, async (job) => {
+            await handler.generateStats(job.data.conversationId);
+        }, { connection, concurrency: STATS_WORKER_CONCURRENCY });
+        this.lifecycleWorker.on('failed', (job, err) => log.error({ job: job?.id, error: err.message }, 'Lifecycle job failed'));
+        this.coldMessageWorker.on('failed', (job, err) => log.error({ job: job?.id, error: err.message }, 'Cold message job failed'));
+        this.statsWorker.on('failed', (job, err) => log.error({ job: job?.id, error: err.message }, 'Stats job failed'));
+        await this.lifecycleQueue.upsertJobScheduler('scan', { every: LIFECYCLE_SCAN_INTERVAL_MS }, { name: 'lifecycle-scan' });
+        log.info(`BullMQ workers started (scan every ${LIFECYCLE_SCAN_INTERVAL_MS / 1000}s, ${COLD_MESSAGE_CONCURRENCY} cold message workers, ${STATS_WORKER_CONCURRENCY} stats workers)`);
+    }
+    async stopWorkers() {
+        await this.lifecycleWorker?.close();
+        await this.coldMessageWorker?.close();
+        await this.statsWorker?.close();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { QueueService } from '@supaproxy/core/ports/queue';
+export declare function createBullMqQueue(redisHost: string, redisPort: number): QueueService;
+export { BullMqService } from './BullMqService.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+import { BullMqService } from './BullMqService.js';
+export function createBullMqQueue(redisHost, redisPort) {
+    return new BullMqService(redisHost, redisPort);
+}
+export { BullMqService } from './BullMqService.js';

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@supaproxy/bullmq",
+  "version": "1.0.0",
+  "description": "BullMQ queue adapter for SupaProxy: job queues, workers, and lifecycle scheduling",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@supaproxy/core": ">=1.0.0"
+  },
+  "dependencies": {
+    "bullmq": "^5.74.1",
+    "pino": "^9.6.0"
+  },
+  "devDependencies": {
+    "@supaproxy/core": "^1.0.0",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0",
+    "vitest": "^3.1.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NumstackPtyLtd/supaproxy-bullmq.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "pnpm@9.15.0",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "lint": "tsc --noEmit"
+  }
+}