@pg-boss/proxy 0.1.0

package/dist/index.js

@@ -0,0 +1,270 @@
+import { version } from './version.js';
+import { OpenAPIHono, createRoute } from '@hono/zod-openapi';
+import { swaggerUI } from '@hono/swagger-ui';
+import { logger } from 'hono/logger';
+import { PgBoss, events, policies, states } from 'pg-boss';
+import { errorResultSchema, htmlResponseSchema, metaResponseSchema } from './contracts.js';
+import { renderHome } from './home.js';
+import { allRoutes } from './routes.js';
+import { configureAuth } from './auth.js';
+const normalizePrefix = (prefix) => {
+    const normalized = prefix.startsWith('/') ? prefix : `/${prefix}`;
+    return normalized === '/' ? '' : normalized.replace(/\/$/, '');
+};
+const resolvePrefix = (prefix) => {
+    return normalizePrefix(prefix ?? '/api');
+};
+const errorResponse = (context, status, message) => {
+    return context.json({ ok: false, error: { message } }, status);
+};
+const resultResponse = (context, result) => {
+    return context.json({ ok: true, result: result ?? null }, 200);
+};
+export const createProxyApp = (options) => {
+    const envOptions = options.env?.DATABASE_URL
+        ? { connectionString: options.env.DATABASE_URL }
+        : undefined;
+    const providedOptions = options.options ?? envOptions ?? {};
+    const exposeErrors = options.exposeErrors ?? false;
+    const resolvedOptions = { ...providedOptions };
+    if (!('supervise' in providedOptions)) {
+        resolvedOptions.supervise = false;
+    }
+    if (!('migrate' in providedOptions)) {
+        resolvedOptions.migrate = false;
+    }
+    if (!('schedule' in providedOptions)) {
+        resolvedOptions.schedule = false;
+    }
+    let boss;
+    if (options.bossFactory) {
+        boss = options.bossFactory(resolvedOptions);
+    }
+    else {
+        if (Object.keys(providedOptions).length === 0) {
+            throw new Error('Proxy requires PgBoss constructor options.');
+        }
+        boss = new PgBoss(resolvedOptions);
+    }
+    const prefix = resolvePrefix(options.prefix);
+    const app = new OpenAPIHono({
+        defaultHook: (result, context) => {
+            if (!result.success) {
+                const message = result.error instanceof Error ? result.error.message : 'Validation error';
+                return context.json({ ok: false, error: { message } }, 400);
+            }
+        }
+    });
+    app.use('*', logger());
+    configureAuth(app, options.env ?? process.env, prefix);
+    const base = prefix || '/';
+    const openapiPath = '/openapi.json';
+    const docsPath = '/docs';
+    const pages = options.pages ?? {};
+    if (pages.openapi !== false) {
+        app.doc31(openapiPath, {
+            openapi: '3.1.0',
+            info: {
+                title: 'pg-boss proxy',
+                version,
+                description: 'HTTP proxy for pg-boss methods.'
+            }
+        });
+    }
+    if (pages.docs !== false) {
+        app.get(docsPath, swaggerUI({ url: openapiPath }));
+    }
+    app.onError((error, context) => {
+        const message = exposeErrors && error instanceof Error
+            ? error.message
+            : 'Internal server error';
+        return errorResponse(context, 500, message);
+    });
+    const homeRoute = createRoute({
+        method: 'get',
+        path: '/',
+        responses: {
+            200: {
+                description: 'Home page',
+                content: {
+                    'text/html': {
+                        schema: htmlResponseSchema
+                    }
+                }
+            }
+        }
+    });
+    const applyRouteFilter = (routes) => {
+        let result = routes;
+        const allow = options.routes?.allow;
+        const deny = options.routes?.deny;
+        if (allow && allow.length > 0) {
+            result = result.filter((entry) => allow.includes(entry.method));
+        }
+        if (deny && deny.length > 0) {
+            result = result.filter((entry) => !deny.includes(entry.method));
+        }
+        return result;
+    };
+    const enabledRoutes = applyRouteFilter(allRoutes);
+    const enabledMethodInfos = enabledRoutes.map(({ method, httpMethod }) => ({ method, httpMethod }));
+    const homeHtml = renderHome({ base, openapiPath, docsPath, methods: enabledMethodInfos });
+    if (pages.root !== false) {
+        app.openapi(homeRoute, (context) => {
+            return context.html(homeHtml);
+        });
+    }
+    const maxBodySize = options.bodyLimit ?? 1024 * 1024;
+    app.use(`${prefix}/*`, async (context, next) => {
+        if (context.req.method === 'POST') {
+            const contentLength = context.req.header('content-length');
+            if (contentLength && parseInt(contentLength, 10) > maxBodySize) {
+                return context.json({ ok: false, error: { message: `Request body too large (max ${maxBodySize} bytes)` } }, 413);
+            }
+        }
+        await next();
+    });
+    if (options.middleware) {
+        const middlewares = Array.isArray(options.middleware) ? options.middleware : [options.middleware];
+        for (const mw of middlewares) {
+            app.use(`${prefix}/*`, mw);
+        }
+    }
+    const metaRoute = createRoute({
+        method: 'get',
+        path: `${prefix}/meta`,
+        responses: {
+            200: {
+                description: 'Metadata for pg-boss enumerations',
+                content: {
+                    'application/json': {
+                        schema: metaResponseSchema
+                    }
+                }
+            }
+        }
+    });
+    app.openapi(metaRoute, (context) => {
+        return context.json({ ok: true, result: { states, policies, events } }, 200);
+    });
+    const registerRoute = (entry) => {
+        const { method, httpMethod, tag, request, querySchema, response, args: buildArgs } = entry;
+        const responses = {
+            200: {
+                description: 'Method response',
+                content: {
+                    'application/json': {
+                        schema: response
+                    }
+                }
+            },
+            500: {
+                description: 'Server error',
+                content: {
+                    'application/json': {
+                        schema: errorResultSchema
+                    }
+                }
+            }
+        };
+        if (httpMethod === 'post' && request) {
+            responses[400] = {
+                description: 'Invalid request',
+                content: {
+                    'application/json': {
+                        schema: errorResultSchema
+                    }
+                }
+            };
+        }
+        if (httpMethod === 'get' && querySchema) {
+            responses[400] = {
+                description: 'Invalid query parameters',
+                content: {
+                    'application/json': {
+                        schema: errorResultSchema
+                    }
+                }
+            };
+        }
+        const routeDef = {
+            method: httpMethod,
+            path: `${prefix}/${method}`,
+            tags: [tag],
+            operationId: method,
+            responses
+        };
+        if (httpMethod === 'post' && request) {
+            routeDef.request = {
+                body: {
+                    content: {
+                        'application/json': {
+                            schema: request
+                        }
+                    },
+                    description: 'Arguments to pass through to the pg-boss method'
+                }
+            };
+        }
+        if (httpMethod === 'get' && querySchema) {
+            routeDef.request = {
+                query: querySchema
+            };
+        }
+        const route = createRoute(routeDef);
+        app.openapi(route, async (context) => {
+            let args;
+            if (httpMethod === 'post' && request) {
+                const input = context.req.valid('json');
+                args = buildArgs(input);
+            }
+            else if (httpMethod === 'get' && querySchema) {
+                try {
+                    const raw = context.req.queries();
+                    const flat = {};
+                    for (const [key, values] of Object.entries(raw)) {
+                        flat[key] = values.length === 1 ? values[0] : values;
+                    }
+                    const input = querySchema.parse(flat);
+                    args = buildArgs(input);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : 'Invalid query parameters';
+                    return errorResponse(context, 400, message);
+                }
+            }
+            else {
+                args = buildArgs();
+            }
+            try {
+                const result = await boss[method](...args);
+                return resultResponse(context, result);
+            }
+            catch (error) {
+                const message = exposeErrors && error instanceof Error
+                    ? error.message
+                    : 'Internal server error';
+                return errorResponse(context, 500, message);
+            }
+        });
+    };
+    for (const entry of enabledRoutes) {
+        registerRoute(entry);
+    }
+    return { app, boss, prefix };
+};
+export const createProxyService = (options) => {
+    const proxy = createProxyApp(options);
+    return {
+        ...proxy,
+        start: async () => {
+            await proxy.boss.start();
+        },
+        stop: async () => {
+            await proxy.boss.stop();
+        }
+    };
+};
+export { bossMethodNames, bossMethodInfos } from './routes.js';
+export { configureAuth } from './auth.js';
+export { attachShutdownListeners, nodeShutdownAdapter, bunShutdownAdapter, createDenoShutdownAdapter } from './shutdown.js';

package/dist/node.d.ts

@@ -0,0 +1,31 @@
+import { serve } from '@hono/node-server';
+import type { ConstructorOptions } from 'pg-boss';
+import { type ProxyApp, type ProxyOptions, type ProxyService } from './index.js';
+type ProxyNodeOptions = Omit<ProxyOptions, 'options' | 'env'> & {
+    options?: ConstructorOptions;
+    env?: Record<string, string | undefined>;
+};
+type ProxyServerNodeOptions = ProxyNodeOptions & {
+    port?: number;
+    hostname?: string;
+    shutdownSignals?: NodeJS.Signals[];
+    attachSignals?: boolean;
+    onListen?: (info: {
+        port: number;
+    }) => void;
+};
+type ProxyServerNode = Omit<ProxyService, 'start' | 'stop'> & {
+    hostname: string;
+    port: number;
+    server: ReturnType<typeof serve> | null;
+    start: () => Promise<{
+        port: number;
+    }>;
+    stop: () => Promise<void>;
+    detachSignals?: () => void;
+};
+export declare const createProxyAppNode: (options?: ProxyNodeOptions) => ProxyApp;
+export declare const createProxyServiceNode: (options?: ProxyNodeOptions) => ProxyService;
+export declare const createProxyServerNode: (options?: ProxyServerNodeOptions) => ProxyServerNode;
+export type { ProxyNodeOptions, ProxyServerNodeOptions, ProxyServerNode };
+//# sourceMappingURL=node.d.ts.map

package/dist/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AACzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AACjD,OAAO,EAKL,KAAK,QAAQ,EACb,KAAK,YAAY,EACjB,KAAK,YAAY,EAClB,MAAM,YAAY,CAAA;AAEnB,KAAK,gBAAgB,GAAG,IAAI,CAAC,YAAY,EAAE,SAAS,GAAG,KAAK,CAAC,GAAG;IAC9D,OAAO,CAAC,EAAE,kBAAkB,CAAA;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;CACzC,CAAA;AAED,KAAK,sBAAsB,GAAG,gBAAgB,GAAG;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC,OAAO,EAAE,CAAA;IAClC,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;CAC5C,CAAA;AAED,KAAK,eAAe,GAAG,IAAI,CAAC,YAAY,EAAE,OAAO,GAAG,MAAM,CAAC,GAAG;IAC5D,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,GAAG,IAAI,CAAA;IACvC,KAAK,EAAE,MAAM,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IACtC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IACzB,aAAa,CAAC,EAAE,MAAM,IAAI,CAAA;CAC3B,CAAA;AAcD,eAAO,MAAM,kBAAkB,GAAI,UAAS,gBAAqB,KAAG,QAInE,CAAA;AAED,eAAO,MAAM,sBAAsB,GAAI,UAAS,gBAAqB,KAAG,YAIvE,CAAA;AAED,eAAO,MAAM,qBAAqB,GAAI,UAAS,sBAA2B,KAAG,eAgE5E,CAAA;AAED,YAAY,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,eAAe,EAAE,CAAA"}

package/dist/node.js

@@ -0,0 +1,78 @@
+import { serve } from '@hono/node-server';
+import { attachShutdownListeners, createProxyApp, createProxyService, nodeShutdownAdapter } from './index.js';
+const resolveOptions = (options) => {
+    if (options.options) {
+        return options.options;
+    }
+    if (options.env?.DATABASE_URL) {
+        return { connectionString: options.env.DATABASE_URL };
+    }
+    throw new Error('Proxy requires PgBoss constructor options or DATABASE_URL.');
+};
+export const createProxyAppNode = (options = {}) => {
+    const { options: __, ...rest } = options;
+    const env = options.env ?? process.env;
+    return createProxyApp({ ...rest, options: resolveOptions({ ...options, env }), env });
+};
+export const createProxyServiceNode = (options = {}) => {
+    const { options: __, ...rest } = options;
+    const env = options.env ?? process.env;
+    return createProxyService({ ...rest, options: resolveOptions({ ...options, env }), env });
+};
+export const createProxyServerNode = (options = {}) => {
+    const { options: __, ...rest } = options;
+    const env = options.env ?? process.env;
+    const service = createProxyService({ ...rest, options: resolveOptions({ ...options, env }), env });
+    const hostname = options.hostname ?? env.HOST ?? 'localhost';
+    const port = options.port ?? Number(env.PORT ?? 3000);
+    const signals = options.shutdownSignals ?? ['SIGINT', 'SIGTERM'];
+    let server = null;
+    let detachSignals;
+    const proxy = {};
+    const stop = async () => {
+        try {
+            await service.stop();
+        }
+        finally {
+            if (server) {
+                await new Promise((resolve) => server?.close(() => resolve()));
+                server = null;
+                proxy.server = null;
+            }
+            if (detachSignals) {
+                detachSignals();
+                detachSignals = undefined;
+                proxy.detachSignals = undefined;
+            }
+        }
+    };
+    const start = async () => {
+        await service.start();
+        if (!server) {
+            const info = await new Promise((resolve) => {
+                server = serve({
+                    fetch: service.app.fetch,
+                    port,
+                    hostname
+                }, resolve);
+            });
+            proxy.server = server;
+            options.onListen?.(info);
+        }
+        if (options.attachSignals ?? true) {
+            detachSignals = attachShutdownListeners(signals, nodeShutdownAdapter, stop);
+            proxy.detachSignals = detachSignals;
+        }
+        return { port };
+    };
+    Object.assign(proxy, {
+        ...service,
+        hostname,
+        port,
+        server,
+        start,
+        stop,
+        detachSignals
+    });
+    return proxy;
+};

package/dist/routes.d.ts

@@ -0,0 +1,22 @@
+import { z } from '@hono/zod-openapi';
+export declare const withOptionalDataOptions: (args: unknown[], data?: unknown, options?: unknown) => unknown[];
+export declare const withFixedDataOptions: (args: unknown[], data?: unknown, options?: unknown, tail?: unknown[]) => unknown[];
+export declare const withOptionalOptions: (args: unknown[], options?: unknown) => unknown[];
+export type RouteEntry = {
+    method: string;
+    httpMethod: 'get' | 'post';
+    tag: string;
+    request?: z.ZodTypeAny;
+    querySchema?: z.ZodTypeAny;
+    response: z.ZodTypeAny;
+    args: (input?: unknown) => unknown[];
+};
+export declare const postMethods: RouteEntry[];
+export declare const getMethods: RouteEntry[];
+export declare const allRoutes: RouteEntry[];
+export declare const bossMethodNames: string[];
+export declare const bossMethodInfos: {
+    method: string;
+    httpMethod: 'get' | 'post';
+}[];
+//# sourceMappingURL=routes.d.ts.map

package/dist/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAA;AA4DrC,eAAO,MAAM,uBAAuB,GAAI,MAAM,OAAO,EAAE,EAAE,OAAO,OAAO,EAAE,UAAU,OAAO,cAQzF,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAI,MAAM,OAAO,EAAE,EAAE,OAAO,OAAO,EAAE,UAAU,OAAO,EAAE,OAAM,OAAO,EAAO,cAM5G,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,MAAM,OAAO,EAAE,EAAE,UAAU,OAAO,cAKrE,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,KAAK,GAAG,MAAM,CAAA;IAC1B,GAAG,EAAE,MAAM,CAAA;IACX,OAAO,CAAC,EAAE,CAAC,CAAC,UAAU,CAAA;IACtB,WAAW,CAAC,EAAE,CAAC,CAAC,UAAU,CAAA;IAC1B,QAAQ,EAAE,CAAC,CAAC,UAAU,CAAA;IACtB,IAAI,EAAE,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,OAAO,EAAE,CAAA;CACrC,CAAA;AA+DD,eAAO,MAAM,WAAW,EAAE,UAAU,EAyBnC,CAAA;AAED,eAAO,MAAM,UAAU,EAAE,UAAU,EAsBlC,CAAA;AAED,eAAO,MAAM,SAAS,EAAE,UAAU,EAAoC,CAAA;AAEtE,eAAO,MAAM,eAAe,EAAE,MAAM,EAA2C,CAAA;AAE/E,eAAO,MAAM,eAAe,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,KAAK,GAAG,MAAM,CAAA;CAAE,EAGzE,CAAA"}

package/dist/routes.js

@@ -0,0 +1,128 @@
+import { z } from '@hono/zod-openapi';
+import { cancelRequestSchema, cancelResponseSchema, completeRequestSchema, completeResponseSchema, createQueueRequestSchema, createQueueResponseSchema, deleteAllJobsRequestSchema, deleteAllJobsResponseSchema, deleteJobRequestSchema, deleteJobResponseSchema, deleteQueueRequestSchema, deleteQueueResponseSchema, deleteQueuedJobsRequestSchema, deleteQueuedJobsResponseSchema, deleteStoredJobsRequestSchema, deleteStoredJobsResponseSchema, failRequestSchema, failResponseSchema, fetchRequestSchema, fetchResponseSchema, findJobsResponseSchema, getBamStatusResponseSchema, getBlockedKeysResponseSchema, getQueueResponseSchema, getQueuesResponseSchema, getSchedulesResponseSchema, insertRequestSchema, insertResponseSchema, isInstalledResponseSchema, publishRequestSchema, publishResponseSchema, resumeRequestSchema, resumeResponseSchema, retryRequestSchema, retryResponseSchema, scheduleRequestSchema, scheduleResponseSchema, schemaVersionResponseSchema, sendAfterRequestSchema, sendAfterResponseSchema, sendDebouncedRequestSchema, sendDebouncedResponseSchema, sendRequestSchema, sendResponseSchema, sendThrottledRequestSchema, sendThrottledResponseSchema, subscribeRequestSchema, subscribeResponseSchema, superviseRequestSchema, superviseResponseSchema, unsubscribeRequestSchema, unsubscribeResponseSchema, unscheduleRequestSchema, unscheduleResponseSchema, updateQueueRequestSchema, updateQueueResponseSchema } from './contracts.js';
+export const withOptionalDataOptions = (args, data, options) => {
+    if (data !== undefined || options !== undefined) {
+        args.push(data ?? null);
+    }
+    if (options !== undefined) {
+        args.push(options);
+    }
+    return args;
+};
+export const withFixedDataOptions = (args, data, options, tail = []) => {
+    const result = [...args, data ?? null, options ?? null, ...tail];
+    while (result.length > 0 && result[result.length - 1] === undefined) {
+        result.pop();
+    }
+    return result;
+};
+export const withOptionalOptions = (args, options) => {
+    if (options !== undefined) {
+        args.push(options);
+    }
+    return args;
+};
+const post = (tag, method, request, response, args) => ({
+    method,
+    httpMethod: 'post',
+    tag,
+    request,
+    response,
+    args: (body) => args(body)
+});
+const get = (tag, method, response, querySchema, args) => ({
+    method,
+    httpMethod: 'get',
+    tag,
+    querySchema,
+    response,
+    args: args
+        ? (query) => args(query)
+        : () => []
+});
+// Query schemas for GET endpoints (transport-layer schemas with string coercion)
+const nameQuerySchema = z.object({
+    name: z.string().min(1)
+});
+const namesQuerySchema = z.object({
+    names: z.union([z.array(z.string()), z.string().transform((s) => [s])]).optional()
+});
+const schedulesQuerySchema = z.object({
+    name: z.string().optional(),
+    key: z.string().optional()
+});
+const findJobsQuerySchema = z.object({
+    name: z.string().min(1),
+    id: z.string().optional(),
+    key: z.string().optional(),
+    queued: z.enum(['true', 'false']).transform((v) => v === 'true').optional(),
+    dataKey: z.string().optional(),
+    dataValue: z.string().optional()
+}).refine((q) => !q.dataValue || q.dataKey, {
+    message: 'dataKey is required when dataValue is provided'
+});
+const blockedKeysQuerySchema = z.object({
+    name: z.string().min(1)
+});
+export const postMethods = [
+    post('jobs', 'send', sendRequestSchema, sendResponseSchema, (body) => withOptionalDataOptions([body.name], body.data, body.options)),
+    post('jobs', 'sendAfter', sendAfterRequestSchema, sendAfterResponseSchema, (body) => withFixedDataOptions([body.name], body.data, body.options, [body.after])),
+    post('jobs', 'sendThrottled', sendThrottledRequestSchema, sendThrottledResponseSchema, (body) => withFixedDataOptions([body.name], body.data, body.options, [body.seconds, body.key])),
+    post('jobs', 'sendDebounced', sendDebouncedRequestSchema, sendDebouncedResponseSchema, (body) => withFixedDataOptions([body.name], body.data, body.options, [body.seconds, body.key])),
+    post('jobs', 'insert', insertRequestSchema, insertResponseSchema, (body) => withOptionalOptions([body.name, body.jobs], body.options)),
+    post('jobs', 'fetch', fetchRequestSchema, fetchResponseSchema, (body) => withOptionalOptions([body.name], body.options)),
+    post('jobs', 'complete', completeRequestSchema, completeResponseSchema, (body) => withOptionalDataOptions([body.name, body.id], body.data, body.options)),
+    post('jobs', 'fail', failRequestSchema, failResponseSchema, (body) => withOptionalDataOptions([body.name, body.id], body.data)),
+    post('jobs', 'cancel', cancelRequestSchema, cancelResponseSchema, (body) => [body.name, body.id]),
+    post('jobs', 'resume', resumeRequestSchema, resumeResponseSchema, (body) => [body.name, body.id]),
+    post('jobs', 'retry', retryRequestSchema, retryResponseSchema, (body) => [body.name, body.id]),
+    post('jobs', 'deleteJob', deleteJobRequestSchema, deleteJobResponseSchema, (body) => [body.name, body.id]),
+    post('jobs', 'deleteQueuedJobs', deleteQueuedJobsRequestSchema, deleteQueuedJobsResponseSchema, (body) => [body.name]),
+    post('jobs', 'deleteStoredJobs', deleteStoredJobsRequestSchema, deleteStoredJobsResponseSchema, (body) => [body.name]),
+    post('jobs', 'deleteAllJobs', deleteAllJobsRequestSchema, deleteAllJobsResponseSchema, (body) => (body.name ? [body.name] : [])),
+    post('queues', 'createQueue', createQueueRequestSchema, createQueueResponseSchema, (body) => withOptionalOptions([body.name], body.options)),
+    post('queues', 'updateQueue', updateQueueRequestSchema, updateQueueResponseSchema, (body) => withOptionalOptions([body.name], body.options)),
+    post('queues', 'deleteQueue', deleteQueueRequestSchema, deleteQueueResponseSchema, (body) => [body.name]),
+    post('events', 'subscribe', subscribeRequestSchema, subscribeResponseSchema, (body) => [body.event, body.name]),
+    post('events', 'unsubscribe', unsubscribeRequestSchema, unsubscribeResponseSchema, (body) => [body.event, body.name]),
+    post('events', 'publish', publishRequestSchema, publishResponseSchema, (body) => withOptionalDataOptions([body.event], body.data, body.options)),
+    post('schedules', 'schedule', scheduleRequestSchema, scheduleResponseSchema, (body) => withOptionalDataOptions([body.name, body.cron], body.data, body.options)),
+    post('schedules', 'unschedule', unscheduleRequestSchema, unscheduleResponseSchema, (body) => (body.key ? [body.name, body.key] : [body.name])),
+    post('system', 'supervise', superviseRequestSchema, superviseResponseSchema, (body) => (body.name ? [body.name] : []))
+];
+export const getMethods = [
+    get('system', 'isInstalled', isInstalledResponseSchema),
+    get('system', 'schemaVersion', schemaVersionResponseSchema),
+    get('system', 'getBamStatus', getBamStatusResponseSchema),
+    get('queues', 'getQueue', getQueueResponseSchema, nameQuerySchema, (q) => [q.name]),
+    get('queues', 'getBlockedKeys', getBlockedKeysResponseSchema, blockedKeysQuerySchema, (q) => [q.name]),
+    get('queues', 'getQueues', getQueuesResponseSchema, namesQuerySchema, (q) => (q.names ? [q.names] : [])),
+    get('schedules', 'getSchedules', getSchedulesResponseSchema, schedulesQuerySchema, (q) => {
+        if (q.name && q.key)
+            return [q.name, q.key];
+        if (q.name)
+            return [q.name];
+        return [];
+    }),
+    get('jobs', 'findJobs', findJobsResponseSchema, findJobsQuerySchema, (q) => {
+        const args = [q.name];
+        const options = {};
+        if (q.id)
+            options.id = q.id;
+        if (q.key)
+            options.key = q.key;
+        if (q.queued !== undefined)
+            options.queued = q.queued;
+        if (q.dataKey)
+            options.data = { [q.dataKey]: q.dataValue ?? null };
+        if (Object.keys(options).length > 0)
+            args.push(options);
+        return args;
+    })
+];
+export const allRoutes = [...postMethods, ...getMethods];
+export const bossMethodNames = allRoutes.map((entry) => entry.method);
+export const bossMethodInfos = allRoutes.map((entry) => ({
+    method: entry.method,
+    httpMethod: entry.httpMethod
+}));

package/dist/shutdown.d.ts

@@ -0,0 +1,12 @@
+export type ShutdownHandler = () => void | Promise<void>;
+export type ShutdownAdapter<Signal> = {
+    on: (signal: Signal, handler: () => void) => void;
+    off?: (signal: Signal, handler: () => void) => void;
+};
+type DenoSignal = 'SIGINT' | 'SIGTERM' | string;
+export declare const nodeShutdownAdapter: ShutdownAdapter<NodeJS.Signals>;
+export declare const bunShutdownAdapter: ShutdownAdapter<NodeJS.Signals>;
+export declare const createDenoShutdownAdapter: () => ShutdownAdapter<DenoSignal>;
+export declare const attachShutdownListeners: <Signal>(signals: Signal[], adapter: ShutdownAdapter<Signal>, handler: ShutdownHandler) => () => void;
+export {};
+//# sourceMappingURL=shutdown.d.ts.map

package/dist/shutdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown.d.ts","sourceRoot":"","sources":["../src/shutdown.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;AAExD,MAAM,MAAM,eAAe,CAAC,MAAM,IAAI;IACpC,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;IACjD,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;CACpD,CAAA;AAED,KAAK,UAAU,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,CAAA;AAO/C,eAAO,MAAM,mBAAmB,EAAE,eAAe,CAAC,MAAM,CAAC,OAAO,CAG/D,CAAA;AAED,eAAO,MAAM,kBAAkB,iCAAsB,CAAA;AAErD,eAAO,MAAM,yBAAyB,QAAO,eAAe,CAAC,UAAU,CAStE,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAI,MAAM,EAC5C,SAAS,MAAM,EAAE,EACjB,SAAS,eAAe,CAAC,MAAM,CAAC,EAChC,SAAS,eAAe,eAuBzB,CAAA"}

package/dist/shutdown.js

@@ -0,0 +1,37 @@
+export const nodeShutdownAdapter = {
+    on: (signal, handler) => process.on(signal, handler),
+    off: (signal, handler) => process.off(signal, handler)
+};
+export const bunShutdownAdapter = nodeShutdownAdapter;
+export const createDenoShutdownAdapter = () => {
+    const deno = globalThis.Deno;
+    if (!deno) {
+        throw new Error('Deno global is not available in this runtime.');
+    }
+    return {
+        on: (signal, handler) => deno.addSignalListener(signal, handler),
+        off: (signal, handler) => deno.removeSignalListener(signal, handler)
+    };
+};
+export const attachShutdownListeners = (signals, adapter, handler) => {
+    let called = false;
+    const wrapped = () => {
+        if (called)
+            return;
+        called = true;
+        Promise.resolve(handler()).catch((err) => {
+            console.error('Shutdown handler error:', err);
+        });
+    };
+    for (const signal of signals) {
+        adapter.on(signal, wrapped);
+    }
+    return () => {
+        if (!adapter.off) {
+            return;
+        }
+        for (const signal of signals) {
+            adapter.off(signal, wrapped);
+        }
+    };
+};