@lastshotlabs/bunshot 0.0.27 → 0.0.28

package/dist/{routes → src/framework/routes}/jobs.js

@@ -1,41 +1,40 @@
-import { createRoute, withSecurity } from "../lib/createRoute";
-import { z } from "zod";
-import { createRouter } from "../lib/context";
-import { userAuth } from "../middleware/userAuth";
-import { requireRole } from "../middleware/requireRole";
-import { createQueue } from "../lib/queue";
-const tags = ["Jobs"];
+import { createRoute, withSecurity } from '../lib/createRoute';
+import { z } from 'zod';
+import { createRouter, getBunshotCtx, getRouteAuth } from '../../../packages/bunshot-core/src/index.js';
+const tags = ['Jobs'];
 const ErrorResponse = z.object({ error: z.string() });
-const JobStatusResponse = z.object({
-    id: z.string().describe("Job ID."),
-    state: z.string().describe("Job state: waiting, active, completed, failed, delayed, paused."),
-    progress: z.union([z.number(), z.record(z.string(), z.unknown())]).describe("Job progress."),
-    result: z.unknown().optional().describe("Job result (when completed)."),
-    failedReason: z.string().optional().describe("Failure reason (when failed)."),
-    attemptsMade: z.number().describe("Number of attempts made."),
-    timestamp: z.number().describe("Unix timestamp (ms) when the job was created."),
-    finishedOn: z.number().optional().describe("Unix timestamp (ms) when the job finished."),
-}).openapi("JobStatus");
-export const createJobsRouter = (config) => {
+const JobStatusResponse = z
+    .object({
+    id: z.string().describe('Job ID.'),
+    state: z.string().describe('Job state: waiting, active, completed, failed, delayed, paused.'),
+    progress: z.union([z.number(), z.record(z.string(), z.unknown())]).describe('Job progress.'),
+    result: z.unknown().optional().describe('Job result (when completed).'),
+    failedReason: z.string().optional().describe('Failure reason (when failed).'),
+    attemptsMade: z.number().describe('Number of attempts made.'),
+    timestamp: z.number().describe('Unix timestamp (ms) when the job was created.'),
+    finishedOn: z.number().optional().describe('Unix timestamp (ms) when the job finished.'),
+})
+    .openapi('JobStatus');
+export const createJobsRouter = (config, queueFactory) => {
     const router = createRouter();
     const allowedQueues = new Set(config.allowedQueues ?? []);
-    const authConfig = config.auth ?? "none";
+    const authConfig = config.auth ?? 'none';
     const scopeToUser = config.scopeToUser ?? false;
-    if (process.env.NODE_ENV === "production" && authConfig === "none" && !config.unsafePublic) {
-        throw new Error("[security] jobs.auth is required in production. Set jobs.auth or set unsafePublic: true.");
+    if (process.env.NODE_ENV === 'production' && authConfig === 'none' && !config.unsafePublic) {
+        throw new Error('[security] jobs.auth is required in production. Set jobs.auth or set unsafePublic: true.');
     }
     // Determine if userAuth is involved (for scopeToUser and OpenAPI security schemes)
-    const hasUserAuth = authConfig === "userAuth" || Array.isArray(authConfig);
+    const hasUserAuth = authConfig === 'userAuth' || Array.isArray(authConfig);
     // Apply middleware based on config
-    if (authConfig === "userAuth") {
-        router.use("/jobs/*", userAuth);
+    if (authConfig === 'userAuth') {
+        router.use('/jobs/*', async (c, next) => getRouteAuth(getBunshotCtx(c)).userAuth(c, next));
         if (config.roles?.length) {
-            router.use("/jobs/*", requireRole(...config.roles));
+            router.use('/jobs/*', async (c, next) => getRouteAuth(getBunshotCtx(c)).requireRole(...config.roles)(c, next));
         }
     }
     else if (Array.isArray(authConfig)) {
         for (const mw of authConfig) {
-            router.use("/jobs/*", mw);
+            router.use('/jobs/*', mw);
         }
     }
     // "none" requires no middleware
@@ -44,7 +43,7 @@ export const createJobsRouter = (config) => {
     }
     /** Determine OpenAPI security for a route */
     function applyRouteSecurity(route) {
-        if (authConfig === "userAuth") {
+        if (authConfig === 'userAuth') {
             return withSecurity(route, { cookieAuth: [] }, { userToken: [] });
         }
         if (Array.isArray(authConfig)) {
@@ -69,21 +68,21 @@ export const createJobsRouter = (config) => {
     }
     // ─── List available queues ──────────────────────────────────────────────
     const listQueuesRoute = createRoute({
-        method: "get",
-        path: "/jobs",
-        summary: "List available queues",
-        description: "Returns the list of queue names exposed via the API.",
+        method: 'get',
+        path: '/jobs',
+        summary: 'List available queues',
+        description: 'Returns the list of queue names exposed via the API.',
         tags,
         responses: {
             200: {
                 content: {
-                    "application/json": {
+                    'application/json': {
                         schema: z.object({
-                            queues: z.array(z.string()).describe("Available queue names."),
+                            queues: z.array(z.string()).describe('Available queue names.'),
                         }),
                     },
                 },
-                description: "Available queues.",
+                description: 'Available queues.',
             },
         },
     });
@@ -92,47 +91,53 @@ export const createJobsRouter = (config) => {
     });
     // ─── List jobs in a queue ─────────────────────────────────────────────
     const listJobsRoute = createRoute({
-        method: "get",
-        path: "/jobs/{queue}",
-        summary: "List jobs in a queue",
-        description: "Returns a paginated list of jobs in a queue, optionally filtered by state.",
+        method: 'get',
+        path: '/jobs/{queue}',
+        summary: 'List jobs in a queue',
+        description: 'Returns a paginated list of jobs in a queue, optionally filtered by state.',
         tags,
         request: {
             params: z.object({
-                queue: z.string().describe("Queue name."),
+                queue: z.string().describe('Queue name.'),
             }),
             query: z.object({
-                state: z.enum(["waiting", "active", "completed", "failed", "delayed", "paused"]).optional().describe("Filter by job state."),
-                start: z.string().optional().describe("Start index. Default: 0."),
-                end: z.string().optional().describe("End index. Default: 19."),
+                state: z
+                    .enum(['waiting', 'active', 'completed', 'failed', 'delayed', 'paused'])
+                    .optional()
+                    .describe('Filter by job state.'),
+                start: z.string().optional().describe('Start index. Default: 0.'),
+                end: z.string().optional().describe('End index. Default: 19.'),
             }),
         },
         responses: {
             200: {
                 content: {
-                    "application/json": {
+                    'application/json': {
                         schema: z.object({
                             jobs: z.array(JobStatusResponse),
-                            total: z.number().describe("Total jobs matching the filter."),
+                            total: z.number().describe('Total jobs matching the filter.'),
                         }),
                     },
                 },
-                description: "Jobs list.",
+                description: 'Jobs list.',
+            },
+            403: {
+                content: { 'application/json': { schema: ErrorResponse } },
+                description: 'Queue not allowed.',
             },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Queue not allowed." },
         },
     });
     router.openapi(applyRouteSecurity(listJobsRoute), async (c) => {
-        const { queue: queueName } = c.req.valid("param");
+        const { queue: queueName } = c.req.valid('param');
         if (!isQueueAllowed(queueName)) {
-            return c.json({ error: "Queue not allowed" }, 403);
+            return c.json({ error: 'Queue not allowed' }, 403);
         }
-        const { state, start: startStr, end: endStr } = c.req.valid("query");
+        const { state, start: startStr, end: endStr } = c.req.valid('query');
         const start = startStr ? parseInt(startStr) : 0;
         const end = endStr ? parseInt(endStr) : 19;
-        const queue = createQueue(queueName);
+        const queue = queueFactory.createQueue(queueName);
         // Get jobs by state or all jobs
-        const stateFilter = state ?? "waiting";
+        const stateFilter = state ?? 'waiting';
         const jobs = await queue.getJobs([stateFilter], start, end);
         // Get total count for the filtered state
         const counts = await queue.getJobCounts(stateFilter);
@@ -140,8 +145,8 @@ export const createJobsRouter = (config) => {
         // Optionally filter by userId
         let filteredJobs = jobs;
         if (scopeToUser && hasUserAuth) {
-            const userId = c.get("authUserId");
-            filteredJobs = jobs.filter((job) => job.data?.userId === userId);
+            const userId = c.get('authUserId');
+            filteredJobs = jobs.filter(job => job.data?.userId === userId);
         }
         const result = await Promise.all(filteredJobs.map(jobToResponse));
         // NOTE: When scopeToUser is active, total is a page-local filtered count, not a
@@ -152,50 +157,55 @@ export const createJobsRouter = (config) => {
     // Must be registered BEFORE getJobRoute so that the literal path segment
     // "dead-letters" is matched before the parameterised {id} segment.
     const getDlqRoute = createRoute({
-        method: "get",
-        path: "/jobs/{queue}/dead-letters",
-        summary: "List dead letter queue jobs",
-        description: "Returns paginated list of jobs in the dead letter queue for a given source queue.",
+        method: 'get',
+        path: '/jobs/{queue}/dead-letters',
+        summary: 'List dead letter queue jobs',
+        description: 'Returns paginated list of jobs in the dead letter queue for a given source queue.',
         tags,
         request: {
-            params: z.object({ queue: z.string().describe("Source queue name (DLQ name is {queue}-dlq).") }),
+            params: z.object({
+                queue: z.string().describe('Source queue name (DLQ name is {queue}-dlq).'),
+            }),
             query: z.object({
-                start: z.string().optional().describe("Start index. Default: 0."),
-                end: z.string().optional().describe("End index. Default: 19."),
+                start: z.string().optional().describe('Start index. Default: 0.'),
+                end: z.string().optional().describe('End index. Default: 19.'),
             }),
         },
         responses: {
             200: {
                 content: {
-                    "application/json": {
+                    'application/json': {
                         schema: z.object({
                             jobs: z.array(JobStatusResponse),
-                            total: z.number().describe("Total jobs in DLQ."),
+                            total: z.number().describe('Total jobs in DLQ.'),
                         }),
                     },
                 },
-                description: "DLQ jobs.",
+                description: 'DLQ jobs.',
+            },
+            403: {
+                content: { 'application/json': { schema: ErrorResponse } },
+                description: 'Queue not allowed.',
             },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Queue not allowed." },
         },
     });
     router.openapi(applyRouteSecurity(getDlqRoute), async (c) => {
-        const { queue: queueName } = c.req.valid("param");
+        const { queue: queueName } = c.req.valid('param');
         if (!isQueueAllowed(queueName)) {
-            return c.json({ error: "Queue not allowed" }, 403);
+            return c.json({ error: 'Queue not allowed' }, 403);
         }
-        const { start: startStr, end: endStr } = c.req.valid("query");
+        const { start: startStr, end: endStr } = c.req.valid('query');
         const start = startStr ? parseInt(startStr) : 0;
         const end = endStr ? parseInt(endStr) : 19;
-        const dlqQueue = createQueue(`${queueName}-dlq`);
+        const dlqQueue = queueFactory.createQueue(`${queueName}-dlq`);
         const [jobs, total] = await Promise.all([
             dlqQueue.getWaiting(start, end),
             dlqQueue.getWaitingCount(),
         ]);
         let filteredJobs = jobs;
         if (scopeToUser && hasUserAuth) {
-            const userId = c.get("authUserId");
-            filteredJobs = jobs.filter((job) => job.data?.userId === userId);
+            const userId = c.get('authUserId');
+            filteredJobs = jobs.filter(job => job.data?.userId === userId);
         }
         const result = await Promise.all(filteredJobs.map(jobToResponse));
         // NOTE: When scopeToUser is active, total is a page-local filtered count, not a
@@ -204,83 +214,98 @@ export const createJobsRouter = (config) => {
     });
     // ─── Get job status ─────────────────────────────────────────────────────
     const getJobRoute = createRoute({
-        method: "get",
-        path: "/jobs/{queue}/{id}",
-        summary: "Get job status",
-        description: "Returns the current state, progress, result, or failure reason for a job.",
+        method: 'get',
+        path: '/jobs/{queue}/{id}',
+        summary: 'Get job status',
+        description: 'Returns the current state, progress, result, or failure reason for a job.',
         tags,
         request: {
             params: z.object({
-                queue: z.string().describe("Queue name."),
-                id: z.string().describe("Job ID."),
+                queue: z.string().describe('Queue name.'),
+                id: z.string().describe('Job ID.'),
             }),
         },
         responses: {
-            200: { content: { "application/json": { schema: JobStatusResponse } }, description: "Job status." },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Queue not in allowedQueues." },
-            404: { content: { "application/json": { schema: ErrorResponse } }, description: "Job not found." },
+            200: {
+                content: { 'application/json': { schema: JobStatusResponse } },
+                description: 'Job status.',
+            },
+            403: {
+                content: { 'application/json': { schema: ErrorResponse } },
+                description: 'Queue not in allowedQueues.',
+            },
+            404: {
+                content: { 'application/json': { schema: ErrorResponse } },
+                description: 'Job not found.',
+            },
         },
     });
     router.openapi(applyRouteSecurity(getJobRoute), async (c) => {
-        const { queue: queueName, id } = c.req.valid("param");
+        const { queue: queueName, id } = c.req.valid('param');
         if (!isQueueAllowed(queueName)) {
-            return c.json({ error: "Queue not allowed" }, 403);
+            return c.json({ error: 'Queue not allowed' }, 403);
         }
-        const queue = createQueue(queueName);
+        const queue = queueFactory.createQueue(queueName);
         const job = await queue.getJob(id);
         if (!job)
-            return c.json({ error: "Job not found" }, 404);
+            return c.json({ error: 'Job not found' }, 404);
         // Scope to user if configured
         if (scopeToUser && hasUserAuth) {
-            const userId = c.get("authUserId");
+            const userId = c.get('authUserId');
             if (job.data?.userId !== userId) {
-                return c.json({ error: "Job not found" }, 404);
+                return c.json({ error: 'Job not found' }, 404);
             }
         }
         return c.json(await jobToResponse(job), 200);
     });
     // ─── Get job logs ───────────────────────────────────────────────────────
     const getJobLogsRoute = createRoute({
-        method: "get",
-        path: "/jobs/{queue}/{id}/logs",
-        summary: "Get job logs",
-        description: "Returns logs for a specific job.",
+        method: 'get',
+        path: '/jobs/{queue}/{id}/logs',
+        summary: 'Get job logs',
+        description: 'Returns logs for a specific job.',
         tags,
         request: {
             params: z.object({
-                queue: z.string().describe("Queue name."),
-                id: z.string().describe("Job ID."),
+                queue: z.string().describe('Queue name.'),
+                id: z.string().describe('Job ID.'),
             }),
         },
         responses: {
             200: {
                 content: {
-                    "application/json": {
+                    'application/json': {
                         schema: z.object({
-                            logs: z.array(z.string()).describe("Log entries."),
-                            count: z.number().describe("Total log count."),
+                            logs: z.array(z.string()).describe('Log entries.'),
+                            count: z.number().describe('Total log count.'),
                         }),
                     },
                 },
-                description: "Job logs.",
+                description: 'Job logs.',
+            },
+            403: {
+                content: { 'application/json': { schema: ErrorResponse } },
+                description: 'Queue not allowed.',
+            },
+            404: {
+                content: { 'application/json': { schema: ErrorResponse } },
+                description: 'Job not found.',
             },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Queue not allowed." },
-            404: { content: { "application/json": { schema: ErrorResponse } }, description: "Job not found." },
         },
     });
     router.openapi(applyRouteSecurity(getJobLogsRoute), async (c) => {
-        const { queue: queueName, id } = c.req.valid("param");
+        const { queue: queueName, id } = c.req.valid('param');
         if (!isQueueAllowed(queueName)) {
-            return c.json({ error: "Queue not allowed" }, 403);
+            return c.json({ error: 'Queue not allowed' }, 403);
         }
-        const queue = createQueue(queueName);
+        const queue = queueFactory.createQueue(queueName);
         const job = await queue.getJob(id);
         if (!job)
-            return c.json({ error: "Job not found" }, 404);
+            return c.json({ error: 'Job not found' }, 404);
         if (scopeToUser && hasUserAuth) {
-            const userId = c.get("authUserId");
+            const userId = c.get('authUserId');
             if (job.data?.userId !== userId) {
-                return c.json({ error: "Job not found" }, 404);
+                return c.json({ error: 'Job not found' }, 404);
             }
         }
         const { logs, count } = await queue.getJobLogs(id);

package/dist/src/framework/routes/metrics.d.ts

@@ -0,0 +1,10 @@
+import type { MetricsState } from '../lib/metrics';
+import type { QueueFactory } from '../../lib/queue';
+import type { MiddlewareHandler } from 'hono';
+import type { AppEnv } from '../../../packages/bunshot-core/src/index.js';
+export interface MetricsRouteConfig {
+    auth?: 'userAuth' | 'none' | MiddlewareHandler<AppEnv>[];
+    queues?: string[];
+    unsafePublic?: boolean;
+}
+export declare const createMetricsRouter: (config: MetricsRouteConfig, state: MetricsState, queueFactory?: QueueFactory) => import("@hono/zod-openapi").OpenAPIHono<AppEnv, {}, "/">;

package/dist/src/framework/routes/metrics.js

@@ -0,0 +1,57 @@
+import { registerGaugeCallback, serializeMetrics, setMetricsQueues } from '../lib/metrics';
+import { createRouter, getBunshotCtx, getRouteAuth } from '../../../packages/bunshot-core/src/index.js';
+export const createMetricsRouter = (config, state, queueFactory) => {
+    const router = createRouter();
+    const authConfig = config.auth ?? 'none';
+    if (process.env.NODE_ENV === 'production' && authConfig === 'none' && !config.unsafePublic) {
+        throw new Error('[security] metrics.auth is required in production. Set metrics.auth or set unsafePublic: true.');
+    }
+    // Apply auth middleware
+    if (authConfig === 'userAuth') {
+        router.use('/metrics', async (c, next) => getRouteAuth(getBunshotCtx(c)).userAuth(c, next));
+    }
+    else if (Array.isArray(authConfig)) {
+        for (const mw of authConfig) {
+            router.use('/metrics', mw);
+        }
+    }
+    // Register BullMQ queue depth gauges if configured
+    if (config.queues?.length) {
+        if (!queueFactory) {
+            throw new Error('[queue] Metrics queue gauges require startup-resolved Redis queue configuration.');
+        }
+        const queueNames = config.queues;
+        const cachedQueues = new Map();
+        setMetricsQueues(state, cachedQueues);
+        registerGaugeCallback(state, 'bullmq_queue_depth', async () => {
+            const { createQueue } = await import('../../lib/queue');
+            const results = [];
+            for (const name of queueNames) {
+                let queue = cachedQueues.get(name);
+                try {
+                    if (!queue) {
+                        queue = queueFactory.createQueue(name);
+                        cachedQueues.set(name, queue);
+                    }
+                    const counts = await queue.getJobCounts('waiting', 'active', 'delayed', 'failed');
+                    for (const [state, count] of Object.entries(counts)) {
+                        results.push({ labels: { queue: name, state }, value: count });
+                    }
+                }
+                catch {
+                    // Discard cached instance on error so it's recreated next scrape
+                    cachedQueues.delete(name);
+                }
+            }
+            return results;
+        });
+    }
+    // Plain GET /metrics (not OpenAPI — infrastructure endpoint)
+    router.get('/metrics', async (c) => {
+        const body = await serializeMetrics(state);
+        return c.body(body, 200, {
+            'Content-Type': 'text/plain; version=0.0.4; charset=utf-8',
+        });
+    });
+    return router;
+};

package/dist/{routes → src/framework/routes}/uploads.d.ts

@@ -1,8 +1,8 @@
-import type { PresignedUrlConfig } from "../app";
+import type { PresignedUrlConfig } from '../../app';
 interface UploadsRouterConfig extends PresignedUrlConfig {
     authorization?: {
         authorize?: (input: {
-            action: "read" | "delete";
+            action: 'read' | 'delete';
             key: string;
             userId?: string;
             tenantId?: string;
@@ -10,5 +10,5 @@ interface UploadsRouterConfig extends PresignedUrlConfig {
     };
     allowExternalKeys?: boolean;
 }
-export declare const createUploadsRouter: (config: UploadsRouterConfig) => import("@hono/zod-openapi").OpenAPIHono<import("../lib/context").AppEnv, {}, "/">;
+export declare const createUploadsRouter: (config: UploadsRouterConfig) => import("@hono/zod-openapi").OpenAPIHono<import("../../../packages/bunshot-core/src/index.js").AppEnv, {}, "/">;
 export {};