bunqueue 2.8.53 → 2.8.56

package/dist/domain/types/shard.d.ts

@@ -0,0 +1,4 @@
+import type { DlqEntry } from './dlq';
+export interface ShardOptions {
+    onDlqEvicted?: (entry: DlqEntry) => void;
+}

package/dist/domain/types/shard.js

@@ -0,0 +1 @@
+export {};

package/dist/infrastructure/cloud/cloudAgent.js

@@ -78,6 +78,12 @@ export class CloudAgent {
                 cloudLog.info('Remote commands enabled');
                 const commandContext = {
                     getSnapshot: () => this.getSnapshot(),
+                    triggerBackup: () => {
+                        const trigger = this.serverHandles?.triggerBackup;
+                        if (!trigger)
+                            throw new Error('S3 backup not configured');
+                        return trigger();
+                    },
                 };
                 this.wsSender.setCommandHandler((cmd) => {
                     handleCommand(this.queueManager, cmd, commandContext)

package/dist/infrastructure/cloud/commandHandler.d.ts

@@ -6,46 +6,7 @@
  * All commands are whitelisted — unknown actions are rejected.
  */
 import type { QueueManager } from '../../application/queueManager';
-import type { CloudSnapshot } from './types';
-/** Incoming command from dashboard (fields at top level) */
-export interface CloudCommand {
-    type: 'command';
-    id: string;
-    action: string;
-    queue?: string;
-    jobId?: string;
-    name?: string;
-    schedule?: string;
-    data?: unknown;
-    config?: Record<string, unknown>;
-    graceMs?: number;
-    state?: string;
-    limit?: number;
-    offset?: number;
-    priority?: number;
-    delay?: number;
-    url?: string;
-    events?: string[];
-    secret?: string;
-    webhookId?: string;
-    enabled?: boolean;
-    keepLogs?: number;
-    max?: number;
-    concurrency?: number;
-    sort?: string;
-    search?: string;
-}
-/** Result sent back to dashboard */
-export interface CloudCommandResult {
-    type: 'command_result';
-    id: string;
-    success: boolean;
-    data?: unknown;
-    error?: string;
-}
-/** Optional context for commands that need more than QueueManager */
-export interface CommandContext {
-    getSnapshot?: () => Promise<CloudSnapshot>;
-}
+import type { CloudCommand, CloudCommandResult, CommandContext } from './types/command';
+export type { CloudCommand, CloudCommandResult, CommandContext } from './types/command';
 /** Process a command and return the result */
 export declare function handleCommand(queueManager: QueueManager, cmd: CloudCommand, context?: CommandContext): Promise<CloudCommandResult>;

package/dist/infrastructure/cloud/commandHandler.js

@@ -66,7 +66,7 @@ export async function handleCommand(queueManager, cmd, context) {
         };
     }
     try {
-        const raw = await handler(queueManager, cmd);
+        const raw = await handler(queueManager, cmd, context);
         const data = camelKeys(raw);
         cloudLog.info('Remote command executed', { action: cmd.action, id: cmd.id });
         return { type: 'command_result', id: cmd.id, success: true, data };

package/dist/infrastructure/cloud/commands/integrations.d.ts

@@ -0,0 +1,2 @@
+import type { CloudCommandHandler } from '../types/command';
+export declare const INTEGRATION_COMMANDS: Partial<Record<string, CloudCommandHandler>>;

package/dist/infrastructure/cloud/commands/integrations.js

@@ -0,0 +1,31 @@
+export const INTEGRATION_COMMANDS = {
+    'cron:upsert': (queueManager, command) => {
+        queueManager.removeCron(command.name ?? '');
+        const cron = queueManager.addCron({
+            name: command.name ?? '',
+            jobName: 'default',
+            queue: command.queue ?? '',
+            data: command.data ?? {},
+            schedule: command.schedule,
+        });
+        return { name: cron.name, nextRun: cron.nextRun };
+    },
+    'cron:delete': (queueManager, command) => ({
+        deleted: queueManager.removeCron(command.name ?? ''),
+    }),
+    'webhook:add': (queueManager, command) => {
+        const webhook = queueManager.webhookManager.add(command.url ?? '', command.events ?? [], command.queue ?? undefined, command.secret ?? undefined);
+        return { id: webhook.id, url: webhook.url, events: webhook.events };
+    },
+    'webhook:remove': (queueManager, command) => ({
+        removed: queueManager.webhookManager.remove(command.webhookId ?? ''),
+    }),
+    'webhook:set-enabled': (queueManager, command) => ({
+        updated: queueManager.webhookManager.setEnabled(command.webhookId ?? '', command.enabled ?? true),
+    }),
+    's3:backup': async (_queueManager, _command, context) => {
+        if (!context?.triggerBackup)
+            throw new Error('S3 backup not configured');
+        return await context.triggerBackup();
+    },
+};

package/dist/infrastructure/cloud/commands/jobMapper.d.ts

@@ -0,0 +1,56 @@
+import type { Job } from '../../../domain/types/job';
+/** Map a domain job to the field names expected by the dashboard. */
+export declare function mapCloudCommandJob(job: Job): {
+    id: string;
+    name: string;
+    queueName: string;
+    _queue: string;
+    state: string;
+    _status: string;
+    data: string | undefined;
+    priority: number;
+    timestamp: number;
+    processedOn: number | undefined;
+    finishedOn: number | undefined;
+    runAt: number;
+    failedReason: string | undefined;
+    attemptsMade: number;
+    maxAttempts: number;
+    backoff: number;
+    timeout: number | undefined;
+    ttl: number | undefined;
+    duration: number | undefined;
+    waitTime: number | undefined;
+    totalDuration: number | undefined;
+    progress: number | undefined;
+    progressMessage: string | undefined;
+    customId: string | undefined;
+    uniqueKey: string | undefined;
+    tags: string[] | undefined;
+    groupId: string | undefined;
+    parentId: string | undefined;
+    childrenIds: string[] | undefined;
+    dependsOn: string[] | undefined;
+    childrenCompleted: number | undefined;
+    lastHeartbeat: number | undefined;
+    stallCount: number | undefined;
+    stallTimeout: number | undefined;
+    removeOnComplete: true | undefined;
+    removeOnFail: true | undefined;
+    lifo: true | undefined;
+    backoffConfig: import("../../../domain/types").BackoffConfig | undefined;
+    repeat: import("../../../domain/types").RepeatConfig | undefined;
+    stackTraceLimit: number;
+    keepLogs: number | undefined;
+    sizeLimit: number | undefined;
+    failParentOnFailure: true | undefined;
+    removeDependencyOnFailure: true | undefined;
+    continueParentOnFailure: true | undefined;
+    ignoreDependencyOnFailure: true | undefined;
+    deduplicationTtl: number | undefined;
+    deduplicationExtend: true | undefined;
+    deduplicationReplace: true | undefined;
+    debounceId: string | undefined;
+    debounceTtl: number | undefined;
+    timeline: import("../../../domain/types").JobTimelineEntry[] | undefined;
+};

package/dist/infrastructure/cloud/commands/jobMapper.js

@@ -0,0 +1,72 @@
+/** Derive the dashboard state from persisted job timestamps. */
+function deriveState(job) {
+    if (job.completedAt)
+        return 'completed';
+    if (job.startedAt)
+        return 'active';
+    if (job.runAt > Date.now())
+        return 'delayed';
+    return 'waiting';
+}
+/** Map a domain job to the field names expected by the dashboard. */
+export function mapCloudCommandJob(job) {
+    const data = job.data;
+    const state = deriveState(job);
+    const processTime = job.completedAt && job.startedAt ? job.completedAt - job.startedAt : undefined;
+    return {
+        id: String(job.id),
+        name: job.name,
+        queueName: job.queue,
+        _queue: job.queue,
+        state,
+        _status: state,
+        data: data !== undefined ? JSON.stringify(data) : undefined,
+        priority: job.priority,
+        timestamp: job.createdAt,
+        processedOn: job.startedAt ?? undefined,
+        finishedOn: job.completedAt ?? undefined,
+        runAt: job.runAt,
+        failedReason: state === 'active' && job.attempts > 0
+            ? `Retry ${job.attempts}/${job.maxAttempts}`
+            : undefined,
+        attemptsMade: job.attempts,
+        maxAttempts: job.maxAttempts,
+        backoff: job.backoff,
+        timeout: job.timeout ?? undefined,
+        ttl: job.ttl ?? undefined,
+        duration: processTime,
+        waitTime: job.startedAt ? job.startedAt - job.createdAt : undefined,
+        totalDuration: job.completedAt ? job.completedAt - job.createdAt : undefined,
+        progress: job.progress || undefined,
+        progressMessage: job.progressMessage ?? undefined,
+        customId: job.customId ?? undefined,
+        uniqueKey: job.uniqueKey ?? undefined,
+        tags: job.tags.length > 0 ? job.tags : undefined,
+        groupId: job.groupId ?? undefined,
+        parentId: job.parentId ? String(job.parentId) : undefined,
+        childrenIds: job.childrenIds.length > 0 ? job.childrenIds.map(String) : undefined,
+        dependsOn: job.dependsOn.length > 0 ? job.dependsOn.map(String) : undefined,
+        childrenCompleted: job.childrenCompleted > 0 ? job.childrenCompleted : undefined,
+        lastHeartbeat: job.lastHeartbeat > 0 ? job.lastHeartbeat : undefined,
+        stallCount: job.stallCount > 0 ? job.stallCount : undefined,
+        stallTimeout: job.stallTimeout ?? undefined,
+        removeOnComplete: job.removeOnComplete || undefined,
+        removeOnFail: job.removeOnFail || undefined,
+        lifo: job.lifo || undefined,
+        backoffConfig: job.backoffConfig ?? undefined,
+        repeat: job.repeat ?? undefined,
+        stackTraceLimit: job.stackTraceLimit,
+        keepLogs: job.keepLogs ?? undefined,
+        sizeLimit: job.sizeLimit ?? undefined,
+        failParentOnFailure: job.failParentOnFailure || undefined,
+        removeDependencyOnFailure: job.removeDependencyOnFailure || undefined,
+        continueParentOnFailure: job.continueParentOnFailure || undefined,
+        ignoreDependencyOnFailure: job.ignoreDependencyOnFailure || undefined,
+        deduplicationTtl: job.deduplicationTtl ?? undefined,
+        deduplicationExtend: job.deduplicationExtend || undefined,
+        deduplicationReplace: job.deduplicationReplace || undefined,
+        debounceId: job.debounceId ?? undefined,
+        debounceTtl: job.debounceTtl ?? undefined,
+        timeline: job.timeline.length > 0 ? job.timeline : undefined,
+    };
+}

package/dist/infrastructure/cloud/commands/jobs.d.ts

@@ -0,0 +1,2 @@
+import type { CloudCommandHandler } from '../types/command';
+export declare const JOB_COMMANDS: Partial<Record<string, CloudCommandHandler>>;

package/dist/infrastructure/cloud/commands/jobs.js

@@ -0,0 +1,111 @@
+import { jobId } from '../../../domain/types/job';
+import { mapCloudCommandJob } from './jobMapper';
+export const JOB_COMMANDS = {
+    'job:cancel': async (queueManager, command) => {
+        const ok = await queueManager.cancel(jobId(command.jobId ?? ''));
+        return { cancelled: ok };
+    },
+    'job:promote': async (queueManager, command) => {
+        const ok = await queueManager.promote(jobId(command.jobId ?? ''));
+        return { promoted: ok };
+    },
+    'job:push': async (queueManager, command) => {
+        const job = await queueManager.push(command.queue ?? '', {
+            name: command.name ?? 'default',
+            data: command.data ?? {},
+            priority: command.priority,
+            delay: command.delay,
+        });
+        return { jobId: String(job.id), queue: command.queue };
+    },
+    'job:priority': async (queueManager, command) => {
+        const ok = await queueManager.changePriority(jobId(command.jobId ?? ''), command.priority ?? 0);
+        return { changed: ok };
+    },
+    'job:discard': async (queueManager, command) => {
+        const ok = await queueManager.discard(jobId(command.jobId ?? ''));
+        return { discarded: ok };
+    },
+    'job:delay': async (queueManager, command) => {
+        await queueManager.changeDelay(jobId(command.jobId ?? ''), command.delay ?? 0);
+        return { delayed: true };
+    },
+    'job:updateData': async (queueManager, command) => {
+        const ok = await queueManager.updateJobData(jobId(command.jobId ?? ''), command.data);
+        return { updated: ok };
+    },
+    'job:clearLogs': (queueManager, command) => {
+        queueManager.clearLogs(jobId(command.jobId ?? ''), command.keepLogs);
+        return { cleared: true };
+    },
+    'job:retry': (queueManager, command) => {
+        if (command.queue) {
+            const count = queueManager.retryDlq(command.queue, command.jobId ? jobId(command.jobId) : undefined);
+            return { retried: count };
+        }
+        return { retried: 0 };
+    },
+    'job:logs': (queueManager, command) => ({
+        logs: queueManager.getLogs(jobId(command.jobId ?? '')),
+    }),
+    'job:result': (queueManager, command) => ({
+        result: queueManager.getResult(jobId(command.jobId ?? '')) ?? null,
+    }),
+    'job:list': (queueManager, command) => {
+        const limit = command.limit ?? 50;
+        const offset = command.offset ?? 0;
+        const states = command.state
+            ? command.state.split(',')
+            : ['waiting', 'active', 'delayed', 'completed', 'failed'];
+        const jobs = queueManager.getJobs(command.queue ?? '', {
+            state: states,
+            start: offset,
+            end: offset + limit - 1,
+        });
+        return {
+            jobs: jobs.map(mapCloudCommandJob),
+            total: queueManager.count(command.queue ?? ''),
+            offset,
+            limit,
+        };
+    },
+    'job:get': async (queueManager, command) => {
+        const id = jobId(command.jobId ?? '');
+        const job = await queueManager.getJob(id);
+        if (!job)
+            return { job: null };
+        return {
+            job: {
+                ...mapCloudCommandJob(job),
+                logs: queueManager.getLogs(id),
+                result: queueManager.getResult(id) ?? null,
+            },
+        };
+    },
+    'job:listAll': (queueManager, command) => {
+        const limit = command.limit ?? 50;
+        const offset = command.offset ?? 0;
+        const states = command.state
+            ? command.state.split(',')
+            : ['waiting', 'active', 'delayed', 'completed', 'failed'];
+        const allJobs = [];
+        for (const name of queueManager.listQueues()) {
+            const jobs = queueManager.getJobs(name, { state: states, start: 0, end: 999 });
+            for (const job of jobs)
+                allJobs.push(mapCloudCommandJob(job));
+        }
+        allJobs.sort((a, b) => b.timestamp - a.timestamp);
+        return {
+            jobs: allJobs.slice(offset, offset + limit),
+            total: allJobs.length,
+            offset,
+            limit,
+        };
+    },
+    'dlq:retry': (queueManager, command) => ({
+        retried: queueManager.retryDlq(command.queue ?? '', command.jobId ? jobId(command.jobId) : undefined),
+    }),
+    'dlq:purge': (queueManager, command) => ({
+        purged: queueManager.purgeDlq(command.queue ?? ''),
+    }),
+};

package/dist/infrastructure/cloud/commands/queues.d.ts

@@ -0,0 +1,2 @@
+import type { CloudCommandHandler } from '../types/command';
+export declare const QUEUE_COMMANDS: Partial<Record<string, CloudCommandHandler>>;

package/dist/infrastructure/cloud/commands/queues.js

@@ -0,0 +1,126 @@
+import { mapCloudCommandJob } from './jobMapper';
+export const QUEUE_COMMANDS = {
+    'queue:pause': (queueManager, command) => {
+        queueManager.pause(command.queue ?? '');
+        return { queue: command.queue, paused: true };
+    },
+    'queue:resume': (queueManager, command) => {
+        queueManager.resume(command.queue ?? '');
+        return { queue: command.queue, paused: false };
+    },
+    'queue:drain': (queueManager, command) => {
+        const count = queueManager.drain(command.queue ?? '');
+        return { queue: command.queue, drained: count };
+    },
+    'queue:clean': (queueManager, command) => {
+        const ids = queueManager.clean(command.queue ?? '', command.graceMs ?? 0, command.state, command.limit);
+        return { queue: command.queue, cleaned: ids.length, ids };
+    },
+    'queue:obliterate': (queueManager, command) => {
+        queueManager.obliterate(command.queue ?? '');
+        return { queue: command.queue, obliterated: true };
+    },
+    'queue:promoteAll': async (queueManager, command) => {
+        const limit = command.limit ?? 1000;
+        const jobs = queueManager.getJobs(command.queue ?? '', {
+            state: ['delayed'],
+            start: 0,
+            end: limit - 1,
+        });
+        let promoted = 0;
+        for (const job of jobs) {
+            try {
+                await queueManager.promote(job.id);
+                promoted++;
+            }
+            catch {
+                // Skip jobs that can no longer be promoted.
+            }
+        }
+        return { queue: command.queue, promoted };
+    },
+    'queue:retryCompleted': (queueManager, command) => {
+        const count = queueManager.retryCompleted(command.queue ?? '');
+        return { queue: command.queue, retried: count };
+    },
+    'queue:rateLimit': (queueManager, command) => {
+        queueManager.setRateLimit(command.queue ?? '', command.max ?? 100);
+        return { queue: command.queue, rateLimit: command.max ?? 100 };
+    },
+    'queue:clearRateLimit': (queueManager, command) => {
+        queueManager.clearRateLimit(command.queue ?? '');
+        return { queue: command.queue, rateLimit: null };
+    },
+    'queue:concurrency': (queueManager, command) => {
+        queueManager.setConcurrency(command.queue ?? '', command.concurrency ?? 10);
+        return { queue: command.queue, concurrency: command.concurrency ?? 10 };
+    },
+    'queue:clearConcurrency': (queueManager, command) => {
+        queueManager.clearConcurrency(command.queue ?? '');
+        return { queue: command.queue, concurrency: null };
+    },
+    'queue:stallConfig': (queueManager, command) => {
+        queueManager.setStallConfig(command.queue ?? '', command.config ?? {});
+        return { queue: command.queue, stallConfig: command.config };
+    },
+    'queue:dlqConfig': (queueManager, command) => {
+        queueManager.setDlqConfig(command.queue ?? '', command.config ?? {});
+        return { queue: command.queue, dlqConfig: command.config };
+    },
+    'queue:detail': (queueManager, command) => {
+        const queue = command.queue ?? '';
+        const counts = queueManager.getQueueJobCounts(queue);
+        const paused = queueManager.isPaused(queue);
+        const stallConfig = queueManager.getStallConfig(queue);
+        const dlqConfig = queueManager.getDlqConfig(queue);
+        const dlqEntries = queueManager.getDlqEntries(queue).slice(0, 50);
+        const jobs = queueManager.getJobs(queue, {
+            state: ['waiting', 'active', 'delayed', 'completed', 'failed'],
+            start: 0,
+            end: 49,
+        });
+        return {
+            queue,
+            paused,
+            counts,
+            stallConfig: {
+                enabled: stallConfig.enabled,
+                stallInterval: stallConfig.stallInterval,
+                maxStalls: stallConfig.maxStalls,
+            },
+            dlqConfig: { maxRetries: dlqConfig.maxAutoRetries, maxAge: dlqConfig.maxAge ?? 0 },
+            dlqEntries: dlqEntries.map((entry) => ({
+                jobId: String(entry.job.id),
+                reason: entry.reason,
+                error: entry.error,
+                enteredAt: entry.enteredAt,
+                retryCount: entry.retryCount,
+            })),
+            jobs: jobs.map(mapCloudCommandJob),
+        };
+    },
+    'queue:list': (queueManager) => {
+        const queueNames = queueManager.listQueues();
+        const countsByQueue = queueManager.getAllQueueJobCounts();
+        const queues = queueNames.flatMap((name) => {
+            const counts = countsByQueue.get(name);
+            if (!counts)
+                return [];
+            return {
+                name,
+                waiting: counts.waiting,
+                prioritized: counts.prioritized,
+                delayed: counts.delayed,
+                active: counts.active,
+                completed: counts.completed,
+                failed: counts.failed,
+                'waiting-children': counts['waiting-children'],
+                paused: queueManager.isPaused(name),
+                totalCompleted: counts.totalCompleted,
+                totalFailed: counts.totalFailed,
+            };
+        });
+        return { queues };
+    },
+    'stats:refresh': (queueManager) => queueManager.getStats(),
+};

package/dist/infrastructure/cloud/commands.d.ts

@@ -1,10 +1,3 @@
-/**
- * Cloud Command Definitions
- * Whitelisted commands that the dashboard can execute via WebSocket.
- */
-import type { QueueManager } from '../../application/queueManager';
-import type { CloudCommand } from './commandHandler';
-type Handler = (qm: QueueManager, cmd: CloudCommand) => unknown;
-/** All whitelisted commands */
-export declare const COMMANDS: Partial<Record<string, Handler>>;
-export {};
+/** Whitelisted commands that the cloud dashboard may execute. */
+import type { CloudCommandHandler } from './types/command';
+export declare const COMMANDS: Partial<Record<string, CloudCommandHandler>>;