@lastshotlabs/bunshot 0.0.25 → 0.0.28

package/dist/routes/groups.js

@@ -1,346 +0,0 @@
-import { z } from "zod";
-import { createRoute, withSecurity } from "../lib/createRoute";
-import { createRouter } from "../lib/context";
-import { userAuth } from "../middleware/userAuth";
-import { requireRole } from "../middleware/requireRole";
-import { createGroup, deleteGroup, getGroup, listGroups, updateGroup, addGroupMember, updateGroupMembership, removeGroupMember, getGroupMembers, getUserGroups, } from "../lib/groups";
-import { HttpError } from "../lib/HttpError";
-// ---------------------------------------------------------------------------
-// Zod schemas
-// ---------------------------------------------------------------------------
-const SLUG_REGEX = /^[a-z0-9_-]+$/;
-const GroupBody = z.object({
-    name: z.string().min(1).max(100).regex(SLUG_REGEX, "name must be a slug: lowercase letters, digits, underscores, or hyphens"),
-    displayName: z.string().max(200).optional(),
-    description: z.string().max(1000).optional(),
-    roles: z.array(z.string()).default([]),
-    tenantId: z.string().nullable().optional().default(null),
-});
-const GroupUpdateBody = z.object({
-    name: z.string().min(1).max(100).regex(SLUG_REGEX, "name must be a slug").optional(),
-    displayName: z.string().max(200).nullable().optional(),
-    description: z.string().max(1000).nullable().optional(),
-    roles: z.array(z.string()).optional(),
-});
-const MemberBody = z.object({
-    userId: z.string().min(1),
-    roles: z.array(z.string()).default([]),
-});
-const MemberRolesBody = z.object({
-    roles: z.array(z.string()),
-});
-const GroupResponse = z.object({
-    id: z.string(),
-    name: z.string(),
-    displayName: z.string().optional(),
-    description: z.string().optional(),
-    roles: z.array(z.string()),
-    tenantId: z.string().nullable(),
-    createdAt: z.number(),
-    updatedAt: z.number(),
-}).openapi("Group");
-const MemberResponse = z.object({
-    userId: z.string(),
-    roles: z.array(z.string()),
-}).openapi("GroupMember");
-const PaginatedGroupsResponse = z.object({
-    items: z.array(GroupResponse),
-    total: z.number(),
-    limit: z.number(),
-    offset: z.number(),
-}).openapi("PaginatedGroups");
-const PaginatedMembersResponse = z.object({
-    items: z.array(MemberResponse),
-    total: z.number(),
-    limit: z.number(),
-    offset: z.number(),
-}).openapi("PaginatedGroupMembers");
-const UserGroupEntry = z.object({
-    group: GroupResponse,
-    membershipRoles: z.array(z.string()),
-}).openapi("UserGroupEntry");
-const ErrorResponse = z.object({ error: z.string() });
-const PaginationParams = {
-    limit: z.string().optional().openapi({ description: "Max results (default 50, max 200)" }),
-    offset: z.string().optional().openapi({ description: "Skip this many results (default 0)" }),
-};
-const tags = ["Groups"];
-// ---------------------------------------------------------------------------
-// Router factory
-// ---------------------------------------------------------------------------
-export const createGroupsRouter = (config) => {
-    const router = createRouter();
-    // Normalize: managementRoutes: true is equivalent to managementRoutes: {}
-    const mgmt = config.managementRoutes === true ? {} : (config.managementRoutes ?? {});
-    const guard = mgmt.middleware ?? [userAuth, requireRole.global(mgmt.adminRole ?? "admin")];
-    // Defensive guard warning
-    if (guard.length === 0 && process.env.NODE_ENV !== "production") {
-        console.warn("[bunshot] groups.managementRoutes: resolved auth middleware is empty — management routes are unprotected");
-    }
-    // Apply auth guard to all group management routes
-    router.use("/groups/*", ...guard);
-    router.use("/users/:userId/groups", ...guard);
-    // ---------------------------------------------------------------------------
-    // GET /groups — list groups
-    // ---------------------------------------------------------------------------
-    router.openapi(withSecurity(createRoute({
-        method: "get",
-        path: "/groups",
-        tags,
-        summary: "List groups",
-        description: "List groups. Returns tenant-scoped groups when tenantId is in context, app-wide groups otherwise.",
-        request: { query: z.object(PaginationParams) },
-        responses: {
-            200: { content: { "application/json": { schema: PaginatedGroupsResponse } }, description: "Groups list" },
-            401: { content: { "application/json": { schema: ErrorResponse } }, description: "Unauthorized" },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Forbidden" },
-        },
-    }), { cookieAuth: [] }, { userToken: [] }), async (c) => {
-        const tenantId = c.get("tenantId") ?? null;
-        const { limit, offset } = c.req.valid("query");
-        const result = await listGroups(tenantId, {
-            limit: limit ? Math.min(parseInt(limit, 10), 200) : 50,
-            offset: offset ? parseInt(offset, 10) : 0,
-        });
-        return c.json(result, 200);
-    });
-    // ---------------------------------------------------------------------------
-    // POST /groups — create group
-    // ---------------------------------------------------------------------------
-    router.openapi(withSecurity(createRoute({
-        method: "post",
-        path: "/groups",
-        tags,
-        summary: "Create group",
-        request: { body: { content: { "application/json": { schema: GroupBody } }, required: true } },
-        responses: {
-            201: { content: { "application/json": { schema: z.object({ id: z.string() }) } }, description: "Group created" },
-            401: { content: { "application/json": { schema: ErrorResponse } }, description: "Unauthorized" },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Forbidden" },
-            409: { content: { "application/json": { schema: ErrorResponse } }, description: "Name already exists in scope" },
-            422: { content: { "application/json": { schema: ErrorResponse } }, description: "Validation error" },
-        },
-    }), { cookieAuth: [] }, { userToken: [] }), async (c) => {
-        const body = c.req.valid("json");
-        const result = await createGroup({
-            name: body.name,
-            displayName: body.displayName,
-            description: body.description,
-            roles: body.roles,
-            tenantId: body.tenantId ?? null,
-        });
-        return c.json(result, 201);
-    });
-    // ---------------------------------------------------------------------------
-    // GET /groups/:groupId — get group
-    // ---------------------------------------------------------------------------
-    router.openapi(withSecurity(createRoute({
-        method: "get",
-        path: "/groups/:groupId",
-        tags,
-        summary: "Get group",
-        request: { params: z.object({ groupId: z.string() }) },
-        responses: {
-            200: { content: { "application/json": { schema: GroupResponse } }, description: "Group" },
-            401: { content: { "application/json": { schema: ErrorResponse } }, description: "Unauthorized" },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Forbidden" },
-            404: { content: { "application/json": { schema: ErrorResponse } }, description: "Not found" },
-        },
-    }), { cookieAuth: [] }, { userToken: [] }), async (c) => {
-        const { groupId } = c.req.valid("param");
-        const group = await getGroup(groupId);
-        if (!group)
-            return c.json({ error: "Group not found" }, 404);
-        return c.json(group, 200);
-    });
-    // ---------------------------------------------------------------------------
-    // PATCH /groups/:groupId — update group
-    // ---------------------------------------------------------------------------
-    router.openapi(withSecurity(createRoute({
-        method: "patch",
-        path: "/groups/:groupId",
-        tags,
-        summary: "Update group",
-        request: {
-            params: z.object({ groupId: z.string() }),
-            body: { content: { "application/json": { schema: GroupUpdateBody } }, required: true },
-        },
-        responses: {
-            204: { description: "Updated" },
-            401: { content: { "application/json": { schema: ErrorResponse } }, description: "Unauthorized" },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Forbidden" },
-            404: { content: { "application/json": { schema: ErrorResponse } }, description: "Not found" },
-            409: { content: { "application/json": { schema: ErrorResponse } }, description: "Name conflict" },
-            422: { content: { "application/json": { schema: ErrorResponse } }, description: "Validation error" },
-        },
-    }), { cookieAuth: [] }, { userToken: [] }), async (c) => {
-        const { groupId } = c.req.valid("param");
-        const body = c.req.valid("json");
-        const group = await getGroup(groupId);
-        if (!group)
-            return c.json({ error: "Group not found" }, 404);
-        const updates = {};
-        if (body.name !== undefined)
-            updates.name = body.name;
-        if ("displayName" in body)
-            updates.displayName = body.displayName ?? undefined;
-        if ("description" in body)
-            updates.description = body.description ?? undefined;
-        if (body.roles !== undefined)
-            updates.roles = body.roles;
-        await updateGroup(groupId, updates);
-        return c.body(null, 204);
-    });
-    // ---------------------------------------------------------------------------
-    // DELETE /groups/:groupId — delete group
-    // ---------------------------------------------------------------------------
-    router.openapi(withSecurity(createRoute({
-        method: "delete",
-        path: "/groups/:groupId",
-        tags,
-        summary: "Delete group",
-        description: "Delete a group. All memberships are cascade-deleted.",
-        request: { params: z.object({ groupId: z.string() }) },
-        responses: {
-            204: { description: "Deleted" },
-            401: { content: { "application/json": { schema: ErrorResponse } }, description: "Unauthorized" },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Forbidden" },
-            404: { content: { "application/json": { schema: ErrorResponse } }, description: "Not found" },
-        },
-    }), { cookieAuth: [] }, { userToken: [] }), async (c) => {
-        const { groupId } = c.req.valid("param");
-        const group = await getGroup(groupId);
-        if (!group)
-            return c.json({ error: "Group not found" }, 404);
-        await deleteGroup(groupId);
-        return c.body(null, 204);
-    });
-    // ---------------------------------------------------------------------------
-    // GET /groups/:groupId/members — list members
-    // ---------------------------------------------------------------------------
-    router.openapi(withSecurity(createRoute({
-        method: "get",
-        path: "/groups/:groupId/members",
-        tags,
-        summary: "List group members",
-        request: {
-            params: z.object({ groupId: z.string() }),
-            query: z.object(PaginationParams),
-        },
-        responses: {
-            200: { content: { "application/json": { schema: PaginatedMembersResponse } }, description: "Members list" },
-            401: { content: { "application/json": { schema: ErrorResponse } }, description: "Unauthorized" },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Forbidden" },
-            404: { content: { "application/json": { schema: ErrorResponse } }, description: "Group not found" },
-        },
-    }), { cookieAuth: [] }, { userToken: [] }), async (c) => {
-        const { groupId } = c.req.valid("param");
-        const { limit, offset } = c.req.valid("query");
-        const group = await getGroup(groupId);
-        if (!group)
-            return c.json({ error: "Group not found" }, 404);
-        const result = await getGroupMembers(groupId, {
-            limit: limit ? Math.min(parseInt(limit, 10), 200) : 50,
-            offset: offset ? parseInt(offset, 10) : 0,
-        });
-        return c.json(result, 200);
-    });
-    // ---------------------------------------------------------------------------
-    // POST /groups/:groupId/members — add member
-    // ---------------------------------------------------------------------------
-    router.openapi(withSecurity(createRoute({
-        method: "post",
-        path: "/groups/:groupId/members",
-        tags,
-        summary: "Add group member",
-        request: {
-            params: z.object({ groupId: z.string() }),
-            body: { content: { "application/json": { schema: MemberBody } }, required: true },
-        },
-        responses: {
-            201: { description: "Member added" },
-            401: { content: { "application/json": { schema: ErrorResponse } }, description: "Unauthorized" },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Forbidden" },
-            404: { content: { "application/json": { schema: ErrorResponse } }, description: "Group not found" },
-            409: { content: { "application/json": { schema: ErrorResponse } }, description: "User already a member" },
-        },
-    }), { cookieAuth: [] }, { userToken: [] }), async (c) => {
-        const { groupId } = c.req.valid("param");
-        const body = c.req.valid("json");
-        try {
-            await addGroupMember(groupId, body.userId, body.roles);
-        }
-        catch (err) {
-            if (err instanceof HttpError) {
-                return c.json({ error: err.message }, err.status);
-            }
-            throw err;
-        }
-        return c.body(null, 201);
-    });
-    // ---------------------------------------------------------------------------
-    // PATCH /groups/:groupId/members/:userId — update member roles
-    // ---------------------------------------------------------------------------
-    router.openapi(withSecurity(createRoute({
-        method: "patch",
-        path: "/groups/:groupId/members/:userId",
-        tags,
-        summary: "Update member roles",
-        description: "Update the per-membership roles for an existing group member.",
-        request: {
-            params: z.object({ groupId: z.string(), userId: z.string() }),
-            body: { content: { "application/json": { schema: MemberRolesBody } }, required: true },
-        },
-        responses: {
-            204: { description: "Updated" },
-            401: { content: { "application/json": { schema: ErrorResponse } }, description: "Unauthorized" },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Forbidden" },
-        },
-    }), { cookieAuth: [] }, { userToken: [] }), async (c) => {
-        const { groupId, userId } = c.req.valid("param");
-        const { roles } = c.req.valid("json");
-        await updateGroupMembership(groupId, userId, roles);
-        return c.body(null, 204);
-    });
-    // ---------------------------------------------------------------------------
-    // DELETE /groups/:groupId/members/:userId — remove member
-    // ---------------------------------------------------------------------------
-    router.openapi(withSecurity(createRoute({
-        method: "delete",
-        path: "/groups/:groupId/members/:userId",
-        tags,
-        summary: "Remove group member",
-        request: { params: z.object({ groupId: z.string(), userId: z.string() }) },
-        responses: {
-            204: { description: "Removed" },
-            401: { content: { "application/json": { schema: ErrorResponse } }, description: "Unauthorized" },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Forbidden" },
-        },
-    }), { cookieAuth: [] }, { userToken: [] }), async (c) => {
-        const { groupId, userId } = c.req.valid("param");
-        await removeGroupMember(groupId, userId);
-        return c.body(null, 204);
-    });
-    // ---------------------------------------------------------------------------
-    // GET /users/:userId/groups — list user's groups
-    // ---------------------------------------------------------------------------
-    router.openapi(withSecurity(createRoute({
-        method: "get",
-        path: "/users/:userId/groups",
-        tags,
-        summary: "List user's groups",
-        description: "List groups a user belongs to. Scoped to tenant context when present, app-wide otherwise.",
-        request: { params: z.object({ userId: z.string() }) },
-        responses: {
-            200: { content: { "application/json": { schema: z.array(UserGroupEntry) } }, description: "User's groups" },
-            401: { content: { "application/json": { schema: ErrorResponse } }, description: "Unauthorized" },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Forbidden" },
-        },
-    }), { cookieAuth: [] }, { userToken: [] }), async (c) => {
-        const { userId } = c.req.valid("param");
-        const tenantId = c.get("tenantId") ?? null;
-        const groups = await getUserGroups(userId, tenantId);
-        return c.json(groups, 200);
-    });
-    return router;
-};

package/dist/routes/health.d.ts

@@ -1 +0,0 @@
-export declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../lib/context").AppEnv, {}, "/">;

package/dist/routes/health.js

@@ -1,22 +0,0 @@
-import { createRoute } from "@hono/zod-openapi";
-import { z } from "zod";
-import { createRouter } from "../lib/context";
-export const router = createRouter();
-router.openapi(createRoute({
-    method: "get",
-    path: "/health",
-    tags: ["Core"],
-    responses: {
-        200: {
-            content: {
-                "application/json": {
-                    schema: z.object({
-                        status: z.enum(["ok"]),
-                        timestamp: z.string(),
-                    }),
-                },
-            },
-            description: "Service health check",
-        },
-    },
-}), (c) => c.json({ status: "ok", timestamp: new Date().toISOString() }));

package/dist/routes/home.d.ts

@@ -1 +0,0 @@
-export declare const router: import("@hono/zod-openapi").OpenAPIHono<import("../lib/context").AppEnv, {}, "/">;

package/dist/routes/home.js

@@ -1,16 +0,0 @@
-import { createRoute } from "@hono/zod-openapi";
-import { z } from "zod";
-import { getAppName } from "../lib/appConfig";
-import { createRouter } from "../lib/context";
-export const router = createRouter();
-router.openapi(createRoute({
-    method: "get",
-    path: "/",
-    tags: ["Core"],
-    responses: {
-        200: {
-            content: { "application/json": { schema: z.object({ message: z.string() }) } },
-            description: "API is running",
-        },
-    },
-}), (c) => c.json({ message: `${getAppName()} is running` }));

package/dist/routes/jobs.d.ts

@@ -1,2 +0,0 @@
-import type { JobsConfig } from "../app";
-export declare const createJobsRouter: (config: JobsConfig) => import("@hono/zod-openapi").OpenAPIHono<import("../lib/context").AppEnv, {}, "/">;

package/dist/routes/jobs.js

@@ -1,272 +0,0 @@
-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"];
-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 router = createRouter();
-    const allowedQueues = new Set(config.allowedQueues ?? []);
-    const authConfig = config.auth ?? "none";
-    const scopeToUser = config.scopeToUser ?? false;
-    // Determine if userAuth is involved (for scopeToUser and OpenAPI security schemes)
-    const hasUserAuth = authConfig === "userAuth" || Array.isArray(authConfig);
-    // Apply middleware based on config
-    if (authConfig === "userAuth") {
-        router.use("/jobs/*", userAuth);
-        if (config.roles?.length) {
-            router.use("/jobs/*", requireRole(...config.roles));
-        }
-    }
-    else if (Array.isArray(authConfig)) {
-        for (const mw of authConfig) {
-            router.use("/jobs/*", mw);
-        }
-    }
-    // "none" requires no middleware
-    function isQueueAllowed(queueName) {
-        return allowedQueues.has(queueName);
-    }
-    /** Determine OpenAPI security for a route */
-    function applyRouteSecurity(route) {
-        if (authConfig === "userAuth") {
-            return withSecurity(route, { cookieAuth: [] }, { userToken: [] });
-        }
-        if (Array.isArray(authConfig)) {
-            // Custom middleware — mark as cookieAuth/userToken if it likely includes userAuth
-            return withSecurity(route, { cookieAuth: [] }, { userToken: [] });
-        }
-        return route;
-    }
-    /** Map a BullMQ job to the response shape */
-    async function jobToResponse(job) {
-        const state = await job.getState();
-        return {
-            id: job.id,
-            state,
-            progress: job.progress,
-            result: job.returnvalue,
-            failedReason: job.failedReason ?? undefined,
-            attemptsMade: job.attemptsMade,
-            timestamp: job.timestamp,
-            finishedOn: job.finishedOn ?? undefined,
-        };
-    }
-    // ─── 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.",
-        tags,
-        responses: {
-            200: {
-                content: {
-                    "application/json": {
-                        schema: z.object({
-                            queues: z.array(z.string()).describe("Available queue names."),
-                        }),
-                    },
-                },
-                description: "Available queues.",
-            },
-        },
-    });
-    router.openapi(applyRouteSecurity(listQueuesRoute), async (c) => {
-        return c.json({ queues: [...allowedQueues] }, 200);
-    });
-    // ─── 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.",
-        tags,
-        request: {
-            params: z.object({
-                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."),
-            }),
-        },
-        responses: {
-            200: {
-                content: {
-                    "application/json": {
-                        schema: z.object({
-                            jobs: z.array(JobStatusResponse),
-                            total: z.number().describe("Total jobs matching the filter."),
-                        }),
-                    },
-                },
-                description: "Jobs list.",
-            },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Queue not allowed." },
-        },
-    });
-    router.openapi(applyRouteSecurity(listJobsRoute), async (c) => {
-        const { queue: queueName } = c.req.valid("param");
-        if (!isQueueAllowed(queueName)) {
-            return c.json({ error: "Queue not allowed" }, 403);
-        }
-        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);
-        // Get jobs by state or all jobs
-        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);
-        const total = counts[stateFilter] ?? 0;
-        // Optionally filter by userId
-        let filteredJobs = jobs;
-        if (scopeToUser && hasUserAuth) {
-            const userId = c.get("authUserId");
-            filteredJobs = jobs.filter((job) => job.data?.userId === userId);
-        }
-        const result = await Promise.all(filteredJobs.map(jobToResponse));
-        return c.json({ jobs: result, total }, 200);
-    });
-    // ─── Dead letter queue ────────────────────────────────────────────────
-    // 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.",
-        tags,
-        request: {
-            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."),
-            }),
-        },
-        responses: {
-            200: {
-                content: {
-                    "application/json": {
-                        schema: z.object({
-                            jobs: z.array(JobStatusResponse),
-                            total: z.number().describe("Total jobs in DLQ."),
-                        }),
-                    },
-                },
-                description: "DLQ jobs.",
-            },
-            403: { content: { "application/json": { schema: ErrorResponse } }, description: "Queue not allowed." },
-        },
-    });
-    router.openapi(applyRouteSecurity(getDlqRoute), async (c) => {
-        const { queue: queueName } = c.req.valid("param");
-        if (!isQueueAllowed(queueName)) {
-            return c.json({ error: "Queue not allowed" }, 403);
-        }
-        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 [jobs, total] = await Promise.all([
-            dlqQueue.getWaiting(start, end),
-            dlqQueue.getWaitingCount(),
-        ]);
-        const result = await Promise.all(jobs.map(jobToResponse));
-        return c.json({ jobs: result, total }, 200);
-    });
-    // ─── 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.",
-        tags,
-        request: {
-            params: z.object({
-                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." },
-        },
-    });
-    router.openapi(applyRouteSecurity(getJobRoute), async (c) => {
-        const { queue: queueName, id } = c.req.valid("param");
-        if (!isQueueAllowed(queueName)) {
-            return c.json({ error: "Queue not allowed" }, 403);
-        }
-        const queue = createQueue(queueName);
-        const job = await queue.getJob(id);
-        if (!job)
-            return c.json({ error: "Job not found" }, 404);
-        // Scope to user if configured
-        if (scopeToUser && hasUserAuth) {
-            const userId = c.get("authUserId");
-            if (job.data?.userId !== userId) {
-                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.",
-        tags,
-        request: {
-            params: z.object({
-                queue: z.string().describe("Queue name."),
-                id: z.string().describe("Job ID."),
-            }),
-        },
-        responses: {
-            200: {
-                content: {
-                    "application/json": {
-                        schema: z.object({
-                            logs: z.array(z.string()).describe("Log entries."),
-                            count: z.number().describe("Total log count."),
-                        }),
-                    },
-                },
-                description: "Job logs.",
-            },
-            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");
-        if (!isQueueAllowed(queueName)) {
-            return c.json({ error: "Queue not allowed" }, 403);
-        }
-        const queue = createQueue(queueName);
-        const job = await queue.getJob(id);
-        if (!job)
-            return c.json({ error: "Job not found" }, 404);
-        const { logs, count } = await queue.getJobLogs(id);
-        return c.json({ logs, count }, 200);
-    });
-    return router;
-};