bunqueue 2.8.53 → 2.8.56

package/dist/infrastructure/server/ws/subscriptions.js

@@ -0,0 +1,39 @@
+import { errorResponse } from '../protocol';
+import { VALID_WS_PATTERNS } from './constants';
+export function handleWsSubscribe(websocket, command) {
+    const events = command.events;
+    if (!Array.isArray(events) || events.length === 0) {
+        websocket.send(errorResponse('events must be a non-empty array', command.reqId));
+        return;
+    }
+    const invalid = events.filter((event) => !VALID_WS_PATTERNS.has(event));
+    if (invalid.length > 0) {
+        websocket.send(errorResponse(`Invalid: ${invalid.join(', ')}`, command.reqId));
+        return;
+    }
+    websocket.data.subscriptions ??= new Set();
+    for (const event of events)
+        websocket.data.subscriptions.add(event);
+    websocket.send(JSON.stringify({
+        ok: true,
+        subscribed: [...websocket.data.subscriptions],
+        reqId: command.reqId,
+    }));
+}
+export function handleWsUnsubscribe(websocket, command) {
+    if (!websocket.data.subscriptions) {
+        websocket.send(JSON.stringify({ ok: true, subscribed: [], reqId: command.reqId }));
+        return;
+    }
+    const events = command.events;
+    if (!Array.isArray(events) || events.length === 0)
+        websocket.data.subscriptions.clear();
+    else
+        for (const event of events)
+            websocket.data.subscriptions.delete(event);
+    websocket.send(JSON.stringify({
+        ok: true,
+        subscribed: [...websocket.data.subscriptions],
+        reqId: command.reqId,
+    }));
+}

package/dist/infrastructure/server/wsHandler.d.ts

@@ -15,14 +15,8 @@ import type { ServerWebSocket } from 'bun';
 import type { QueueManager } from '../../application/queueManager';
 import type { JobEvent } from '../../domain/types/queue';
 import { type HandlerContext } from './handler';
-/** WebSocket client data */
-export interface WsData {
-    id: string;
-    authenticated: boolean;
-    queueFilter: string | null;
-    /** Subscribed patterns. Null = legacy mode */
-    subscriptions: Set<string> | null;
-}
+import type { WsData } from './types/ws';
+export type { WsData } from './types/ws';
 export declare class WsHandler {
     private readonly clients;
     private statsInterval;
@@ -51,7 +45,5 @@ export declare class WsHandler {
     onOpen(ws: ServerWebSocket<WsData>): void;
     onClose(ws: ServerWebSocket<WsData>): void;
     onMessage(ws: ServerWebSocket<WsData>, message: string | Buffer, ctx: HandlerContext): Promise<void>;
-    private handleSubscribe;
-    private handleUnsubscribe;
     getClients(): Map<string, ServerWebSocket<WsData>>;
 }

package/dist/infrastructure/server/wsHandler.js

@@ -13,159 +13,10 @@
  */
 import { handleCommand } from './handler';
 import { parseCommand, serializeResponse, errorResponse } from './protocol';
-import { throughputTracker } from '../../application/throughputTracker';
 import { QueueCountsScheduler } from './queueCountsScheduler';
-const textDecoder = new TextDecoder();
-/** Old eventType → new event name */
-const EVENT_MAP = {
-    pushed: 'job:pushed',
-    pulled: 'job:active',
-    completed: 'job:completed',
-    failed: 'job:failed',
-    progress: 'job:progress',
-    stalled: 'job:stalled',
-    removed: 'job:removed',
-    delayed: 'job:delayed',
-    duplicated: 'job:duplicated',
-    retried: 'job:retried',
-    'waiting-children': 'job:waiting-children',
-    drained: 'queue:drained',
-};
-/** All valid subscription patterns (events + wildcards) */
-const VALID_PATTERNS = new Set([
-    '*',
-    // Job lifecycle (22)
-    'job:pushed',
-    'job:active',
-    'job:completed',
-    'job:failed',
-    'job:removed',
-    'job:promoted',
-    'job:progress',
-    'job:delayed',
-    'job:stalled',
-    'job:retried',
-    'job:discarded',
-    'job:priority-changed',
-    'job:data-updated',
-    'job:delay-changed',
-    'job:timeout',
-    'job:lock-expired',
-    'job:deduplicated',
-    'job:waiting-children',
-    'job:dependencies-resolved',
-    'job:moved-to-delayed',
-    'job:expired',
-    'job:*',
-    // Queue (9)
-    'queue:created',
-    'queue:removed',
-    'queue:paused',
-    'queue:resumed',
-    'queue:drained',
-    'queue:cleaned',
-    'queue:obliterated',
-    'queue:counts',
-    'queue:idle',
-    'queue:threshold',
-    'queue:*',
-    // DLQ (6)
-    'dlq:added',
-    'dlq:retried',
-    'dlq:retry-all',
-    'dlq:purged',
-    'dlq:auto-retried',
-    'dlq:expired',
-    'dlq:*',
-    // Flow (2)
-    'flow:completed',
-    'flow:failed',
-    'flow:*',
-    // Cron (6)
-    'cron:created',
-    'cron:updated',
-    'cron:deleted',
-    'cron:fired',
-    'cron:missed',
-    'cron:skipped',
-    'cron:*',
-    // Worker (7)
-    'worker:connected',
-    'worker:disconnected',
-    'worker:heartbeat',
-    'worker:idle',
-    'worker:removed-stale',
-    'worker:overloaded',
-    'worker:error',
-    'worker:*',
-    // Rate limit & concurrency (7)
-    'ratelimit:set',
-    'ratelimit:cleared',
-    'ratelimit:hit',
-    'ratelimit:rejected',
-    'concurrency:set',
-    'concurrency:cleared',
-    'concurrency:rejected',
-    'ratelimit:*',
-    'concurrency:*',
-    // Webhook (6)
-    'webhook:added',
-    'webhook:removed',
-    'webhook:fired',
-    'webhook:failed',
-    'webhook:enabled',
-    'webhook:disabled',
-    'webhook:*',
-    // Batch (2)
-    'batch:pushed',
-    'batch:pulled',
-    'batch:*',
-    // Client (2)
-    'client:connected',
-    'client:disconnected',
-    'client:*',
-    // Auth (1)
-    'auth:failed',
-    'auth:*',
-    // Cleanup (2)
-    'cleanup:orphans-removed',
-    'cleanup:stale-deps-removed',
-    'cleanup:*',
-    // System (10)
-    'health:status',
-    'health:*',
-    'stats:snapshot',
-    'stats:*',
-    'storage:status',
-    'storage:backup-started',
-    'storage:backup-completed',
-    'storage:backup-failed',
-    'storage:size-warning',
-    'storage:*',
-    'server:started',
-    'server:shutdown',
-    'server:recovered',
-    'server:memory-warning',
-    'server:*',
-    // Memory (1)
-    'memory:compacted',
-    'memory:*',
-    // Config (2)
-    'config:stall-changed',
-    'config:dlq-changed',
-    'config:*',
-]);
-/** Check if event matches any subscription pattern */
-function matches(event, subs) {
-    if (subs.has('*') || subs.has(event))
-        return true;
-    const prefix = event.split(':')[0];
-    return subs.has(`${prefix}:*`);
-}
-/** Max concurrent WebSocket connections */
-const MAX_WS_CLIENTS = 1000;
-/** Backpressure threshold — skip sends when buffered data exceeds 1MB */
-const BACKPRESSURE_BYTES = 1024 * 1024;
+import { matchesWsSubscription, MAX_WS_CLIENTS, textDecoder, WS_BACKPRESSURE_BYTES, WS_EVENT_MAP, } from './ws/constants';
+import { buildHealthSnapshot, buildStatsSnapshot, buildStorageSnapshot } from './ws/snapshots';
+import { handleWsSubscribe, handleWsUnsubscribe } from './ws/subscriptions';
 export class WsHandler {
     clients = new Map();
     statsInterval = null;
@@ -184,7 +35,7 @@ export class WsHandler {
     safeSend(ws, data) {
         try {
             const buffered = typeof ws.getBufferedAmount === 'function' ? ws.getBufferedAmount() : 0;
-            if (buffered > BACKPRESSURE_BYTES) {
+            if (buffered > WS_BACKPRESSURE_BYTES) {
                 this.droppedMessages++;
                 return true; // alive but slow — skip this message, don't disconnect
             }
@@ -240,58 +91,13 @@ export class WsHandler {
     }
     // ── Periodic broadcasts ──────────────────────────────────
     broadcastStats(qm) {
-        const stats = qm.getStats();
-        const rates = throughputTracker.getRates();
-        const perQueue = qm.getPerQueueStats();
-        const workerStats = qm.workerManager.getStats();
-        const crons = qm.listCrons();
-        const queues = {};
-        for (const [name, s] of perQueue) {
-            queues[name] = {
-                waiting: s.waiting ?? 0,
-                active: s.active ?? 0,
-                delayed: s.delayed ?? 0,
-                dlq: s.dlq ?? 0,
-                paused: qm.isPaused(name),
-            };
-        }
-        this.emit('stats:snapshot', {
-            waiting: stats.waiting,
-            active: stats.active,
-            delayed: stats.delayed,
-            completed: stats.completed,
-            dlq: stats.dlq,
-            totalPushed: Number(stats.totalPushed),
-            totalCompleted: Number(stats.totalCompleted),
-            totalFailed: Number(stats.totalFailed),
-            pushPerSec: rates.pushPerSec,
-            pullPerSec: rates.pullPerSec,
-            uptime: stats.uptime,
-            queues,
-            workers: { total: workerStats.total, active: workerStats.active },
-            cronJobs: crons.length,
-        });
+        this.emit('stats:snapshot', buildStatsSnapshot(qm));
     }
     broadcastHealth(qm) {
-        const mem = process.memoryUsage();
-        const storage = qm.getStorageStatus();
-        this.emit('health:status', {
-            ok: !storage.diskFull,
-            uptime: Math.floor(process.uptime()),
-            memory: {
-                rss: Math.round(mem.rss / 1024 / 1024),
-                heapUsed: Math.round(mem.heapUsed / 1024 / 1024),
-            },
-            connections: { ws: this.clients.size },
-        });
+        this.emit('health:status', buildHealthSnapshot(qm, this.clients.size));
     }
     broadcastStorage(qm) {
-        const memStats = qm.getMemoryStats();
-        const storage = qm.getStorageStatus();
-        this.emit('storage:status', {
-            collections: memStats,
-            diskFull: storage.diskFull,
-        });
+        this.emit('storage:status', buildStorageSnapshot(qm));
     }
     // ── Event broadcasting ───────────────────────────────────
     /** Emit a dashboard event to subscribed clients */
@@ -305,7 +111,7 @@ export class WsHandler {
         let msg = null;
         const dead = [];
         for (const [id, ws] of this.clients) {
-            if (ws.data.subscriptions && matches(event, ws.data.subscriptions)) {
+            if (ws.data.subscriptions && matchesWsSubscription(event, ws.data.subscriptions)) {
                 msg ??= JSON.stringify({ event, ts: Date.now(), data });
                 if (!this.safeSend(ws, msg))
                     dead.push(id);
@@ -318,7 +124,7 @@ export class WsHandler {
     broadcast(event) {
         if (this.clients.size === 0)
             return;
-        const dashEvent = EVENT_MAP[event.eventType] ?? `job:${event.eventType}`;
+        const dashEvent = WS_EVENT_MAP[event.eventType] ?? `job:${event.eventType}`;
         // Build new-format data
         const eventData = {
             queue: event.queue,
@@ -343,7 +149,7 @@ export class WsHandler {
                 if (!this.safeSend(ws, legacyMsg))
                     dead.push(id);
             }
-            else if (matches(dashEvent, ws.data.subscriptions)) {
+            else if (matchesWsSubscription(dashEvent, ws.data.subscriptions)) {
                 newMsg ??= JSON.stringify({ event: dashEvent, ts: event.timestamp, data: eventData });
                 if (!this.safeSend(ws, newMsg))
                     dead.push(id);
@@ -369,11 +175,11 @@ export class WsHandler {
         try {
             const raw = JSON.parse(text);
             if (raw['cmd'] === 'Subscribe') {
-                this.handleSubscribe(ws, raw);
+                handleWsSubscribe(ws, raw);
                 return;
             }
             if (raw['cmd'] === 'Unsubscribe') {
-                this.handleUnsubscribe(ws, raw);
+                handleWsUnsubscribe(ws, raw);
                 return;
             }
         }
@@ -397,37 +203,6 @@ export class WsHandler {
             ws.send(errorResponse(msg, cmd.reqId));
         }
     }
-    handleSubscribe(ws, cmd) {
-        const events = cmd.events;
-        if (!Array.isArray(events) || events.length === 0) {
-            ws.send(errorResponse('events must be a non-empty array', cmd.reqId));
-            return;
-        }
-        const invalid = events.filter((e) => !VALID_PATTERNS.has(e));
-        if (invalid.length > 0) {
-            ws.send(errorResponse(`Invalid: ${invalid.join(', ')}`, cmd.reqId));
-            return;
-        }
-        ws.data.subscriptions ??= new Set();
-        for (const e of events)
-            ws.data.subscriptions.add(e);
-        ws.send(JSON.stringify({ ok: true, subscribed: [...ws.data.subscriptions], reqId: cmd.reqId }));
-    }
-    handleUnsubscribe(ws, cmd) {
-        if (!ws.data.subscriptions) {
-            ws.send(JSON.stringify({ ok: true, subscribed: [], reqId: cmd.reqId }));
-            return;
-        }
-        const events = cmd.events;
-        if (!Array.isArray(events) || events.length === 0) {
-            ws.data.subscriptions.clear();
-        }
-        else {
-            for (const e of events)
-                ws.data.subscriptions.delete(e);
-        }
-        ws.send(JSON.stringify({ ok: true, subscribed: [...ws.data.subscriptions], reqId: cmd.reqId }));
-    }
     getClients() {
         return this.clients;
     }