bunqueue 2.8.54 → 2.8.57

package/dist/infrastructure/server/httpRouteJobs.js

@@ -1,284 +1,95 @@
-/**
- * HTTP Routes - Job operations
- * All /jobs/:id/* endpoints, split into sub-routers for complexity
- */
 import { handleCommand } from './handler';
+import { routeJobAdvanced } from './http-routes/jobAdvanced';
+import { routeJobManagement } from './http-routes/jobManagement';
 import { jsonResponse, parseJsonBody } from './httpEndpoints';
-// Pre-compiled regex patterns for URL matching
-const RE_JOB_PROMOTE = /^\/jobs\/([^/]+)\/promote$/;
-const RE_JOB_DATA = /^\/jobs\/([^/]+)\/data$/;
-const RE_JOB_STATE = /^\/jobs\/([^/]+)\/state$/;
-const RE_JOB_RESULT = /^\/jobs\/([^/]+)\/result$/;
-const RE_JOB_PROGRESS = /^\/jobs\/([^/]+)\/progress$/;
-const RE_JOB_PRIORITY = /^\/jobs\/([^/]+)\/priority$/;
-const RE_JOB_DISCARD = /^\/jobs\/([^/]+)\/discard$/;
-const RE_JOB_MOVE_DELAYED = /^\/jobs\/([^/]+)\/move-to-delayed$/;
-const RE_JOB_DELAY = /^\/jobs\/([^/]+)\/delay$/;
-const RE_JOB_CHILDREN = /^\/jobs\/([^/]+)\/children$/;
-const RE_JOB_LOGS = /^\/jobs\/([^/]+)\/logs$/;
-const RE_JOB_HEARTBEAT = /^\/jobs\/([^/]+)\/heartbeat$/;
-const RE_JOB_WAIT = /^\/jobs\/([^/]+)\/wait$/;
-const RE_JOB_EXTEND_LOCK = /^\/jobs\/([^/]+)\/extend-lock$/;
-const RE_JOB_MOVE_TO_WAIT = /^\/jobs\/([^/]+)\/move-to-wait$/;
 const RE_JOB_CUSTOM_ID = /^\/jobs\/custom\/([^/]+)$/;
 const RE_JOB_BY_ID = /^\/jobs\/([^/]+)$/;
 const RE_JOB_ACK = /^\/jobs\/([^/]+)\/ack$/;
 const RE_JOB_FAIL = /^\/jobs\/([^/]+)\/fail$/;
-/** Job management: promote, update, state, result, progress, priority, discard */
-async function routeJobManagement(req, path, method, ctx, cors) {
-    const promoteMatch = path.match(RE_JOB_PROMOTE);
-    if (promoteMatch && method === 'POST') {
-        const r = await handleCommand({ cmd: 'Promote', id: promoteMatch[1] }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
-    }
-    const dataMatch = path.match(RE_JOB_DATA);
-    if (dataMatch && method === 'PUT') {
-        let body;
-        try {
-            body = (await req.json());
-        }
-        catch {
-            return jsonResponse({ ok: false, error: 'Invalid JSON body' }, 400, cors);
-        }
-        const r = await handleCommand({ cmd: 'Update', id: dataMatch[1], data: body['data'] }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
-    }
-    const stateMatch = path.match(RE_JOB_STATE);
-    if (stateMatch && method === 'GET') {
-        const r = await handleCommand({ cmd: 'GetState', id: stateMatch[1] }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 404, cors);
-    }
-    const resultMatch = path.match(RE_JOB_RESULT);
-    if (resultMatch && method === 'GET') {
-        const r = await handleCommand({ cmd: 'GetResult', id: resultMatch[1] }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 404, cors);
-    }
-    const progressMatch = path.match(RE_JOB_PROGRESS);
-    if (progressMatch && method === 'GET') {
-        const r = await handleCommand({ cmd: 'GetProgress', id: progressMatch[1] }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 404, cors);
-    }
-    if (progressMatch && method === 'POST') {
-        const body = await parseJsonBody(req, cors);
-        if (body instanceof Response)
-            return body;
-        const r = await handleCommand({
-            cmd: 'Progress',
-            id: progressMatch[1],
-            progress: body['progress'],
-            message: body['message'],
-        }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
-    }
-    const priorityMatch = path.match(RE_JOB_PRIORITY);
-    if (priorityMatch && method === 'PUT') {
-        const body = await parseJsonBody(req, cors);
-        if (body instanceof Response)
-            return body;
-        const r = await handleCommand({
-            cmd: 'ChangePriority',
-            id: priorityMatch[1],
-            priority: body['priority'],
-            lifo: body['lifo'],
-        }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
-    }
-    const discardMatch = path.match(RE_JOB_DISCARD);
-    if (discardMatch && method === 'POST') {
-        const r = await handleCommand({ cmd: 'Discard', id: discardMatch[1] }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
-    }
-    return null;
-}
-/** Job advanced: delay, children, logs, heartbeat, wait, lock, move-to-wait */
-async function routeJobAdvanced(req, path, method, ctx, cors) {
-    const moveDelayedMatch = path.match(RE_JOB_MOVE_DELAYED);
-    if (moveDelayedMatch && method === 'POST') {
-        const body = await parseJsonBody(req, cors);
-        if (body instanceof Response)
-            return body;
-        const r = await handleCommand({
-            cmd: 'MoveToDelayed',
-            id: moveDelayedMatch[1],
-            delay: body['delay'],
-        }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
-    }
-    const changeDelayMatch = path.match(RE_JOB_DELAY);
-    if (changeDelayMatch && method === 'PUT') {
-        const body = await parseJsonBody(req, cors);
-        if (body instanceof Response)
-            return body;
-        const r = await handleCommand({
-            cmd: 'ChangeDelay',
-            id: changeDelayMatch[1],
-            delay: body['delay'],
-        }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
-    }
-    const childrenMatch = path.match(RE_JOB_CHILDREN);
-    if (childrenMatch && method === 'GET') {
-        const r = await handleCommand({ cmd: 'GetChildrenValues', id: childrenMatch[1] }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 404, cors);
-    }
-    const logsMatch = path.match(RE_JOB_LOGS);
-    if (logsMatch && method === 'GET') {
-        const r = await handleCommand({ cmd: 'GetLogs', id: logsMatch[1] }, ctx);
-        return jsonResponse(r, 200, cors);
-    }
-    if (logsMatch && method === 'POST') {
-        const body = await parseJsonBody(req, cors);
-        if (body instanceof Response)
-            return body;
-        const r = await handleCommand({
-            cmd: 'AddLog',
-            id: logsMatch[1],
-            message: body['message'],
-            level: body['level'],
-        }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
-    }
-    if (logsMatch && method === 'DELETE') {
-        const r = await handleCommand({ cmd: 'ClearLogs', id: logsMatch[1] }, ctx);
-        return jsonResponse(r, 200, cors);
-    }
-    const heartbeatMatch = path.match(RE_JOB_HEARTBEAT);
-    if (heartbeatMatch && method === 'POST') {
-        const body = await parseJsonBody(req, cors);
-        if (body instanceof Response)
-            return body;
-        const r = await handleCommand({
-            cmd: 'JobHeartbeat',
-            id: heartbeatMatch[1],
-            token: body['token'],
-            duration: body['duration'],
-        }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
-    }
-    const waitMatch = path.match(RE_JOB_WAIT);
-    if (waitMatch && method === 'POST') {
-        const body = await parseJsonBody(req, cors);
-        if (body instanceof Response)
-            return body;
-        const r = await handleCommand({
-            cmd: 'WaitJob',
-            id: waitMatch[1],
-            timeout: body['timeout'],
-        }, ctx);
-        return jsonResponse(r, 200, cors);
-    }
-    const extendLockMatch = path.match(RE_JOB_EXTEND_LOCK);
-    if (extendLockMatch && method === 'POST') {
-        const body = await parseJsonBody(req, cors);
-        if (body instanceof Response)
-            return body;
-        const r = await handleCommand({
-            cmd: 'ExtendLock',
-            id: extendLockMatch[1],
-            duration: body['duration'],
-            token: body['token'],
-        }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
-    }
-    const moveToWaitMatch = path.match(RE_JOB_MOVE_TO_WAIT);
-    if (moveToWaitMatch && method === 'POST') {
-        const r = await handleCommand({ cmd: 'MoveToWait', id: moveToWaitMatch[1] }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
-    }
-    return null;
-}
-/** Route /jobs/* requests. Returns Response or null if no match. */
-export async function routeJobRoutes(req, path, method, ctx, cors) {
-    // Batch endpoints FIRST (exact match, before generic /jobs/:id pattern)
+export async function routeJobRoutes(request, path, method, context, cors) {
     if (path === '/jobs/ack-batch' && method === 'POST') {
-        const body = await parseJsonBody(req, cors);
+        const body = await parseJsonBody(request, cors);
         if (body instanceof Response)
             return body;
-        const r = await handleCommand({
+        const result = await handleCommand({
             cmd: 'ACKB',
             ids: body['ids'],
             results: body['results'],
             tokens: body['tokens'],
-        }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
+        }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
     }
     if (path === '/jobs/extend-locks' && method === 'POST') {
-        const body = await parseJsonBody(req, cors);
+        const body = await parseJsonBody(request, cors);
         if (body instanceof Response)
             return body;
-        const r = await handleCommand({
+        const result = await handleCommand({
             cmd: 'ExtendLocks',
             ids: body['ids'],
             tokens: body['tokens'],
             durations: body['durations'],
-        }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
+        }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
     }
     if (path === '/jobs/heartbeat-batch' && method === 'POST') {
-        const body = await parseJsonBody(req, cors);
+        const body = await parseJsonBody(request, cors);
         if (body instanceof Response)
             return body;
-        const r = await handleCommand({
+        const result = await handleCommand({
             cmd: 'JobHeartbeatB',
             ids: body['ids'],
             tokens: body['tokens'],
-        }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
+        }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
     }
-    // GET /jobs/custom/:customId (before generic /jobs/:id)
     const customIdMatch = path.match(RE_JOB_CUSTOM_ID);
     if (customIdMatch && method === 'GET') {
         const customId = decodeURIComponent(customIdMatch[1]);
-        const r = await handleCommand({ cmd: 'GetJobByCustomId', customId }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 404, cors);
+        const result = await handleCommand({ cmd: 'GetJobByCustomId', customId }, context);
+        return jsonResponse(result, result.ok ? 200 : 404, cors);
     }
-    // GET/DELETE /jobs/:id (generic, after specific paths)
     const jobMatch = path.match(RE_JOB_BY_ID);
     if (jobMatch) {
         const id = jobMatch[1];
         if (method === 'GET') {
-            const r = await handleCommand({ cmd: 'GetJob', id }, ctx);
-            return jsonResponse(r, r.ok ? 200 : 404, cors);
+            const result = await handleCommand({ cmd: 'GetJob', id }, context);
+            return jsonResponse(result, result.ok ? 200 : 404, cors);
         }
         if (method === 'DELETE') {
-            const r = await handleCommand({ cmd: 'Cancel', id }, ctx);
-            return jsonResponse(r, 200, cors);
+            const result = await handleCommand({ cmd: 'Cancel', id }, context);
+            return jsonResponse(result, 200, cors);
         }
     }
-    // POST /jobs/:id/ack
     const ackMatch = path.match(RE_JOB_ACK);
     if (ackMatch && method === 'POST') {
-        const body = await parseJsonBody(req, cors);
+        const body = await parseJsonBody(request, cors);
         if (body instanceof Response)
             return body;
-        const r = await handleCommand({
+        const result = await handleCommand({
             cmd: 'ACK',
             id: ackMatch[1],
             result: body['result'],
             token: body['token'],
-        }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
+        }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
     }
-    // POST /jobs/:id/fail
     const failMatch = path.match(RE_JOB_FAIL);
     if (failMatch && method === 'POST') {
-        const body = await parseJsonBody(req, cors);
+        const body = await parseJsonBody(request, cors);
         if (body instanceof Response)
             return body;
-        const r = await handleCommand({
+        const result = await handleCommand({
             cmd: 'FAIL',
             id: failMatch[1],
             error: body['error'],
             token: body['token'],
             unrecoverable: body['unrecoverable'],
-            // Validated (string[] only, capped) in handleFail (#74)
             stack: body['stack'],
-        }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
+        }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
     }
-    // Delegate to sub-routers
-    const mgmt = await routeJobManagement(req, path, method, ctx, cors);
-    if (mgmt)
-        return mgmt;
-    return routeJobAdvanced(req, path, method, ctx, cors);
+    const management = await routeJobManagement(request, path, method, context, cors);
+    if (management)
+        return management;
+    return routeJobAdvanced(request, path, method, context, cors);
 }

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

@@ -1,7 +1,2 @@
-/**
- * HTTP Routes - Queue operations
- * All /queues/:queue/* endpoints + /queues list
- */
 import type { HandlerContext } from './types';
-/** Route /queues/* requests. Returns Response or null if no match. */
-export declare function routeQueueRoutes(req: Request, path: string, method: string, ctx: HandlerContext, cors: Set<string>): Promise<Response | null>;
+export declare function routeQueueRoutes(request: Request, path: string, method: string, context: HandlerContext, cors: Set<string>): Promise<Response | null>;

package/dist/infrastructure/server/httpRouteQueues.js

@@ -1,14 +1,6 @@
-/**
- * HTTP Routes - Queue operations
- * All /queues/:queue/* endpoints + /queues list
- */
 import { handleCommand } from './handler';
+import { routeQueueJobOperations } from './http-routes/queueJobs';
 import { jsonResponse, parseJsonBody } from './httpEndpoints';
-// Pre-compiled regex patterns for URL matching
-const RE_QUEUE_JOBS = /^\/queues\/([^/]+)\/jobs$/;
-const RE_QUEUE_JOBS_BULK = /^\/queues\/([^/]+)\/jobs\/bulk$/;
-const RE_QUEUE_JOBS_PULL_BATCH = /^\/queues\/([^/]+)\/jobs\/pull-batch$/;
-const RE_QUEUE_JOBS_LIST = /^\/queues\/([^/]+)\/jobs\/list$/;
 const RE_QUEUE_COUNTS = /^\/queues\/([^/]+)\/counts$/;
 const RE_QUEUE_COUNT = /^\/queues\/([^/]+)\/count$/;
 const RE_QUEUE_PRIORITY_COUNTS = /^\/queues\/([^/]+)\/priority-counts$/;
@@ -21,258 +13,100 @@ const RE_QUEUE_CLEAN = /^\/queues\/([^/]+)\/clean$/;
 const RE_QUEUE_PROMOTE_JOBS = /^\/queues\/([^/]+)\/promote-jobs$/;
 const RE_QUEUE_RETRY_COMPLETED = /^\/queues\/([^/]+)\/retry-completed$/;
 const RE_QUEUE_WORKERS = /^\/queues\/([^/]+)\/workers$/;
-/** Route push/pull/bulk job operations */
-async function routeJobOps(req, path, method, ctx, cors) {
-    // POST/GET /queues/:queue/jobs - push/pull
-    const queueJobsMatch = path.match(RE_QUEUE_JOBS);
-    if (queueJobsMatch) {
-        const queue = decodeURIComponent(queueJobsMatch[1]);
-        if (method === 'POST') {
-            let body;
-            try {
-                body = (await req.json());
-            }
-            catch {
-                return jsonResponse({ ok: false, error: 'Invalid JSON body' }, 400, cors);
-            }
-            const cmd = {
-                cmd: 'PUSH',
-                queue,
-                data: body.data,
-                priority: body.priority,
-                delay: body.delay,
-                maxAttempts: body.maxAttempts ?? body.attempts,
-                backoff: body.backoff,
-                timeout: body.timeout,
-                jobId: body.jobId,
-                removeOnComplete: body.removeOnComplete,
-                removeOnFail: body.removeOnFail,
-                durable: body.durable,
-                ttl: body.ttl,
-                uniqueKey: body.uniqueKey,
-                groupId: body.groupId,
-                dependsOn: body.dependsOn,
-                tags: body.tags,
-                lifo: body.lifo,
-                repeat: body.repeat,
-            };
-            const r = await handleCommand(cmd, ctx);
-            return jsonResponse(r, r.ok ? 200 : 400, cors);
-        }
-        if (method === 'GET') {
-            const timeout = parseInt(new URL(req.url).searchParams.get('timeout') ?? '0', 10);
-            const r = await handleCommand({ cmd: 'PULL', queue, timeout }, ctx);
-            return jsonResponse(r, 200, cors);
-        }
-    }
-    // POST /queues/:queue/jobs/bulk - bulk push
-    const bulkMatch = path.match(RE_QUEUE_JOBS_BULK);
-    if (bulkMatch && method === 'POST') {
-        const queue = decodeURIComponent(bulkMatch[1]);
-        let body;
-        try {
-            body = (await req.json());
-        }
-        catch {
-            return jsonResponse({ ok: false, error: 'Invalid JSON body' }, 400, cors);
-        }
-        const r = await handleCommand({
-            cmd: 'PUSHB',
-            queue,
-            jobs: body['jobs'],
-        }, ctx);
-        return jsonResponse(r, r.ok ? 200 : 400, cors);
-    }
-    // POST /queues/:queue/jobs/pull-batch
-    const pullBatchMatch = path.match(RE_QUEUE_JOBS_PULL_BATCH);
-    if (pullBatchMatch && method === 'POST') {
-        const queue = decodeURIComponent(pullBatchMatch[1]);
-        const body = await parseJsonBody(req, cors);
-        if (body instanceof Response)
-            return body;
-        const r = await handleCommand({
-            cmd: 'PULLB',
-            queue,
-            count: body['count'],
-            timeout: body['timeout'],
-            owner: body['owner'],
-            lockTtl: body['lockTtl'],
-        }, ctx);
-        return jsonResponse(r, 200, cors);
-    }
-    // GET /queues/:queue/jobs/list?state=&limit=&offset=
-    const listMatch = path.match(RE_QUEUE_JOBS_LIST);
-    if (listMatch && method === 'GET') {
-        const queue = decodeURIComponent(listMatch[1]);
-        const url = new URL(req.url);
-        // Accept `state`, `status` (dashboard/REST convention), and `states` as
-        // aliases, each repeatable and comma-separated. Previously only `state` was
-        // read, so `?status=failed` silently fell through to an unfiltered list and
-        // returned the whole queue (#95). A state name never contains a comma, so
-        // splitting is safe.
-        const stateValues = [
-            ...url.searchParams.getAll('state'),
-            ...url.searchParams.getAll('status'),
-            ...url.searchParams.getAll('states'),
-        ]
-            .flatMap((v) => v.split(','))
-            .map((s) => s.trim())
-            .filter(Boolean);
-        const state = stateValues.length === 0
-            ? undefined
-            : stateValues.length === 1
-                ? stateValues[0]
-                : stateValues;
-        const limitParam = url.searchParams.get('limit');
-        const offsetParam = url.searchParams.get('offset');
-        const limit = limitParam ? parseInt(limitParam, 10) : undefined;
-        const offset = offsetParam ? parseInt(offsetParam, 10) : undefined;
-        const r = await handleCommand({
-            cmd: 'GetJobs',
-            queue,
-            state,
-            limit,
-            offset,
-        }, ctx);
-        return jsonResponse(r, 200, cors);
-    }
-    return null;
-}
-/** Route /queues/* requests. Returns Response or null if no match. */
-export async function routeQueueRoutes(req, path, method, ctx, cors) {
-    // GET /queues - list all queues
+export async function routeQueueRoutes(request, path, method, context, cors) {
     if (path === '/queues' && method === 'GET') {
-        const r = await handleCommand({ cmd: 'ListQueues' }, ctx);
-        return jsonResponse(r, 200, cors);
+        return jsonResponse(await handleCommand({ cmd: 'ListQueues' }, context), 200, cors);
     }
-    // GET /queues/summary - all queues with paused + counts in one call
     if (path === '/queues/summary' && method === 'GET') {
-        const summary = ctx.queueManager.getQueuesSummary();
-        return jsonResponse(summary, 200, cors);
+        return jsonResponse(context.queueManager.getQueuesSummary(), 200, cors);
     }
-    // Delegate push/pull/bulk/list operations
-    const jobOpsResult = await routeJobOps(req, path, method, ctx, cors);
-    if (jobOpsResult)
-        return jobOpsResult;
-    // GET /queues/:queue/workers
+    const jobOperations = await routeQueueJobOperations(request, path, method, context, cors);
+    if (jobOperations)
+        return jobOperations;
     const queueWorkersMatch = path.match(RE_QUEUE_WORKERS);
     if (queueWorkersMatch && method === 'GET') {
         const queue = decodeURIComponent(queueWorkersMatch[1]);
-        const workers = ctx.queueManager.workerManager.getForQueue(queue);
+        const workers = context.queueManager.workerManager.getForQueue(queue);
         return jsonResponse({
             ok: true,
-            workers: workers.map((w) => ({
-                id: w.id,
-                name: w.name,
-                queues: w.queues,
-                concurrency: w.concurrency,
-                registeredAt: w.registeredAt,
-                lastSeen: w.lastSeen,
-                activeJobs: w.activeJobs,
-                processedJobs: w.processedJobs,
-                failedJobs: w.failedJobs,
+            workers: workers.map((worker) => ({
+                id: worker.id,
+                name: worker.name,
+                queues: worker.queues,
+                concurrency: worker.concurrency,
+                registeredAt: worker.registeredAt,
+                lastSeen: worker.lastSeen,
+                activeJobs: worker.activeJobs,
+                processedJobs: worker.processedJobs,
+                failedJobs: worker.failedJobs,
             })),
         }, 200, cors);
     }
-    // GET /queues/:queue/counts
     const countsMatch = path.match(RE_QUEUE_COUNTS);
     if (countsMatch && method === 'GET') {
         const queue = decodeURIComponent(countsMatch[1]);
-        const r = await handleCommand({ cmd: 'GetJobCounts', queue }, ctx);
-        return jsonResponse(r, 200, cors);
+        return jsonResponse(await handleCommand({ cmd: 'GetJobCounts', queue }, context), 200, cors);
     }
-    // GET /queues/:queue/count
     const countMatch = path.match(RE_QUEUE_COUNT);
     if (countMatch && method === 'GET') {
         const queue = decodeURIComponent(countMatch[1]);
-        const r = await handleCommand({ cmd: 'Count', queue }, ctx);
-        return jsonResponse(r, 200, cors);
+        return jsonResponse(await handleCommand({ cmd: 'Count', queue }, context), 200, cors);
     }
-    // GET /queues/:queue/priority-counts
-    const priCountsMatch = path.match(RE_QUEUE_PRIORITY_COUNTS);
-    if (priCountsMatch && method === 'GET') {
-        const queue = decodeURIComponent(priCountsMatch[1]);
-        const r = await handleCommand({ cmd: 'GetCountsPerPriority', queue }, ctx);
-        return jsonResponse(r, 200, cors);
+    const priorityCountsMatch = path.match(RE_QUEUE_PRIORITY_COUNTS);
+    if (priorityCountsMatch && method === 'GET') {
+        const queue = decodeURIComponent(priorityCountsMatch[1]);
+        return jsonResponse(await handleCommand({ cmd: 'GetCountsPerPriority', queue }, context), 200, cors);
     }
-    // GET /queues/:queue/paused
     const pausedMatch = path.match(RE_QUEUE_PAUSED);
     if (pausedMatch && method === 'GET') {
         const queue = decodeURIComponent(pausedMatch[1]);
-        const r = await handleCommand({ cmd: 'IsPaused', queue }, ctx);
-        return jsonResponse(r, 200, cors);
-    }
-    // POST /queues/:queue/pause
-    const pauseMatch = path.match(RE_QUEUE_PAUSE);
-    if (pauseMatch && method === 'POST') {
-        const queue = decodeURIComponent(pauseMatch[1]);
-        const r = await handleCommand({ cmd: 'Pause', queue }, ctx);
-        return jsonResponse(r, 200, cors);
-    }
-    // POST /queues/:queue/resume
-    const resumeMatch = path.match(RE_QUEUE_RESUME);
-    if (resumeMatch && method === 'POST') {
-        const queue = decodeURIComponent(resumeMatch[1]);
-        const r = await handleCommand({ cmd: 'Resume', queue }, ctx);
-        return jsonResponse(r, 200, cors);
-    }
-    // POST /queues/:queue/drain
-    const drainMatch = path.match(RE_QUEUE_DRAIN);
-    if (drainMatch && method === 'POST') {
-        const queue = decodeURIComponent(drainMatch[1]);
-        const r = await handleCommand({ cmd: 'Drain', queue }, ctx);
-        return jsonResponse(r, 200, cors);
-    }
-    // POST /queues/:queue/obliterate
-    const obliterateMatch = path.match(RE_QUEUE_OBLITERATE);
-    if (obliterateMatch && method === 'POST') {
-        const queue = decodeURIComponent(obliterateMatch[1]);
-        const r = await handleCommand({ cmd: 'Obliterate', queue }, ctx);
-        return jsonResponse(r, 200, cors);
+        return jsonResponse(await handleCommand({ cmd: 'IsPaused', queue }, context), 200, cors);
+    }
+    const controlRoutes = [
+        [RE_QUEUE_PAUSE, 'POST', 'Pause'],
+        [RE_QUEUE_RESUME, 'POST', 'Resume'],
+        [RE_QUEUE_DRAIN, 'POST', 'Drain'],
+        [RE_QUEUE_OBLITERATE, 'POST', 'Obliterate'],
+    ];
+    for (const [pattern, expectedMethod, commandName] of controlRoutes) {
+        const match = path.match(pattern);
+        if (match && method === expectedMethod) {
+            const queue = decodeURIComponent(match[1]);
+            return jsonResponse(await handleCommand({ cmd: commandName, queue }, context), 200, cors);
+        }
     }
-    // POST /queues/:queue/clean
     const cleanMatch = path.match(RE_QUEUE_CLEAN);
     if (cleanMatch && method === 'POST') {
         const queue = decodeURIComponent(cleanMatch[1]);
-        const body = await parseJsonBody(req, cors);
+        const body = await parseJsonBody(request, cors);
         if (body instanceof Response)
             return body;
-        const r = await handleCommand({
+        const result = await handleCommand({
             cmd: 'Clean',
             queue,
             grace: typeof body['grace'] === 'number' ? body['grace'] : 0,
             state: body['state'],
             limit: body['limit'],
-        }, ctx);
-        return jsonResponse(r, 200, cors);
+        }, context);
+        return jsonResponse(result, 200, cors);
     }
-    // POST /queues/:queue/promote-jobs
     const promoteJobsMatch = path.match(RE_QUEUE_PROMOTE_JOBS);
     if (promoteJobsMatch && method === 'POST') {
         const queue = decodeURIComponent(promoteJobsMatch[1]);
-        const body = await parseJsonBody(req, cors);
+        const body = await parseJsonBody(request, cors);
         if (body instanceof Response)
             return body;
-        const r = await handleCommand({
-            cmd: 'PromoteJobs',
-            queue,
-            count: body['count'],
-        }, ctx);
-        return jsonResponse(r, 200, cors);
+        const result = await handleCommand({ cmd: 'PromoteJobs', queue, count: body['count'] }, context);
+        return jsonResponse(result, 200, cors);
     }
-    // POST /queues/:queue/retry-completed
-    const retryCompMatch = path.match(RE_QUEUE_RETRY_COMPLETED);
-    if (retryCompMatch && method === 'POST') {
-        const queue = decodeURIComponent(retryCompMatch[1]);
-        const body = await parseJsonBody(req, cors);
+    const retryCompletedMatch = path.match(RE_QUEUE_RETRY_COMPLETED);
+    if (retryCompletedMatch && method === 'POST') {
+        const queue = decodeURIComponent(retryCompletedMatch[1]);
+        const body = await parseJsonBody(request, cors);
         if (body instanceof Response)
             return body;
-        const r = await handleCommand({
-            cmd: 'RetryCompleted',
-            queue,
-            id: body['id'],
-        }, ctx);
-        return jsonResponse(r, 200, cors);
+        const result = await handleCommand({ cmd: 'RetryCompleted', queue, id: body['id'] }, context);
+        return jsonResponse(result, 200, cors);
     }
     return null;
 }

package/dist/infrastructure/server/httpRouteResources.js

@@ -30,6 +30,7 @@ export async function routeResourceRoutes(req, path, method, ctx, cors) {
         const r = await handleCommand({
             cmd: 'Cron',
             name: body['name'],
+            jobName: typeof body['jobName'] === 'string' ? body['jobName'] : 'default',
             queue: body['queue'],
             data: body['data'],
             schedule: body['schedule'],