bunqueue 2.8.54 → 2.8.57

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;

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

@@ -0,0 +1,111 @@
+import * as response from '../../../../domain/types/response';
+import { sanitizeConfigNumbers, toFiniteNumber } from './configNumbers';
+export function handleIsPaused(command, context, requestId) {
+    return {
+        ok: true,
+        paused: context.queueManager.isPaused(command.queue),
+        reqId: requestId,
+    };
+}
+export function handleObliterate(command, context, requestId) {
+    context.queueManager.obliterate(command.queue);
+    return response.ok(undefined, requestId);
+}
+export function handleListQueues(_command, context, requestId) {
+    return {
+        ok: true,
+        queues: context.queueManager.listQueues(),
+        reqId: requestId,
+    };
+}
+export function handleClean(command, context, requestId) {
+    const ids = context.queueManager.clean(command.queue, command.grace, command.state, command.limit);
+    if (ids.length > 0) {
+        context.queueManager.emitDashboardEvent('queue:cleaned', {
+            queue: command.queue,
+            state: command.state,
+            count: ids.length,
+        });
+    }
+    return { ok: true, count: ids.length, ids, reqId: requestId };
+}
+export function handleCount(command, context, requestId) {
+    return { ok: true, count: context.queueManager.count(command.queue), reqId: requestId };
+}
+export function handleRateLimit(command, context, requestId) {
+    const limit = toFiniteNumber(command.limit);
+    if (limit === undefined)
+        return response.error('limit must be a finite number', requestId);
+    const duration = toFiniteNumber(command.duration);
+    const ttl = toFiniteNumber(command.ttl);
+    context.queueManager.setRateLimit(command.queue, limit, duration, ttl);
+    context.queueManager.emitDashboardEvent('ratelimit:set', {
+        queue: command.queue,
+        max: limit,
+        ...(duration !== undefined && { duration }),
+        ...(ttl !== undefined && { ttl }),
+    });
+    return response.ok(undefined, requestId);
+}
+export function handleRateLimitClear(command, context, requestId) {
+    context.queueManager.clearRateLimit(command.queue);
+    context.queueManager.emitDashboardEvent('ratelimit:cleared', { queue: command.queue });
+    return response.ok(undefined, requestId);
+}
+export function handleSetConcurrency(command, context, requestId) {
+    const limit = toFiniteNumber(command.limit);
+    if (limit === undefined)
+        return response.error('limit must be a finite number', requestId);
+    context.queueManager.setConcurrency(command.queue, limit);
+    context.queueManager.emitDashboardEvent('concurrency:set', {
+        queue: command.queue,
+        concurrency: limit,
+    });
+    return response.ok(undefined, requestId);
+}
+export function handleClearConcurrency(command, context, requestId) {
+    context.queueManager.clearConcurrency(command.queue);
+    context.queueManager.emitDashboardEvent('concurrency:cleared', { queue: command.queue });
+    return response.ok(undefined, requestId);
+}
+export function handleSetStallConfig(command, context, requestId) {
+    const config = sanitizeConfigNumbers(command.config, [
+        'stallInterval',
+        'maxStalls',
+        'gracePeriod',
+    ]);
+    context.queueManager.setStallConfig(command.queue, config);
+    context.queueManager.emitDashboardEvent('config:stall-changed', {
+        queue: command.queue,
+        config,
+    });
+    return response.ok(undefined, requestId);
+}
+export function handleGetStallConfig(command, context, requestId) {
+    return {
+        ok: true,
+        config: context.queueManager.getStallConfig(command.queue),
+        reqId: requestId,
+    };
+}
+export function handleSetDlqConfig(command, context, requestId) {
+    const config = sanitizeConfigNumbers(command.config, [
+        'autoRetryInterval',
+        'maxAutoRetries',
+        'maxAge',
+        'maxEntries',
+    ]);
+    context.queueManager.setDlqConfig(command.queue, config);
+    context.queueManager.emitDashboardEvent('config:dlq-changed', {
+        queue: command.queue,
+        config,
+    });
+    return response.ok(undefined, requestId);
+}
+export function handleGetDlqConfig(command, context, requestId) {
+    return {
+        ok: true,
+        config: context.queueManager.getDlqConfig(command.queue),
+        reqId: requestId,
+    };
+}

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

@@ -1,121 +1,3 @@
-/**
- * Advanced Command Handlers
- * Job management, queue control, rate limiting
- */
-import type { Command } from '../../../domain/types/command';
-import type { Response } from '../../../domain/types/response';
-import type { HandlerContext } from '../types';
-/** Handle Update command - update job data */
-export declare function handleUpdate(cmd: Extract<Command, {
-    cmd: 'Update';
-}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle ChangePriority command */
-export declare function handleChangePriority(cmd: Extract<Command, {
-    cmd: 'ChangePriority';
-}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle Promote command - move delayed to waiting */
-export declare function handlePromote(cmd: Extract<Command, {
-    cmd: 'Promote';
-}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle UpdateParent command - update child's parent reference */
-export declare function handleUpdateParent(cmd: Extract<Command, {
-    cmd: 'UpdateParent';
-}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle MoveToDelayed command */
-export declare function handleMoveToDelayed(cmd: Extract<Command, {
-    cmd: 'MoveToDelayed';
-}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle Discard command - move to DLQ */
-export declare function handleDiscard(cmd: Extract<Command, {
-    cmd: 'Discard';
-}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle WaitJob command - wait for job completion (event-driven, no polling) */
-export declare function handleWaitJob(cmd: Extract<Command, {
-    cmd: 'WaitJob';
-}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle IsPaused command */
-export declare function handleIsPaused(cmd: Extract<Command, {
-    cmd: 'IsPaused';
-}>, ctx: HandlerContext, reqId?: string): Response;
-/** Handle Obliterate command */
-export declare function handleObliterate(cmd: Extract<Command, {
-    cmd: 'Obliterate';
-}>, ctx: HandlerContext, reqId?: string): Response;
-/** Handle ListQueues command */
-export declare function handleListQueues(_cmd: Extract<Command, {
-    cmd: 'ListQueues';
-}>, ctx: HandlerContext, reqId?: string): Response;
-/** Handle Clean command */
-export declare function handleClean(cmd: Extract<Command, {
-    cmd: 'Clean';
-}>, ctx: HandlerContext, reqId?: string): Response;
-/** Handle Count command */
-export declare function handleCount(cmd: Extract<Command, {
-    cmd: 'Count';
-}>, ctx: HandlerContext, reqId?: string): Response;
-/** Handle RateLimit command */
-export declare function handleRateLimit(cmd: Extract<Command, {
-    cmd: 'RateLimit';
-}>, ctx: HandlerContext, reqId?: string): Response;
-/** Handle RateLimitClear command */
-export declare function handleRateLimitClear(cmd: Extract<Command, {
-    cmd: 'RateLimitClear';
-}>, ctx: HandlerContext, reqId?: string): Response;
-/** Handle SetConcurrency command */
-export declare function handleSetConcurrency(cmd: Extract<Command, {
-    cmd: 'SetConcurrency';
-}>, ctx: HandlerContext, reqId?: string): Response;
-/** Handle ClearConcurrency command */
-export declare function handleClearConcurrency(cmd: Extract<Command, {
-    cmd: 'ClearConcurrency';
-}>, ctx: HandlerContext, reqId?: string): Response;
-/** Handle SetStallConfig command */
-export declare function handleSetStallConfig(cmd: Extract<Command, {
-    cmd: 'SetStallConfig';
-}>, ctx: HandlerContext, reqId?: string): Response;
-/** Handle GetStallConfig command */
-export declare function handleGetStallConfig(cmd: Extract<Command, {
-    cmd: 'GetStallConfig';
-}>, ctx: HandlerContext, reqId?: string): Response;
-/** Handle SetDlqConfig command */
-export declare function handleSetDlqConfig(cmd: Extract<Command, {
-    cmd: 'SetDlqConfig';
-}>, ctx: HandlerContext, reqId?: string): Response;
-/** Handle GetDlqConfig command */
-export declare function handleGetDlqConfig(cmd: Extract<Command, {
-    cmd: 'GetDlqConfig';
-}>, ctx: HandlerContext, reqId?: string): Response;
-/** Handle ChangeDelay command - change delay for a delayed/active job */
-export declare function handleChangeDelay(cmd: Extract<Command, {
-    cmd: 'ChangeDelay';
-}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle MoveToWait command - move a job back to waiting.
- *  Dispatch by state to match embedded branching in jobMove.ts.
- *  - active  -> moveActiveToWait
- *  - delayed -> promote
- *  - failed  -> retryDlq
- *  - waiting / prioritized -> already there, no-op success
- */
-export declare function handleMoveToWait(cmd: Extract<Command, {
-    cmd: 'MoveToWait';
-}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle PromoteJobs command - promote all delayed jobs in a queue */
-export declare function handlePromoteJobs(cmd: Extract<Command, {
-    cmd: 'PromoteJobs';
-}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle GetFailedChildrenValues command */
-export declare function handleGetFailedChildrenValues(cmd: Extract<Command, {
-    cmd: 'GetFailedChildrenValues';
-}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle GetIgnoredChildrenFailures command */
-export declare function handleGetIgnoredChildrenFailures(cmd: Extract<Command, {
-    cmd: 'GetIgnoredChildrenFailures';
-}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle RemoveChildDependency command */
-export declare function handleRemoveChildDependency(cmd: Extract<Command, {
-    cmd: 'RemoveChildDependency';
-}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
-/** Handle RemoveUnprocessedChildren command */
-export declare function handleRemoveUnprocessedChildren(cmd: Extract<Command, {
-    cmd: 'RemoveUnprocessedChildren';
-}>, ctx: HandlerContext, reqId?: string): Promise<Response>;
+export { handleGetFailedChildrenValues, handleGetIgnoredChildrenFailures, handleRemoveChildDependency, handleRemoveUnprocessedChildren, } from './advanced/dependencies';
+export { handleChangeDelay, handleChangePriority, handleDiscard, handleMoveToDelayed, handleMoveToWait, handlePromote, handlePromoteJobs, handleUpdate, handleUpdateParent, handleWaitJob, } from './advanced/jobs';
+export { handleClean, handleClearConcurrency, handleCount, handleGetDlqConfig, handleGetStallConfig, handleIsPaused, handleListQueues, handleObliterate, handleRateLimit, handleRateLimitClear, handleSetConcurrency, handleSetDlqConfig, handleSetStallConfig, } from './advanced/queue';

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

@@ -1,336 +1,3 @@
-/**
- * Advanced Command Handlers
- * Job management, queue control, rate limiting
- */
-import * as resp from '../../../domain/types/response';
-import { jobId } from '../../../domain/types/job';
-import { validateNumericField } from '../protocol';
-/**
- * Coerce a value to a finite number, or return undefined if it can't be.
- * Guards config endpoints against non-numeric input (e.g. `"abc"`) that would
- * otherwise reach numeric comparisons as NaN and silently break behaviour
- * (a string `stallInterval` disabled stall detection entirely).
- */
-function toFiniteNumber(value) {
-    if (value === undefined || value === null)
-        return undefined;
-    const n = typeof value === 'number' ? value : Number(value);
-    return Number.isFinite(n) ? n : undefined;
-}
-/**
- * Sanitize the numeric fields of a config object: coerce numeric strings, drop
- * non-numeric garbage (so the manager's merge keeps the existing/default value
- * instead of storing NaN). Booleans and unknown keys pass through untouched.
- */
-function sanitizeConfigNumbers(config, numericKeys) {
-    if (!config || typeof config !== 'object')
-        return config;
-    const numeric = new Set(numericKeys);
-    const out = {};
-    for (const [key, value] of Object.entries(config)) {
-        if (!numeric.has(key)) {
-            out[key] = value; // booleans / unknown keys pass through untouched
-            continue;
-        }
-        if (value === null) {
-            out[key] = null; // valid for nullable fields (e.g. dlq maxAge)
-            continue;
-        }
-        const n = toFiniteNumber(value);
-        // coerce numeric strings; omit non-numeric garbage so the manager's merge
-        // keeps the existing/default value instead of storing NaN
-        if (n !== undefined)
-            out[key] = n;
-    }
-    return out;
-}
-// ============ Job Management ============
-/** Handle Update command - update job data */
-export async function handleUpdate(cmd, ctx, reqId) {
-    const success = await ctx.queueManager.updateJobData(jobId(cmd.id), cmd.data);
-    if (success)
-        ctx.queueManager.emitDashboardEvent('job:data-updated', { jobId: cmd.id });
-    return success
-        ? resp.ok(undefined, reqId)
-        : resp.error('Job not found or cannot be updated', reqId);
-}
-/** Handle ChangePriority command */
-export async function handleChangePriority(cmd, ctx, reqId) {
-    const success = await ctx.queueManager.changePriority(jobId(cmd.id), cmd.priority, cmd.lifo);
-    if (success) {
-        ctx.queueManager.emitDashboardEvent('job:priority-changed', {
-            jobId: cmd.id,
-            newPriority: cmd.priority,
-        });
-    }
-    return success ? resp.ok(undefined, reqId) : resp.error('Job not found or not in queue', reqId);
-}
-/** Handle Promote command - move delayed to waiting */
-export async function handlePromote(cmd, ctx, reqId) {
-    const success = await ctx.queueManager.promote(jobId(cmd.id));
-    if (success)
-        ctx.queueManager.emitDashboardEvent('job:promoted', { jobId: cmd.id });
-    return success ? resp.ok(undefined, reqId) : resp.error('Job not found or not delayed', reqId);
-}
-/** Handle UpdateParent command - update child's parent reference */
-export async function handleUpdateParent(cmd, ctx, reqId) {
-    try {
-        await ctx.queueManager.updateJobParent(jobId(cmd.childId), jobId(cmd.parentId));
-        return resp.ok(undefined, reqId);
-    }
-    catch (error) {
-        return resp.error(error instanceof Error ? error.message : 'Failed to update parent', reqId);
-    }
-}
-/** Handle MoveToDelayed command */
-export async function handleMoveToDelayed(cmd, ctx, reqId) {
-    const id = jobId(cmd.id);
-    const success = await ctx.queueManager.moveToDelayed(id, cmd.delay);
-    if (success) {
-        ctx.queueManager.emitDashboardEvent('job:moved-to-delayed', {
-            jobId: cmd.id,
-            delay: cmd.delay,
-        });
-        return resp.ok(undefined, reqId);
-    }
-    const state = await ctx.queueManager.getJobState(id);
-    if (state === 'unknown') {
-        return resp.error('Job not found', reqId);
-    }
-    return resp.error(`Job is not active (current state: ${state})`, reqId);
-}
-/** Handle Discard command - move to DLQ */
-export async function handleDiscard(cmd, ctx, reqId) {
-    const success = await ctx.queueManager.discard(jobId(cmd.id));
-    if (success)
-        ctx.queueManager.emitDashboardEvent('job:discarded', { jobId: cmd.id });
-    return success ? resp.ok(undefined, reqId) : resp.error('Job not found', reqId);
-}
-/** Handle WaitJob command - wait for job completion (event-driven, no polling) */
-export async function handleWaitJob(cmd, ctx, reqId) {
-    const jid = jobId(cmd.id);
-    // Bounded like PULL (which caps at 60s); waiting for completion is
-    // legitimately longer, so the cap here is 10 min. validateNumericField also
-    // rejects NaN/Infinity from hostile clients (a hand-rolled <0/>max check
-    // would let NaN through and resolve instantly as a false "not completed").
-    const timeoutError = validateNumericField(cmd.timeout, 'timeout', { min: 0, max: 600000 });
-    if (timeoutError)
-        return resp.error(timeoutError, reqId);
-    const timeout = cmd.timeout ?? 30000;
-    // First check if job exists and is already completed
-    const job = await ctx.queueManager.getJob(jid);
-    if (!job)
-        return resp.error('Job not found', reqId);
-    if (job.completedAt) {
-        const result = ctx.queueManager.getResult(jid);
-        return { ok: true, completed: true, result, reqId };
-    }
-    // Wait for completion event - event-driven, no polling
-    const completed = await ctx.queueManager.waitForJobCompletion(jid, timeout);
-    if (completed) {
-        const result = ctx.queueManager.getResult(jid);
-        return { ok: true, completed: true, result, reqId };
-    }
-    return { ok: true, completed: false, reqId };
-}
-// ============ Queue Control ============
-/** Handle IsPaused command */
-export function handleIsPaused(cmd, ctx, reqId) {
-    const paused = ctx.queueManager.isPaused(cmd.queue);
-    return { ok: true, paused, reqId };
-}
-/** Handle Obliterate command */
-export function handleObliterate(cmd, ctx, reqId) {
-    ctx.queueManager.obliterate(cmd.queue);
-    return resp.ok(undefined, reqId);
-}
-/** Handle ListQueues command */
-export function handleListQueues(_cmd, ctx, reqId) {
-    const queues = ctx.queueManager.listQueues();
-    return { ok: true, queues, reqId };
-}
-/** Handle Clean command */
-export function handleClean(cmd, ctx, reqId) {
-    const ids = ctx.queueManager.clean(cmd.queue, cmd.grace, cmd.state, cmd.limit);
-    if (ids.length > 0) {
-        ctx.queueManager.emitDashboardEvent('queue:cleaned', {
-            queue: cmd.queue,
-            state: cmd.state,
-            count: ids.length,
-        });
-    }
-    return { ok: true, count: ids.length, ids, reqId };
-}
-/** Handle Count command */
-export function handleCount(cmd, ctx, reqId) {
-    const count = ctx.queueManager.count(cmd.queue);
-    return { ok: true, count, reqId };
-}
-// ============ Rate Limiting ============
-/** Handle RateLimit command */
-export function handleRateLimit(cmd, ctx, reqId) {
-    const limit = toFiniteNumber(cmd.limit);
-    if (limit === undefined)
-        return resp.error('limit must be a finite number', reqId);
-    // Optional window/TTL: invalid values degrade to the defaults (1s window,
-    // permanent limit) inside the limiter rather than failing the command.
-    const duration = toFiniteNumber(cmd.duration);
-    const ttl = toFiniteNumber(cmd.ttl);
-    ctx.queueManager.setRateLimit(cmd.queue, limit, duration, ttl);
-    ctx.queueManager.emitDashboardEvent('ratelimit:set', {
-        queue: cmd.queue,
-        max: limit,
-        ...(duration !== undefined && { duration }),
-        ...(ttl !== undefined && { ttl }),
-    });
-    return resp.ok(undefined, reqId);
-}
-/** Handle RateLimitClear command */
-export function handleRateLimitClear(cmd, ctx, reqId) {
-    ctx.queueManager.clearRateLimit(cmd.queue);
-    ctx.queueManager.emitDashboardEvent('ratelimit:cleared', { queue: cmd.queue });
-    return resp.ok(undefined, reqId);
-}
-/** Handle SetConcurrency command */
-export function handleSetConcurrency(cmd, ctx, reqId) {
-    const limit = toFiniteNumber(cmd.limit);
-    if (limit === undefined)
-        return resp.error('limit must be a finite number', reqId);
-    ctx.queueManager.setConcurrency(cmd.queue, limit);
-    ctx.queueManager.emitDashboardEvent('concurrency:set', {
-        queue: cmd.queue,
-        concurrency: limit,
-    });
-    return resp.ok(undefined, reqId);
-}
-/** Handle ClearConcurrency command */
-export function handleClearConcurrency(cmd, ctx, reqId) {
-    ctx.queueManager.clearConcurrency(cmd.queue);
-    ctx.queueManager.emitDashboardEvent('concurrency:cleared', { queue: cmd.queue });
-    return resp.ok(undefined, reqId);
-}
-// ============ Config Commands ============
-/** Handle SetStallConfig command */
-export function handleSetStallConfig(cmd, ctx, reqId) {
-    const config = sanitizeConfigNumbers(cmd.config, ['stallInterval', 'maxStalls', 'gracePeriod']);
-    ctx.queueManager.setStallConfig(cmd.queue, config);
-    ctx.queueManager.emitDashboardEvent('config:stall-changed', {
-        queue: cmd.queue,
-        config,
-    });
-    return resp.ok(undefined, reqId);
-}
-/** Handle GetStallConfig command */
-export function handleGetStallConfig(cmd, ctx, reqId) {
-    const config = ctx.queueManager.getStallConfig(cmd.queue);
-    return { ok: true, config, reqId };
-}
-/** Handle SetDlqConfig command */
-export function handleSetDlqConfig(cmd, ctx, reqId) {
-    const config = sanitizeConfigNumbers(cmd.config, [
-        'autoRetryInterval',
-        'maxAutoRetries',
-        'maxAge',
-        'maxEntries',
-    ]);
-    ctx.queueManager.setDlqConfig(cmd.queue, config);
-    ctx.queueManager.emitDashboardEvent('config:dlq-changed', {
-        queue: cmd.queue,
-        config,
-    });
-    return resp.ok(undefined, reqId);
-}
-/** Handle GetDlqConfig command */
-export function handleGetDlqConfig(cmd, ctx, reqId) {
-    const config = ctx.queueManager.getDlqConfig(cmd.queue);
-    return { ok: true, config, reqId };
-}
-/** Handle ChangeDelay command - change delay for a delayed/active job */
-export async function handleChangeDelay(cmd, ctx, reqId) {
-    const success = await ctx.queueManager.changeDelay(jobId(cmd.id), cmd.delay);
-    if (success) {
-        ctx.queueManager.emitDashboardEvent('job:delay-changed', {
-            jobId: cmd.id,
-            newDelay: cmd.delay,
-        });
-    }
-    return success
-        ? resp.ok(undefined, reqId)
-        : resp.error('Job not found or cannot change delay', reqId);
-}
-/** Handle MoveToWait command - move a job back to waiting.
- *  Dispatch by state to match embedded branching in jobMove.ts.
- *  - active  -> moveActiveToWait
- *  - delayed -> promote
- *  - failed  -> retryDlq
- *  - waiting / prioritized -> already there, no-op success
- */
-export async function handleMoveToWait(cmd, ctx, reqId) {
-    const id = jobId(cmd.id);
-    const state = await ctx.queueManager.getJobState(id);
-    if (state === 'active') {
-        const ok = await ctx.queueManager.moveActiveToWait(id);
-        return ok ? resp.ok(undefined, reqId) : resp.error('Job not found or not active', reqId);
-    }
-    if (state === 'delayed') {
-        const ok = await ctx.queueManager.promote(id);
-        return ok ? resp.ok(undefined, reqId) : resp.error('Job not found or not delayed', reqId);
-    }
-    if (state === 'failed') {
-        const job = await ctx.queueManager.getJob(id);
-        if (!job)
-            return resp.error('Job not found', reqId);
-        const count = ctx.queueManager.retryDlq(job.queue, id);
-        return count > 0 ? resp.ok(undefined, reqId) : resp.error('Failed job not in DLQ', reqId);
-    }
-    if (state === 'waiting' || state === 'prioritized') {
-        return resp.ok(undefined, reqId);
-    }
-    return resp.error(`Cannot move job from state '${state}' to waiting`, reqId);
-}
-/** Handle PromoteJobs command - promote all delayed jobs in a queue */
-export async function handlePromoteJobs(cmd, ctx, reqId) {
-    const count = await ctx.queueManager.promoteJobs(cmd.queue, cmd.count);
-    return { ok: true, count, reqId };
-}
-// ============ Flow Dependency Commands ============
-/** Handle GetFailedChildrenValues command */
-export async function handleGetFailedChildrenValues(cmd, ctx, reqId) {
-    try {
-        const values = await ctx.queueManager.getFailedChildrenValues(jobId(cmd.id));
-        return { ok: true, values, reqId };
-    }
-    catch {
-        return { ok: true, values: {}, reqId };
-    }
-}
-/** Handle GetIgnoredChildrenFailures command */
-export async function handleGetIgnoredChildrenFailures(cmd, ctx, reqId) {
-    try {
-        const values = await ctx.queueManager.getIgnoredChildrenFailures(jobId(cmd.id));
-        return { ok: true, values, reqId };
-    }
-    catch {
-        return { ok: true, values: {}, reqId };
-    }
-}
-/** Handle RemoveChildDependency command */
-export async function handleRemoveChildDependency(cmd, ctx, reqId) {
-    try {
-        const removed = await ctx.queueManager.removeChildDependency(jobId(cmd.id));
-        return { ok: true, removed, reqId };
-    }
-    catch (err) {
-        return resp.error(err instanceof Error ? err.message : String(err), reqId);
-    }
-}
-/** Handle RemoveUnprocessedChildren command */
-export async function handleRemoveUnprocessedChildren(cmd, ctx, reqId) {
-    try {
-        await ctx.queueManager.removeUnprocessedChildren(jobId(cmd.id));
-        return resp.ok(undefined, reqId);
-    }
-    catch (err) {
-        return resp.error(err instanceof Error ? err.message : String(err), reqId);
-    }
-}
+export { handleGetFailedChildrenValues, handleGetIgnoredChildrenFailures, handleRemoveChildDependency, handleRemoveUnprocessedChildren, } from './advanced/dependencies';
+export { handleChangeDelay, handleChangePriority, handleDiscard, handleMoveToDelayed, handleMoveToWait, handlePromote, handlePromoteJobs, handleUpdate, handleUpdateParent, handleWaitJob, } from './advanced/jobs';
+export { handleClean, handleClearConcurrency, handleCount, handleGetDlqConfig, handleGetStallConfig, handleIsPaused, handleListQueues, handleObliterate, handleRateLimit, handleRateLimitClear, handleSetConcurrency, handleSetDlqConfig, handleSetStallConfig, } from './advanced/queue';

package/dist/infrastructure/server/handlers/core.d.ts

@@ -1,7 +1,4 @@
-/**
- * Core Command Handlers
- * Push, Pull, Ack, Fail operations
- */
+/** Core command handlers for push, pull, acknowledgement, and failure. */
 import type { Command } from '../../../domain/types/command';
 import type { Response } from '../../../domain/types/response';
 import type { HandlerContext } from '../types';