bunqueue 2.8.53 → 2.8.56

package/dist/infrastructure/server/handler-routes/monitoring.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from '../../../domain/types/command';
+import type { Response } from '../../../domain/types/response';
+import type { HandlerContext } from '../types';
+export declare function routeMonitoringCommand(command: Command, context: HandlerContext, requestId?: string): Response | null;
+export declare function routeDashboardCommand(command: Command, context: HandlerContext, requestId?: string): Response | null;

package/dist/infrastructure/server/handler-routes/monitoring.js

@@ -0,0 +1,65 @@
+import { handleDashboardOverview, handleDashboardQueue, handleDashboardQueues, } from '../handlers/dashboard';
+import { handleMetrics, handleQueueMetrics, handleStats, handleStorageStatus, handleTrimEvents, } from '../handlers/management';
+import { handleAddLog, handleAddWebhook, handleClearLogs, handleCompactMemory, handleGetLogs, handleHeartbeat, handleHello, handleJobHeartbeat, handleJobHeartbeatBatch, handleListWebhooks, handleListWorkers, handlePing, handlePrometheus, handleRegisterWorker, handleRemoveWebhook, handleSetWebhookEnabled, handleUnregisterWorker, } from '../handlers/monitoring';
+export function routeMonitoringCommand(command, context, requestId) {
+    switch (command.cmd) {
+        case 'Stats':
+            return handleStats(context, requestId);
+        case 'Metrics':
+            return command.queue !== undefined || command.type !== undefined
+                ? handleQueueMetrics(command, context, requestId)
+                : handleMetrics(context, requestId);
+        case 'TrimEvents':
+            return handleTrimEvents(command, context, requestId);
+        case 'Prometheus':
+            return handlePrometheus(command, context, requestId);
+        case 'AddLog':
+            return handleAddLog(command, context, requestId);
+        case 'GetLogs':
+            return handleGetLogs(command, context, requestId);
+        case 'Heartbeat':
+            return handleHeartbeat(command, context, requestId);
+        case 'JobHeartbeat':
+            return handleJobHeartbeat(command, context, requestId);
+        case 'JobHeartbeatB':
+            return handleJobHeartbeatBatch(command, context, requestId);
+        case 'Ping':
+            return handlePing(command, context, requestId);
+        case 'Hello':
+            return handleHello(command, context, requestId);
+        case 'RegisterWorker':
+            return handleRegisterWorker(command, context, requestId);
+        case 'UnregisterWorker':
+            return handleUnregisterWorker(command, context, requestId);
+        case 'ListWorkers':
+            return handleListWorkers(command, context, requestId);
+        case 'AddWebhook':
+            return handleAddWebhook(command, context, requestId);
+        case 'RemoveWebhook':
+            return handleRemoveWebhook(command, context, requestId);
+        case 'ListWebhooks':
+            return handleListWebhooks(command, context, requestId);
+        case 'StorageStatus':
+            return handleStorageStatus(command, context, requestId);
+        case 'ClearLogs':
+            return handleClearLogs(command, context, requestId);
+        case 'SetWebhookEnabled':
+            return handleSetWebhookEnabled(command, context, requestId);
+        case 'CompactMemory':
+            return handleCompactMemory(command, context, requestId);
+        default:
+            return null;
+    }
+}
+export function routeDashboardCommand(command, context, requestId) {
+    switch (command.cmd) {
+        case 'DashboardOverview':
+            return handleDashboardOverview(command, context, requestId);
+        case 'DashboardQueues':
+            return handleDashboardQueues(command, context, requestId);
+        case 'DashboardQueue':
+            return handleDashboardQueue(command, context, requestId);
+        default:
+            return null;
+    }
+}

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

@@ -1,26 +1,3 @@
-/**
- * Handler Routes - Command routing by category
- */
-import type { Command } from '../../domain/types/command';
-import type { Response } from '../../domain/types/response';
-import type { HandlerContext } from './types';
-/** Route core commands (PUSH, PULL, ACK, FAIL) */
-export declare function routeCoreCommand(cmd: Command, ctx: HandlerContext, reqId?: string): Promise<Response | null>;
-/** Route query commands */
-export declare function routeQueryCommand(cmd: Command, ctx: HandlerContext, reqId?: string): Promise<Response | null>;
-/** Route management commands */
-export declare function routeManagementCommand(cmd: Command, ctx: HandlerContext, reqId?: string): Promise<Response | null>;
-/** Route queue control commands */
-export declare function routeQueueControlCommand(cmd: Command, ctx: HandlerContext, reqId?: string): Response | null;
-/** Route DLQ commands */
-export declare function routeDlqCommand(cmd: Command, ctx: HandlerContext, reqId?: string): Response | null;
-/** Route rate limit commands */
-export declare function routeRateLimitCommand(cmd: Command, ctx: HandlerContext, reqId?: string): Response | null;
-/** Route cron commands */
-export declare function routeCronCommand(cmd: Command, ctx: HandlerContext, reqId?: string): Response | null;
-/** Route config commands (stall/DLQ config) */
-export declare function routeConfigCommand(cmd: Command, ctx: HandlerContext, reqId?: string): Response | null;
-/** Route monitoring commands */
-export declare function routeMonitoringCommand(cmd: Command, ctx: HandlerContext, reqId?: string): Response | null;
-/** Route dashboard commands */
-export declare function routeDashboardCommand(cmd: Command, ctx: HandlerContext, reqId?: string): Response | null;
+export { routeConfigCommand, routeCronCommand, routeDlqCommand, routeQueueControlCommand, routeRateLimitCommand, } from './handler-routes/control';
+export { routeCoreCommand, routeManagementCommand, routeQueryCommand, } from './handler-routes/jobs';
+export { routeDashboardCommand, routeMonitoringCommand, } from './handler-routes/monitoring';

package/dist/infrastructure/server/handlerRoutes.js

@@ -1,257 +1,3 @@
-/**
- * Handler Routes - Command routing by category
- */
-// Import handlers
-import { handlePush, handlePushBatch, handlePull, handlePullBatch, handleAck, handleAckBatch, handleFail, } from './handlers/core';
-import { handlePushFlow } from './handlers/flow';
-import { handleGetJob, handleGetState, handleGetResult, handleGetJobCounts, handleGetCountsPerPriority, handleGetJobByCustomId, handleGetJobs, handleGetChildrenValues, } from './handlers/query';
-import { handleCancel, handleProgress, handleGetProgress, handlePause, handleResume, handleDrain, handleStats, handleMetrics, handleStorageStatus, } from './handlers/management';
-import { handleDlq, handleRetryDlq, handlePurgeDlq, handleRetryCompleted } from './handlers/dlq';
-import { handleCron, handleCronGet, handleCronDelete, handleCronList } from './handlers/cron';
-import { handleUpdate, handleUpdateParent, handleChangePriority, handlePromote, handleMoveToDelayed, handleDiscard, handleWaitJob, handleIsPaused, handleObliterate, handleListQueues, handleClean, handleCount, handleRateLimit, handleRateLimitClear, handleSetConcurrency, handleClearConcurrency, handleChangeDelay, handleMoveToWait, handlePromoteJobs, handleSetStallConfig, handleGetStallConfig, handleSetDlqConfig, handleGetDlqConfig, handleGetFailedChildrenValues, handleGetIgnoredChildrenFailures, handleRemoveChildDependency, handleRemoveUnprocessedChildren, } from './handlers/advanced';
-import { handleDashboardOverview, handleDashboardQueues, handleDashboardQueue, } from './handlers/dashboard';
-import { handleAddLog, handleGetLogs, handleHeartbeat, handleJobHeartbeat, handleJobHeartbeatBatch, handlePing, handleHello, handleRegisterWorker, handleUnregisterWorker, handleListWorkers, handleAddWebhook, handleRemoveWebhook, handleListWebhooks, handlePrometheus, handleClearLogs, handleExtendLock, handleExtendLocks, handleSetWebhookEnabled, handleCompactMemory, } from './handlers/monitoring';
-/** Route core commands (PUSH, PULL, ACK, FAIL) */
-export async function routeCoreCommand(cmd, ctx, reqId) {
-    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-    switch (cmd.cmd) {
-        case 'PUSH':
-            return handlePush(cmd, ctx, reqId);
-        case 'PUSHB':
-            return handlePushBatch(cmd, ctx, reqId);
-        case 'PUSHF':
-            return handlePushFlow(cmd, ctx, reqId);
-        case 'PULL':
-            return handlePull(cmd, ctx, reqId);
-        case 'PULLB':
-            return handlePullBatch(cmd, ctx, reqId);
-        case 'ACK':
-            return handleAck(cmd, ctx, reqId);
-        case 'ACKB':
-            return handleAckBatch(cmd, ctx, reqId);
-        case 'FAIL':
-            return handleFail(cmd, ctx, reqId);
-        default:
-            return null;
-    }
-}
-/** Route query commands */
-export async function routeQueryCommand(cmd, ctx, reqId) {
-    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-    switch (cmd.cmd) {
-        case 'GetJob':
-            return handleGetJob(cmd, ctx, reqId);
-        case 'GetState':
-            return handleGetState(cmd, ctx, reqId);
-        case 'GetResult':
-            return handleGetResult(cmd, ctx, reqId);
-        case 'GetJobCounts':
-            return handleGetJobCounts(cmd, ctx, reqId);
-        case 'GetCountsPerPriority':
-            return handleGetCountsPerPriority(cmd, ctx, reqId);
-        case 'GetJobByCustomId':
-            return handleGetJobByCustomId(cmd, ctx, reqId);
-        case 'GetJobs':
-            return handleGetJobs(cmd, ctx, reqId);
-        case 'Count':
-            return handleCount(cmd, ctx, reqId);
-        case 'GetProgress':
-            return handleGetProgress(cmd, ctx, reqId);
-        case 'GetChildrenValues':
-            return handleGetChildrenValues(cmd, ctx, reqId);
-        default:
-            return null;
-    }
-}
-/** Route management commands */
-export async function routeManagementCommand(cmd, ctx, reqId) {
-    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-    switch (cmd.cmd) {
-        case 'Cancel':
-            return handleCancel(cmd, ctx, reqId);
-        case 'Progress':
-            return handleProgress(cmd, ctx, reqId);
-        case 'Update':
-            return handleUpdate(cmd, ctx, reqId);
-        case 'UpdateParent':
-            return handleUpdateParent(cmd, ctx, reqId);
-        case 'ChangePriority':
-            return handleChangePriority(cmd, ctx, reqId);
-        case 'Promote':
-            return handlePromote(cmd, ctx, reqId);
-        case 'MoveToDelayed':
-            return handleMoveToDelayed(cmd, ctx, reqId);
-        case 'Discard':
-            return handleDiscard(cmd, ctx, reqId);
-        case 'WaitJob':
-            return handleWaitJob(cmd, ctx, reqId);
-        case 'ChangeDelay':
-            return handleChangeDelay(cmd, ctx, reqId);
-        case 'MoveToWait':
-            return handleMoveToWait(cmd, ctx, reqId);
-        case 'PromoteJobs':
-            return handlePromoteJobs(cmd, ctx, reqId);
-        case 'ExtendLock':
-            return handleExtendLock(cmd, ctx, reqId);
-        case 'ExtendLocks':
-            return handleExtendLocks(cmd, ctx, reqId);
-        case 'GetFailedChildrenValues':
-            return handleGetFailedChildrenValues(cmd, ctx, reqId);
-        case 'GetIgnoredChildrenFailures':
-            return handleGetIgnoredChildrenFailures(cmd, ctx, reqId);
-        case 'RemoveChildDependency':
-            return handleRemoveChildDependency(cmd, ctx, reqId);
-        case 'RemoveUnprocessedChildren':
-            return handleRemoveUnprocessedChildren(cmd, ctx, reqId);
-        default:
-            return null;
-    }
-}
-/** Route queue control commands */
-export function routeQueueControlCommand(cmd, ctx, reqId) {
-    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-    switch (cmd.cmd) {
-        case 'Pause':
-            return handlePause(cmd, ctx, reqId);
-        case 'Resume':
-            return handleResume(cmd, ctx, reqId);
-        case 'IsPaused':
-            return handleIsPaused(cmd, ctx, reqId);
-        case 'Drain':
-            return handleDrain(cmd, ctx, reqId);
-        case 'Obliterate':
-            return handleObliterate(cmd, ctx, reqId);
-        case 'ListQueues':
-            return handleListQueues(cmd, ctx, reqId);
-        case 'Clean':
-            return handleClean(cmd, ctx, reqId);
-        default:
-            return null;
-    }
-}
-/** Route DLQ commands */
-export function routeDlqCommand(cmd, ctx, reqId) {
-    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-    switch (cmd.cmd) {
-        case 'Dlq':
-            return handleDlq(cmd, ctx, reqId);
-        case 'RetryDlq':
-            return handleRetryDlq(cmd, ctx, reqId);
-        case 'PurgeDlq':
-            return handlePurgeDlq(cmd, ctx, reqId);
-        case 'RetryCompleted':
-            return handleRetryCompleted(cmd, ctx, reqId);
-        default:
-            return null;
-    }
-}
-/** Route rate limit commands */
-export function routeRateLimitCommand(cmd, ctx, reqId) {
-    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-    switch (cmd.cmd) {
-        case 'RateLimit':
-            return handleRateLimit(cmd, ctx, reqId);
-        case 'RateLimitClear':
-            return handleRateLimitClear(cmd, ctx, reqId);
-        case 'SetConcurrency':
-            return handleSetConcurrency(cmd, ctx, reqId);
-        case 'ClearConcurrency':
-            return handleClearConcurrency(cmd, ctx, reqId);
-        default:
-            return null;
-    }
-}
-/** Route cron commands */
-export function routeCronCommand(cmd, ctx, reqId) {
-    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-    switch (cmd.cmd) {
-        case 'Cron':
-            return handleCron(cmd, ctx, reqId);
-        case 'CronGet':
-            return handleCronGet(cmd, ctx, reqId);
-        case 'CronDelete':
-            return handleCronDelete(cmd, ctx, reqId);
-        case 'CronList':
-            return handleCronList(cmd, ctx, reqId);
-        default:
-            return null;
-    }
-}
-/** Route config commands (stall/DLQ config) */
-export function routeConfigCommand(cmd, ctx, reqId) {
-    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-    switch (cmd.cmd) {
-        case 'SetStallConfig':
-            return handleSetStallConfig(cmd, ctx, reqId);
-        case 'GetStallConfig':
-            return handleGetStallConfig(cmd, ctx, reqId);
-        case 'SetDlqConfig':
-            return handleSetDlqConfig(cmd, ctx, reqId);
-        case 'GetDlqConfig':
-            return handleGetDlqConfig(cmd, ctx, reqId);
-        default:
-            return null;
-    }
-}
-/** Route monitoring commands */
-export function routeMonitoringCommand(cmd, ctx, reqId) {
-    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-    switch (cmd.cmd) {
-        case 'Stats':
-            return handleStats(ctx, reqId);
-        case 'Metrics':
-            return handleMetrics(ctx, reqId);
-        case 'Prometheus':
-            return handlePrometheus(cmd, ctx, reqId);
-        case 'AddLog':
-            return handleAddLog(cmd, ctx, reqId);
-        case 'GetLogs':
-            return handleGetLogs(cmd, ctx, reqId);
-        case 'Heartbeat':
-            return handleHeartbeat(cmd, ctx, reqId);
-        case 'JobHeartbeat':
-            return handleJobHeartbeat(cmd, ctx, reqId);
-        case 'JobHeartbeatB':
-            return handleJobHeartbeatBatch(cmd, ctx, reqId);
-        case 'Ping':
-            return handlePing(cmd, ctx, reqId);
-        case 'Hello':
-            return handleHello(cmd, ctx, reqId);
-        case 'RegisterWorker':
-            return handleRegisterWorker(cmd, ctx, reqId);
-        case 'UnregisterWorker':
-            return handleUnregisterWorker(cmd, ctx, reqId);
-        case 'ListWorkers':
-            return handleListWorkers(cmd, ctx, reqId);
-        case 'AddWebhook':
-            return handleAddWebhook(cmd, ctx, reqId);
-        case 'RemoveWebhook':
-            return handleRemoveWebhook(cmd, ctx, reqId);
-        case 'ListWebhooks':
-            return handleListWebhooks(cmd, ctx, reqId);
-        case 'StorageStatus':
-            return handleStorageStatus(cmd, ctx, reqId);
-        case 'ClearLogs':
-            return handleClearLogs(cmd, ctx, reqId);
-        case 'SetWebhookEnabled':
-            return handleSetWebhookEnabled(cmd, ctx, reqId);
-        case 'CompactMemory':
-            return handleCompactMemory(cmd, ctx, reqId);
-        default:
-            return null;
-    }
-}
-/** Route dashboard commands */
-export function routeDashboardCommand(cmd, ctx, reqId) {
-    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
-    switch (cmd.cmd) {
-        case 'DashboardOverview':
-            return handleDashboardOverview(cmd, ctx, reqId);
-        case 'DashboardQueues':
-            return handleDashboardQueues(cmd, ctx, reqId);
-        case 'DashboardQueue':
-            return handleDashboardQueue(cmd, ctx, reqId);
-        default:
-            return null;
-    }
-}
+export { routeConfigCommand, routeCronCommand, routeDlqCommand, routeQueueControlCommand, routeRateLimitCommand, } from './handler-routes/control';
+export { routeCoreCommand, routeManagementCommand, routeQueryCommand, } from './handler-routes/jobs';
+export { routeDashboardCommand, routeMonitoringCommand, } from './handler-routes/monitoring';

package/dist/infrastructure/server/handlers/advanced/configNumbers.d.ts

@@ -0,0 +1,2 @@
+export declare function toFiniteNumber(value: unknown): number | undefined;
+export declare function sanitizeConfigNumbers<T extends Record<string, unknown>>(config: T, numericKeys: readonly string[]): T;

package/dist/infrastructure/server/handlers/advanced/configNumbers.js

@@ -0,0 +1,26 @@
+export function toFiniteNumber(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const number = typeof value === 'number' ? value : Number(value);
+    return Number.isFinite(number) ? number : undefined;
+}
+export function sanitizeConfigNumbers(config, numericKeys) {
+    if (!config || typeof config !== 'object')
+        return config;
+    const numeric = new Set(numericKeys);
+    const output = {};
+    for (const [key, value] of Object.entries(config)) {
+        if (!numeric.has(key)) {
+            output[key] = value;
+            continue;
+        }
+        if (value === null) {
+            output[key] = null;
+            continue;
+        }
+        const number = toFiniteNumber(value);
+        if (number !== undefined)
+            output[key] = number;
+    }
+    return output;
+}

package/dist/infrastructure/server/handlers/advanced/dependencies.d.ts

@@ -0,0 +1,15 @@
+import type { Command } from '../../../../domain/types/command';
+import type { Response } from '../../../../domain/types/response';
+import type { HandlerContext } from '../../types';
+export declare function handleGetFailedChildrenValues(command: Extract<Command, {
+    cmd: 'GetFailedChildrenValues';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handleGetIgnoredChildrenFailures(command: Extract<Command, {
+    cmd: 'GetIgnoredChildrenFailures';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handleRemoveChildDependency(command: Extract<Command, {
+    cmd: 'RemoveChildDependency';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handleRemoveUnprocessedChildren(command: Extract<Command, {
+    cmd: 'RemoveUnprocessedChildren';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;

package/dist/infrastructure/server/handlers/advanced/dependencies.js

@@ -0,0 +1,38 @@
+import { jobId } from '../../../../domain/types/job';
+import * as response from '../../../../domain/types/response';
+export async function handleGetFailedChildrenValues(command, context, requestId) {
+    try {
+        const values = await context.queueManager.getFailedChildrenValues(jobId(command.id));
+        return { ok: true, values, reqId: requestId };
+    }
+    catch {
+        return { ok: true, values: {}, reqId: requestId };
+    }
+}
+export async function handleGetIgnoredChildrenFailures(command, context, requestId) {
+    try {
+        const values = await context.queueManager.getIgnoredChildrenFailures(jobId(command.id));
+        return { ok: true, values, reqId: requestId };
+    }
+    catch {
+        return { ok: true, values: {}, reqId: requestId };
+    }
+}
+export async function handleRemoveChildDependency(command, context, requestId) {
+    try {
+        const removed = await context.queueManager.removeChildDependency(jobId(command.id));
+        return { ok: true, removed, reqId: requestId };
+    }
+    catch (error) {
+        return response.error(error instanceof Error ? error.message : String(error), requestId);
+    }
+}
+export async function handleRemoveUnprocessedChildren(command, context, requestId) {
+    try {
+        await context.queueManager.removeUnprocessedChildren(jobId(command.id));
+        return response.ok(undefined, requestId);
+    }
+    catch (error) {
+        return response.error(error instanceof Error ? error.message : String(error), requestId);
+    }
+}

package/dist/infrastructure/server/handlers/advanced/jobs.d.ts

@@ -0,0 +1,33 @@
+import type { Command } from '../../../../domain/types/command';
+import type { Response } from '../../../../domain/types/response';
+import type { HandlerContext } from '../../types';
+export declare function handleUpdate(command: Extract<Command, {
+    cmd: 'Update';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handleChangePriority(command: Extract<Command, {
+    cmd: 'ChangePriority';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handlePromote(command: Extract<Command, {
+    cmd: 'Promote';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handleUpdateParent(command: Extract<Command, {
+    cmd: 'UpdateParent';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handleMoveToDelayed(command: Extract<Command, {
+    cmd: 'MoveToDelayed';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handleDiscard(command: Extract<Command, {
+    cmd: 'Discard';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handleWaitJob(command: Extract<Command, {
+    cmd: 'WaitJob';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handleChangeDelay(command: Extract<Command, {
+    cmd: 'ChangeDelay';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handleMoveToWait(command: Extract<Command, {
+    cmd: 'MoveToWait';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;
+export declare function handlePromoteJobs(command: Extract<Command, {
+    cmd: 'PromoteJobs';
+}>, context: HandlerContext, requestId?: string): Promise<Response>;

package/dist/infrastructure/server/handlers/advanced/jobs.js

@@ -0,0 +1,136 @@
+import { jobId } from '../../../../domain/types/job';
+import * as response from '../../../../domain/types/response';
+import { validateNumericField } from '../../protocol';
+export async function handleUpdate(command, context, requestId) {
+    const success = await context.queueManager.updateJobData(jobId(command.id), command.data);
+    if (success)
+        context.queueManager.emitDashboardEvent('job:data-updated', { jobId: command.id });
+    return success
+        ? response.ok(undefined, requestId)
+        : response.error('Job not found or cannot be updated', requestId);
+}
+export async function handleChangePriority(command, context, requestId) {
+    const success = await context.queueManager.changePriority(jobId(command.id), command.priority, command.lifo);
+    if (success) {
+        context.queueManager.emitDashboardEvent('job:priority-changed', {
+            jobId: command.id,
+            newPriority: command.priority,
+        });
+    }
+    return success
+        ? response.ok(undefined, requestId)
+        : response.error('Job not found or not in queue', requestId);
+}
+export async function handlePromote(command, context, requestId) {
+    const success = await context.queueManager.promote(jobId(command.id));
+    if (success)
+        context.queueManager.emitDashboardEvent('job:promoted', { jobId: command.id });
+    return success
+        ? response.ok(undefined, requestId)
+        : response.error('Job not found or not delayed', requestId);
+}
+export async function handleUpdateParent(command, context, requestId) {
+    try {
+        await context.queueManager.updateJobParent(jobId(command.childId), jobId(command.parentId));
+        return response.ok(undefined, requestId);
+    }
+    catch (error) {
+        return response.error(error instanceof Error ? error.message : 'Failed to update parent', requestId);
+    }
+}
+export async function handleMoveToDelayed(command, context, requestId) {
+    const id = jobId(command.id);
+    const success = await context.queueManager.moveToDelayed(id, command.delay, command.token);
+    if (success) {
+        context.queueManager.emitDashboardEvent('job:moved-to-delayed', {
+            jobId: command.id,
+            delay: command.delay,
+        });
+        return response.ok(undefined, requestId);
+    }
+    const state = await context.queueManager.getJobState(id);
+    if (state === 'unknown')
+        return response.error('Job not found', requestId);
+    return response.error(`Job is not active (current state: ${state})`, requestId);
+}
+export async function handleDiscard(command, context, requestId) {
+    const success = await context.queueManager.discard(jobId(command.id), command.token);
+    if (success)
+        context.queueManager.emitDashboardEvent('job:discarded', { jobId: command.id });
+    return success ? response.ok(undefined, requestId) : response.error('Job not found', requestId);
+}
+export async function handleWaitJob(command, context, requestId) {
+    const id = jobId(command.id);
+    const timeoutError = validateNumericField(command.timeout, 'timeout', {
+        min: 0,
+        max: 600000,
+    });
+    if (timeoutError)
+        return response.error(timeoutError, requestId);
+    const timeout = command.timeout ?? 30000;
+    const job = await context.queueManager.getJob(id);
+    if (!job)
+        return response.error('Job not found', requestId);
+    if (job.completedAt) {
+        return {
+            ok: true,
+            completed: true,
+            result: context.queueManager.getResult(id),
+            reqId: requestId,
+        };
+    }
+    const completed = await context.queueManager.waitForJobCompletion(id, timeout);
+    if (completed) {
+        return {
+            ok: true,
+            completed: true,
+            result: context.queueManager.getResult(id),
+            reqId: requestId,
+        };
+    }
+    return { ok: true, completed: false, reqId: requestId };
+}
+export async function handleChangeDelay(command, context, requestId) {
+    const success = await context.queueManager.changeDelay(jobId(command.id), command.delay, command.token);
+    if (success) {
+        context.queueManager.emitDashboardEvent('job:delay-changed', {
+            jobId: command.id,
+            newDelay: command.delay,
+        });
+    }
+    return success
+        ? response.ok(undefined, requestId)
+        : response.error('Job not found or cannot change delay', requestId);
+}
+export async function handleMoveToWait(command, context, requestId) {
+    const id = jobId(command.id);
+    const state = await context.queueManager.getJobState(id);
+    if (state === 'active') {
+        const success = await context.queueManager.moveActiveToWait(id, command.token);
+        return success
+            ? response.ok(undefined, requestId)
+            : response.error('Job not found or not active', requestId);
+    }
+    if (state === 'delayed') {
+        const success = await context.queueManager.promote(id);
+        return success
+            ? response.ok(undefined, requestId)
+            : response.error('Job not found or not delayed', requestId);
+    }
+    if (state === 'failed') {
+        const job = await context.queueManager.getJob(id);
+        if (!job)
+            return response.error('Job not found', requestId);
+        const count = context.queueManager.retryDlq(job.queue, id);
+        return count > 0
+            ? response.ok(undefined, requestId)
+            : response.error('Failed job not in DLQ', requestId);
+    }
+    if (state === 'waiting' || state === 'prioritized')
+        return response.ok(undefined, requestId);
+    return response.error(`Cannot move job from state '${state}' to waiting`, requestId);
+}
+export async function handlePromoteJobs(command, context, requestId) {
+    const count = await context.queueManager.promoteJobs(command.queue, command.count);
+    return { ok: true, count, reqId: requestId };
+}

package/dist/infrastructure/server/handlers/advanced/queue.d.ts

@@ -0,0 +1,42 @@
+import type { Command } from '../../../../domain/types/command';
+import type { Response } from '../../../../domain/types/response';
+import type { HandlerContext } from '../../types';
+export declare function handleIsPaused(command: Extract<Command, {
+    cmd: 'IsPaused';
+}>, context: HandlerContext, requestId?: string): Response;
+export declare function handleObliterate(command: Extract<Command, {
+    cmd: 'Obliterate';
+}>, context: HandlerContext, requestId?: string): Response;
+export declare function handleListQueues(_command: Extract<Command, {
+    cmd: 'ListQueues';
+}>, context: HandlerContext, requestId?: string): Response;
+export declare function handleClean(command: Extract<Command, {
+    cmd: 'Clean';
+}>, context: HandlerContext, requestId?: string): Response;
+export declare function handleCount(command: Extract<Command, {
+    cmd: 'Count';
+}>, context: HandlerContext, requestId?: string): Response;
+export declare function handleRateLimit(command: Extract<Command, {
+    cmd: 'RateLimit';
+}>, context: HandlerContext, requestId?: string): Response;
+export declare function handleRateLimitClear(command: Extract<Command, {
+    cmd: 'RateLimitClear';
+}>, context: HandlerContext, requestId?: string): Response;
+export declare function handleSetConcurrency(command: Extract<Command, {
+    cmd: 'SetConcurrency';
+}>, context: HandlerContext, requestId?: string): Response;
+export declare function handleClearConcurrency(command: Extract<Command, {
+    cmd: 'ClearConcurrency';
+}>, context: HandlerContext, requestId?: string): Response;
+export declare function handleSetStallConfig(command: Extract<Command, {
+    cmd: 'SetStallConfig';
+}>, context: HandlerContext, requestId?: string): Response;
+export declare function handleGetStallConfig(command: Extract<Command, {
+    cmd: 'GetStallConfig';
+}>, context: HandlerContext, requestId?: string): Response;
+export declare function handleSetDlqConfig(command: Extract<Command, {
+    cmd: 'SetDlqConfig';
+}>, context: HandlerContext, requestId?: string): Response;
+export declare function handleGetDlqConfig(command: Extract<Command, {
+    cmd: 'GetDlqConfig';
+}>, context: HandlerContext, requestId?: string): Response;