bunqueue 2.8.53 → 2.8.56

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

@@ -1,222 +1,4 @@
-/**
- * Monitoring Handlers
- * Handles logs, workers, webhooks, and prometheus metrics
- */
-import { jobId } from '../../../domain/types/job';
-import { VERSION } from '../../../shared/version';
-import * as resp from '../../../domain/types/response';
-import { validateWebhookUrl } from '../protocol';
-import { WEBHOOK_EVENTS } from '../../../domain/types/webhook';
-// ============ Job Logs ============
-export function handleAddLog(cmd, ctx, reqId) {
-    const jid = jobId(cmd.id);
-    const level = cmd.level ?? 'info';
-    const success = ctx.queueManager.addLog(jid, cmd.message, level);
-    if (success) {
-        return resp.data({ added: true }, reqId);
-    }
-    return resp.error('Job not found', reqId);
-}
-export function handleGetLogs(cmd, ctx, reqId) {
-    const jid = jobId(cmd.id);
-    const all = ctx.queueManager.getLogs(jid);
-    // Honor optional pagination (start/end inclusive) the client already sends.
-    const total = all.length;
-    const logs = cmd.start === undefined && cmd.end === undefined
-        ? all
-        : all.slice(cmd.start ?? 0, (cmd.end ?? total - 1) + 1);
-    return resp.data({ logs, count: total }, reqId);
-}
-// ============ Worker Heartbeat ============
-export function handleHeartbeat(cmd, ctx, reqId) {
-    const stats = cmd.activeJobs !== undefined || cmd.processed !== undefined || cmd.failed !== undefined
-        ? { activeJobs: cmd.activeJobs, processed: cmd.processed, failed: cmd.failed }
-        : undefined;
-    const success = ctx.queueManager.workerManager.heartbeat(cmd.id, stats);
-    if (success) {
-        ctx.queueManager.emitDashboardEvent('worker:heartbeat', { workerId: cmd.id });
-        return resp.data({ ok: true }, reqId);
-    }
-    return resp.error('Worker not found', reqId);
-}
-// ============ Job Heartbeat (for stall detection & lock renewal) ============
-export function handleJobHeartbeat(cmd, ctx, reqId) {
-    const jid = jobId(cmd.id);
-    // If duration is specified, extend lock with that duration
-    if (cmd.duration && cmd.token) {
-        const success = ctx.queueManager.renewJobLock(jid, cmd.token, cmd.duration);
-        if (success)
-            return resp.data({ ok: true }, reqId);
-        return resp.error('Job not found or not active (or invalid token)', reqId);
-    }
-    // Standard heartbeat
-    const success = ctx.queueManager.jobHeartbeat(jid, cmd.token);
-    if (success) {
-        return resp.data({ ok: true }, reqId);
-    }
-    return resp.error('Job not found or not active (or invalid token)', reqId);
-}
-export function handleJobHeartbeatBatch(cmd, ctx, reqId) {
-    const ids = cmd.ids.map((id) => jobId(id));
-    // Pass tokens to renew locks if provided
-    const count = ctx.queueManager.jobHeartbeatBatch(ids, cmd.tokens);
-    return resp.data({ ok: true, count }, reqId);
-}
-// ============ Ping (health check) ============
-export function handlePing(_cmd, _ctx, reqId) {
-    return resp.data({ pong: true, time: Date.now() }, reqId);
-}
-// ============ Hello (protocol negotiation) ============
-/** Current protocol version */
-export const PROTOCOL_VERSION = 2;
-/** Supported capabilities */
-export const SUPPORTED_CAPABILITIES = ['pipelining'];
-export function handleHello(_cmd, _ctx, reqId) {
-    return resp.hello(PROTOCOL_VERSION, SUPPORTED_CAPABILITIES, 'bunqueue', VERSION, reqId);
-}
-// ============ Worker Management ============
-export function handleRegisterWorker(cmd, ctx, reqId) {
-    const worker = ctx.queueManager.registerWorker(cmd.name, cmd.queues, cmd.concurrency, {
-        workerId: cmd.workerId,
-        hostname: cmd.hostname,
-        pid: cmd.pid,
-        startedAt: cmd.startedAt,
-        clientId: ctx.clientId,
-    });
-    return resp.data({
-        workerId: worker.id,
-        name: worker.name,
-        queues: worker.queues,
-        concurrency: worker.concurrency,
-        hostname: worker.hostname,
-        pid: worker.pid,
-        status: 'active',
-        registeredAt: worker.registeredAt,
-        lastSeen: worker.lastSeen,
-        activeJobs: worker.activeJobs,
-        processedJobs: worker.processedJobs,
-        failedJobs: worker.failedJobs,
-        currentJob: worker.currentJob,
-    }, reqId);
-}
-export function handleUnregisterWorker(cmd, ctx, reqId) {
-    const success = ctx.queueManager.unregisterWorker(cmd.workerId);
-    if (success) {
-        return resp.data({ removed: true }, reqId);
-    }
-    return resp.error('Worker not found', reqId);
-}
-/** Worker timeout for status computation */
-const WORKER_TIMEOUT_MS = parseInt(Bun.env.WORKER_TIMEOUT_MS ?? '30000', 10);
-/** Compute worker status from lastSeen timestamp */
-function computeWorkerStatus(lastSeen, now) {
-    return now - lastSeen < WORKER_TIMEOUT_MS ? 'active' : 'stale';
-}
-export function handleListWorkers(_cmd, ctx, reqId) {
-    const workers = ctx.queueManager.workerManager.list();
-    const now = Date.now();
-    return resp.data({
-        workers: workers.map((w) => ({
-            id: w.id,
-            name: w.name,
-            queues: w.queues,
-            concurrency: w.concurrency,
-            hostname: w.hostname,
-            pid: w.pid,
-            status: computeWorkerStatus(w.lastSeen, now),
-            registeredAt: w.registeredAt,
-            lastSeen: w.lastSeen,
-            activeJobs: w.activeJobs,
-            processedJobs: w.processedJobs,
-            failedJobs: w.failedJobs,
-            currentJob: w.currentJob,
-            uptime: now - w.registeredAt,
-        })),
-        stats: ctx.queueManager.workerManager.getStats(),
-    }, reqId);
-}
-// ============ Webhooks ============
-export function handleAddWebhook(cmd, ctx, reqId) {
-    // Validate webhook URL to prevent SSRF
-    const urlError = validateWebhookUrl(cmd.url);
-    if (urlError)
-        return resp.error(urlError, reqId);
-    // Reject events that are never triggered — a webhook subscribed to a dead
-    // event would be created "ok" and then never fire (silent failure).
-    const invalidEvents = cmd.events.filter((e) => !WEBHOOK_EVENTS.includes(e));
-    if (invalidEvents.length > 0) {
-        return resp.error(`Invalid webhook event(s): ${invalidEvents.join(', ')}. Valid: ${WEBHOOK_EVENTS.join(', ')}`, reqId);
-    }
-    const webhook = ctx.queueManager.webhookManager.add(cmd.url, cmd.events, cmd.queue, cmd.secret);
-    ctx.queueManager.emitDashboardEvent('webhook:added', {
-        id: webhook.id,
-        url: webhook.url,
-        events: webhook.events,
-    });
-    return resp.data({
-        webhookId: webhook.id,
-        url: webhook.url,
-        events: webhook.events,
-        queue: webhook.queue,
-        createdAt: webhook.createdAt,
-    }, reqId);
-}
-export function handleRemoveWebhook(cmd, ctx, reqId) {
-    const success = ctx.queueManager.webhookManager.remove(cmd.webhookId);
-    if (success) {
-        ctx.queueManager.emitDashboardEvent('webhook:removed', { id: cmd.webhookId });
-        return resp.data({ removed: true }, reqId);
-    }
-    return resp.error('Webhook not found', reqId);
-}
-export function handleListWebhooks(_cmd, ctx, reqId) {
-    const webhooks = ctx.queueManager.webhookManager.list();
-    return resp.data({
-        webhooks: webhooks.map((w) => ({
-            id: w.id,
-            url: w.url,
-            events: w.events,
-            queue: w.queue,
-            createdAt: w.createdAt,
-            lastTriggered: w.lastTriggered,
-            successCount: w.successCount,
-            failureCount: w.failureCount,
-            enabled: w.enabled,
-        })),
-        stats: ctx.queueManager.webhookManager.getStats(),
-    }, reqId);
-}
-// ============ Prometheus Metrics ============
-export function handlePrometheus(_cmd, ctx, reqId) {
-    const metrics = ctx.queueManager.getPrometheusMetrics();
-    return resp.data({ metrics }, reqId);
-}
-// ============ Clear Logs ============
-export function handleClearLogs(cmd, ctx, reqId) {
-    ctx.queueManager.clearLogs(jobId(cmd.id), cmd.keepLogs);
-    return resp.ok(undefined, reqId);
-}
-// ============ Extend Lock ============
-export async function handleExtendLock(cmd, ctx, reqId) {
-    const success = await ctx.queueManager.extendLock(jobId(cmd.id), cmd.token ?? null, cmd.duration);
-    return success ? resp.ok(undefined, reqId) : resp.error('Lock not found or invalid token', reqId);
-}
-export async function handleExtendLocks(cmd, ctx, reqId) {
-    let count = 0;
-    for (let i = 0; i < cmd.ids.length; i++) {
-        const success = await ctx.queueManager.extendLock(jobId(cmd.ids[i]), cmd.tokens[i] ?? null, cmd.durations[i]);
-        if (success)
-            count++;
-    }
-    return { ok: true, count, reqId };
-}
-// ============ Set Webhook Enabled ============
-export function handleSetWebhookEnabled(cmd, ctx, reqId) {
-    const success = ctx.queueManager.webhookManager.setEnabled(cmd.id, cmd.enabled);
-    return success ? resp.ok(undefined, reqId) : resp.error('Webhook not found', reqId);
-}
-// ============ Compact Memory ============
-export function handleCompactMemory(_cmd, ctx, reqId) {
-    ctx.queueManager.compactMemory();
-    return resp.ok(undefined, reqId);
-}
+export { handleAddLog, handleGetLogs, handleHeartbeat, handleHello, handleJobHeartbeat, handleJobHeartbeatBatch, handlePing, PROTOCOL_VERSION, SUPPORTED_CAPABILITIES, } from './monitoring/health';
+export { handleClearLogs, handleCompactMemory, handleExtendLock, handleExtendLocks, handlePrometheus, } from './monitoring/operations';
+export { handleAddWebhook, handleListWebhooks, handleRemoveWebhook, handleSetWebhookEnabled, } from './monitoring/webhooks';
+export { handleListWorkers, handleRegisterWorker, handleUnregisterWorker, } from './monitoring/workers';

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

@@ -4,7 +4,7 @@
  * validateJobData/validateJobOptions bounds and the same dependsOn
  * existence gate handlePush enforces (core.ts).
  */
-import type { JobInput } from '../../../domain/types/job';
+import { type JobInput } from '../../../domain/types/job';
 import type { HandlerContext } from '../types';
 /**
  * Validate every job of a PUSHB batch. Returns an error message naming the

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

@@ -4,6 +4,7 @@
  * validateJobData/validateJobOptions bounds and the same dependsOn
  * existence gate handlePush enforces (core.ts).
  */
+import { normalizeLegacyJobPayload } from '../../../domain/types/job';
 import { validateJobData, validateJobOptions } from '../protocol';
 /**
  * Validate every job of a PUSHB batch. Returns an error message naming the
@@ -35,6 +36,12 @@ export function validatePushBatchJobs(jobs, ctx) {
     }
     for (let i = 0; i < jobs.length; i++) {
         const job = jobs[i];
+        try {
+            normalizeLegacyJobPayload(job);
+        }
+        catch (error) {
+            return `jobs[${i}]: ${error instanceof Error ? error.message : String(error)}`;
+        }
         const dataError = validateJobData(job.data);
         if (dataError)
             return `jobs[${i}]: ${dataError}`;

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

@@ -4,7 +4,16 @@
  */
 import * as resp from '../../../domain/types/response';
 import { jobId } from '../../../domain/types/job';
+import { lastFailedReason } from '../../../domain/job/terminal';
 import { pausedView } from '../../../shared/pausedView';
+function jobView(ctx, job, state) {
+    return {
+        ...job,
+        ...(state === undefined ? {} : { state }),
+        returnvalue: ctx.queueManager.getResult(job.id),
+        failedReason: lastFailedReason(job),
+    };
+}
 /** Handle GetJob command */
 export async function handleGetJob(cmd, ctx, reqId) {
     const jid = jobId(cmd.id);
@@ -12,7 +21,7 @@ export async function handleGetJob(cmd, ctx, reqId) {
     if (!job)
         return resp.error('Job not found', reqId);
     const state = await ctx.queueManager.getJobState(jid);
-    return { ok: true, job: { ...job, state }, reqId };
+    return { ok: true, job: jobView(ctx, job, state), reqId };
 }
 /** Handle GetState command */
 export async function handleGetState(cmd, ctx, reqId) {
@@ -51,7 +60,7 @@ export function handleGetCountsPerPriority(cmd, ctx, reqId) {
 /** Handle GetJobByCustomId command */
 export function handleGetJobByCustomId(cmd, ctx, reqId) {
     const job = ctx.queueManager.getJobByCustomId(cmd.customId);
-    return job ? resp.job(job, reqId) : resp.error('Job not found', reqId);
+    return job ? resp.job(jobView(ctx, job), reqId) : resp.error('Job not found', reqId);
 }
 /** Handle GetJobs command - list jobs with filtering and pagination */
 export async function handleGetJobs(cmd, ctx, reqId) {
@@ -60,14 +69,14 @@ export async function handleGetJobs(cmd, ctx, reqId) {
         state: stateFilter,
         start: cmd.offset ?? 0,
         end: (cmd.offset ?? 0) + (cmd.limit ?? 100),
-        asc: true,
+        asc: cmd.asc ?? true,
     });
     // Inject state into each job for display
     // When state is a single string, use it directly; otherwise resolve per-job
     const singleState = typeof stateFilter === 'string' ? stateFilter : undefined;
     const jobsWithState = await Promise.all(jobs.map(async (job) => {
         const state = singleState ?? (await ctx.queueManager.getJobState(job.id));
-        return { ...job, state };
+        return jobView(ctx, job, state);
     }));
     return resp.jobs(jobsWithState, reqId);
 }

package/dist/infrastructure/server/http-routes/jobAdvanced.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerContext } from '../types';
+export declare function routeJobAdvanced(request: Request, path: string, method: string, context: HandlerContext, cors: Set<string>): Promise<Response | null>;

package/dist/infrastructure/server/http-routes/jobAdvanced.js

@@ -0,0 +1,106 @@
+import { handleCommand } from '../handler';
+import { jsonResponse, parseJsonBody } from '../httpEndpoints';
+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$/;
+export async function routeJobAdvanced(request, path, method, context, cors) {
+    const moveDelayedMatch = path.match(RE_JOB_MOVE_DELAYED);
+    if (moveDelayedMatch && method === 'POST') {
+        const body = await parseJsonBody(request, cors);
+        if (body instanceof Response)
+            return body;
+        const result = await handleCommand({
+            cmd: 'MoveToDelayed',
+            id: moveDelayedMatch[1],
+            delay: body['delay'],
+            token: body['token'],
+        }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
+    }
+    const changeDelayMatch = path.match(RE_JOB_DELAY);
+    if (changeDelayMatch && method === 'PUT') {
+        const body = await parseJsonBody(request, cors);
+        if (body instanceof Response)
+            return body;
+        const result = await handleCommand({ cmd: 'ChangeDelay', id: changeDelayMatch[1], delay: body['delay'] }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
+    }
+    const childrenMatch = path.match(RE_JOB_CHILDREN);
+    if (childrenMatch && method === 'GET') {
+        const result = await handleCommand({ cmd: 'GetChildrenValues', id: childrenMatch[1] }, context);
+        return jsonResponse(result, result.ok ? 200 : 404, cors);
+    }
+    const logsMatch = path.match(RE_JOB_LOGS);
+    if (logsMatch && method === 'GET') {
+        const result = await handleCommand({ cmd: 'GetLogs', id: logsMatch[1] }, context);
+        return jsonResponse(result, 200, cors);
+    }
+    if (logsMatch && method === 'POST') {
+        const body = await parseJsonBody(request, cors);
+        if (body instanceof Response)
+            return body;
+        const result = await handleCommand({
+            cmd: 'AddLog',
+            id: logsMatch[1],
+            message: body['message'],
+            level: body['level'],
+        }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
+    }
+    if (logsMatch && method === 'DELETE') {
+        const result = await handleCommand({ cmd: 'ClearLogs', id: logsMatch[1] }, context);
+        return jsonResponse(result, 200, cors);
+    }
+    const heartbeatMatch = path.match(RE_JOB_HEARTBEAT);
+    if (heartbeatMatch && method === 'POST') {
+        const body = await parseJsonBody(request, cors);
+        if (body instanceof Response)
+            return body;
+        const result = await handleCommand({
+            cmd: 'JobHeartbeat',
+            id: heartbeatMatch[1],
+            token: body['token'],
+            duration: body['duration'],
+        }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
+    }
+    const waitMatch = path.match(RE_JOB_WAIT);
+    if (waitMatch && method === 'POST') {
+        const body = await parseJsonBody(request, cors);
+        if (body instanceof Response)
+            return body;
+        const result = await handleCommand({ cmd: 'WaitJob', id: waitMatch[1], timeout: body['timeout'] }, context);
+        return jsonResponse(result, 200, cors);
+    }
+    const extendLockMatch = path.match(RE_JOB_EXTEND_LOCK);
+    if (extendLockMatch && method === 'POST') {
+        const body = await parseJsonBody(request, cors);
+        if (body instanceof Response)
+            return body;
+        const result = await handleCommand({
+            cmd: 'ExtendLock',
+            id: extendLockMatch[1],
+            duration: body['duration'],
+            token: body['token'],
+        }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
+    }
+    const moveToWaitMatch = path.match(RE_JOB_MOVE_TO_WAIT);
+    if (moveToWaitMatch && method === 'POST') {
+        const body = await parseJsonBody(request, cors);
+        if (body instanceof Response)
+            return body;
+        const result = await handleCommand({
+            cmd: 'MoveToWait',
+            id: moveToWaitMatch[1],
+            token: body['token'],
+        }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
+    }
+    return null;
+}

package/dist/infrastructure/server/http-routes/jobManagement.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerContext } from '../types';
+export declare function routeJobManagement(request: Request, path: string, method: string, context: HandlerContext, cors: Set<string>): Promise<Response | null>;

package/dist/infrastructure/server/http-routes/jobManagement.js

@@ -0,0 +1,74 @@
+import { handleCommand } from '../handler';
+import { jsonResponse, parseJsonBody } from '../httpEndpoints';
+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$/;
+export async function routeJobManagement(request, path, method, context, cors) {
+    const promoteMatch = path.match(RE_JOB_PROMOTE);
+    if (promoteMatch && method === 'POST') {
+        const result = await handleCommand({ cmd: 'Promote', id: promoteMatch[1] }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
+    }
+    const dataMatch = path.match(RE_JOB_DATA);
+    if (dataMatch && method === 'PUT') {
+        let body;
+        try {
+            body = (await request.json());
+        }
+        catch {
+            return jsonResponse({ ok: false, error: 'Invalid JSON body' }, 400, cors);
+        }
+        const result = await handleCommand({ cmd: 'Update', id: dataMatch[1], data: body['data'] }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
+    }
+    const stateMatch = path.match(RE_JOB_STATE);
+    if (stateMatch && method === 'GET') {
+        const result = await handleCommand({ cmd: 'GetState', id: stateMatch[1] }, context);
+        return jsonResponse(result, result.ok ? 200 : 404, cors);
+    }
+    const resultMatch = path.match(RE_JOB_RESULT);
+    if (resultMatch && method === 'GET') {
+        const result = await handleCommand({ cmd: 'GetResult', id: resultMatch[1] }, context);
+        return jsonResponse(result, result.ok ? 200 : 404, cors);
+    }
+    const progressMatch = path.match(RE_JOB_PROGRESS);
+    if (progressMatch && method === 'GET') {
+        const result = await handleCommand({ cmd: 'GetProgress', id: progressMatch[1] }, context);
+        return jsonResponse(result, result.ok ? 200 : 404, cors);
+    }
+    if (progressMatch && method === 'POST') {
+        const body = await parseJsonBody(request, cors);
+        if (body instanceof Response)
+            return body;
+        const result = await handleCommand({
+            cmd: 'Progress',
+            id: progressMatch[1],
+            progress: body['progress'],
+            message: body['message'],
+        }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
+    }
+    const priorityMatch = path.match(RE_JOB_PRIORITY);
+    if (priorityMatch && method === 'PUT') {
+        const body = await parseJsonBody(request, cors);
+        if (body instanceof Response)
+            return body;
+        const result = await handleCommand({
+            cmd: 'ChangePriority',
+            id: priorityMatch[1],
+            priority: body['priority'],
+            lifo: body['lifo'],
+        }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
+    }
+    const discardMatch = path.match(RE_JOB_DISCARD);
+    if (discardMatch && method === 'POST') {
+        const result = await handleCommand({ cmd: 'Discard', id: discardMatch[1] }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
+    }
+    return null;
+}

package/dist/infrastructure/server/http-routes/queueJobs.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerContext } from '../types';
+export declare function routeQueueJobOperations(request: Request, path: string, method: string, context: HandlerContext, cors: Set<string>): Promise<Response | null>;

package/dist/infrastructure/server/http-routes/queueJobs.js

@@ -0,0 +1,108 @@
+import { handleCommand } from '../handler';
+import { jsonResponse, parseJsonBody } from '../httpEndpoints';
+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$/;
+export async function routeQueueJobOperations(request, path, method, context, cors) {
+    const queueJobsMatch = path.match(RE_QUEUE_JOBS);
+    if (queueJobsMatch) {
+        const queue = decodeURIComponent(queueJobsMatch[1]);
+        if (method === 'POST') {
+            let body;
+            try {
+                body = (await request.json());
+            }
+            catch {
+                return jsonResponse({ ok: false, error: 'Invalid JSON body' }, 400, cors);
+            }
+            const command = {
+                cmd: 'PUSH',
+                queue,
+                name: typeof body.name === 'string' ? body.name : 'default',
+                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 result = await handleCommand(command, context);
+            return jsonResponse(result, result.ok ? 200 : 400, cors);
+        }
+        if (method === 'GET') {
+            const timeout = parseInt(new URL(request.url).searchParams.get('timeout') ?? '0', 10);
+            const result = await handleCommand({ cmd: 'PULL', queue, timeout }, context);
+            return jsonResponse(result, 200, cors);
+        }
+    }
+    const bulkMatch = path.match(RE_QUEUE_JOBS_BULK);
+    if (bulkMatch && method === 'POST') {
+        const queue = decodeURIComponent(bulkMatch[1]);
+        let body;
+        try {
+            body = (await request.json());
+        }
+        catch {
+            return jsonResponse({ ok: false, error: 'Invalid JSON body' }, 400, cors);
+        }
+        const jobs = (body['jobs'] ?? []).map((job) => ({
+            ...job,
+            name: typeof job.name === 'string' ? job.name : 'default',
+        }));
+        const result = await handleCommand({ cmd: 'PUSHB', queue, jobs }, context);
+        return jsonResponse(result, result.ok ? 200 : 400, cors);
+    }
+    const pullBatchMatch = path.match(RE_QUEUE_JOBS_PULL_BATCH);
+    if (pullBatchMatch && method === 'POST') {
+        const queue = decodeURIComponent(pullBatchMatch[1]);
+        const body = await parseJsonBody(request, cors);
+        if (body instanceof Response)
+            return body;
+        const result = await handleCommand({
+            cmd: 'PULLB',
+            queue,
+            count: body['count'],
+            timeout: body['timeout'],
+            owner: body['owner'],
+            lockTtl: body['lockTtl'],
+        }, context);
+        return jsonResponse(result, 200, cors);
+    }
+    const listMatch = path.match(RE_QUEUE_JOBS_LIST);
+    if (listMatch && method === 'GET') {
+        const queue = decodeURIComponent(listMatch[1]);
+        const url = new URL(request.url);
+        const stateValues = [
+            ...url.searchParams.getAll('state'),
+            ...url.searchParams.getAll('status'),
+            ...url.searchParams.getAll('states'),
+        ]
+            .flatMap((value) => value.split(','))
+            .map((state) => state.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 result = await handleCommand({ cmd: 'GetJobs', queue, state, limit, offset }, context);
+        return jsonResponse(result, 200, cors);
+    }
+    return null;
+}

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

@@ -1,9 +1,2 @@
-/**
- * HTTP Routes - Job operations
- * All /jobs/:id/* endpoints, split into sub-routers for complexity
- */
 import type { HandlerContext } from './types';
-type Cors = Set<string>;
-/** Route /jobs/* requests. Returns Response or null if no match. */
-export declare function routeJobRoutes(req: Request, path: string, method: string, ctx: HandlerContext, cors: Cors): Promise<Response | null>;
-export {};
+export declare function routeJobRoutes(request: Request, path: string, method: string, context: HandlerContext, cors: Set<string>): Promise<Response | null>;