velocious 1.0.381 → 1.0.382

package/build/src/background-jobs/web/controller.js

@@ -0,0 +1,212 @@
+// @ts-check
+import Controller from "../../controller.js";
+import BackgroundJobsStore from "../store.js";
+import { authorizeJobsRequest } from "./authorization.js";
+import { getJobsMount } from "./registry.js";
+const DASHBOARD_STATUSES = ["queued", "handed_off", "completed", "failed", "orphaned"];
+const SORTABLE_KEYS = ["attempts", "completedAtMs", "createdAtMs", "failedAtMs", "handedOffAtMs", "scheduledAtMs"];
+const DEFAULT_PER_PAGE = 25;
+const MAX_PER_PAGE = 100;
+/**
+ * Read-only HTTP API backing the background-jobs dashboard. Mounted by
+ * {@link import("./index.js").default} as a route-resolver hook so it can ship
+ * inside the velocious package. Every action is gated by {@link authorizeJobsRequest}.
+ */
+export default class VelociousBackgroundJobsWebController extends Controller {
+    /** @returns {import("./registry.js").JobsMountOptions} - Options for the mount that matched this request. */
+    _mountOptions() {
+        const at = this.params().velociousJobsMountAt;
+        return getJobsMount(this.getConfiguration(), at) || {};
+    }
+    /** @returns {BackgroundJobsStore} - Jobs store scoped to the mount's database. */
+    _store() {
+        if (!this._jobsStore) {
+            this._jobsStore = new BackgroundJobsStore({
+                configuration: this.getConfiguration(),
+                databaseIdentifier: this._mountOptions().databaseIdentifier
+            });
+        }
+        return this._jobsStore;
+    }
+    /**
+     * Adds CORS headers when the request origin is allowed, so the standalone
+     * browser dashboard can read the API cross-origin.
+     * @param {import("./registry.js").JobsMountOptions} options - Mount options.
+     * @returns {void} - No return value.
+     */
+    _applyCorsHeaders(options) {
+        const allowedOrigins = Array.isArray(options.allowedOrigins) ? options.allowedOrigins : [];
+        if (allowedOrigins.length === 0)
+            return;
+        const origin = this.request().origin();
+        const allowAll = allowedOrigins.includes("*");
+        if (!origin)
+            return;
+        if (!allowAll && !allowedOrigins.includes(origin))
+            return;
+        const response = this.response();
+        response.setHeader("Access-Control-Allow-Origin", allowAll ? "*" : origin);
+        response.setHeader("Vary", "Origin");
+        response.setHeader("Access-Control-Allow-Headers", "authorization, content-type");
+        response.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+    }
+    /**
+     * Applies CORS headers, authorizes the request, and runs the action body only
+     * when authorized. Renders a 401 otherwise. The base controller has no
+     * before-action halting, so authorization is enforced here per action.
+     * @param {() => Promise<void>} actionFn - Action body.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async _respond(actionFn) {
+        const options = this._mountOptions();
+        this._applyCorsHeaders(options);
+        const authorized = await authorizeJobsRequest({
+            ability: this.currentAbility(),
+            configuration: this.getConfiguration(),
+            options,
+            request: this.request()
+        });
+        if (!authorized) {
+            await this.render({ json: { error: "unauthorized" }, status: 401 });
+            return;
+        }
+        await actionFn();
+    }
+    /** @returns {Promise<void>} - Resolves when complete. */
+    async health() {
+        await this._respond(async () => {
+            await this.render({ json: { ok: true, service: "velocious-background-jobs" } });
+        });
+    }
+    /** @returns {Promise<void>} - Resolves when complete. */
+    async stats() {
+        await this._respond(async () => {
+            const counts = await this._store().countsByStatus();
+            /** @type {Record<string, number>} */
+            const byStatus = {};
+            let total = 0;
+            for (const status of DASHBOARD_STATUSES) {
+                byStatus[status] = counts[status] || 0;
+            }
+            for (const value of Object.values(counts)) {
+                total += value;
+            }
+            await this.render({ json: { counts: byStatus, generatedAtMs: Date.now(), total } });
+        });
+    }
+    /** @returns {Promise<void>} - Resolves when complete. */
+    async index() {
+        await this._respond(async () => {
+            const params = this.params();
+            const status = this._sanitizeStatus(params.status);
+            const jobName = typeof params.jobName === "string" && params.jobName.length > 0 ? params.jobName : undefined;
+            const page = this._positiveInt(params.page, 1);
+            const perPage = Math.min(this._positiveInt(params.perPage, DEFAULT_PER_PAGE), MAX_PER_PAGE);
+            const { sortColumn, sortDirection } = this._sanitizeSort(params.sort);
+            const store = this._store();
+            const jobs = await store.listJobs({ jobName, limit: perPage, offset: (page - 1) * perPage, sortColumn, sortDirection, status });
+            const total = await store.countJobs({ jobName, status });
+            await this.render({ json: {
+                    jobs: jobs.map((job) => this._serializeJob(job)),
+                    pagination: { page, perPage, total, totalPages: perPage > 0 ? Math.ceil(total / perPage) : 0 }
+                } });
+        });
+    }
+    /** @returns {Promise<void>} - Resolves when complete. */
+    async show() {
+        await this._respond(async () => {
+            const job = await this._store().getJob(this.params().id);
+            if (!job) {
+                await this.render({ json: { error: "not_found" }, status: 404 });
+                return;
+            }
+            await this.render({ json: { job: this._serializeJob(job) } });
+        });
+    }
+    /** @returns {Promise<void>} - Resolves when complete. */
+    async schedule() {
+        await this._respond(async () => {
+            const scheduled = await this.getConfiguration().getScheduledBackgroundJobsConfig();
+            await this.render({ json: { schedule: this._serializeSchedule(scheduled) } });
+        });
+    }
+    /**
+     * @param {import("../types.js").BackgroundJobRow} job - Job row.
+     * @returns {Record<string, any>} - Serialized job for the API.
+     */
+    _serializeJob(job) {
+        const redactArgs = Boolean(this._mountOptions().redactArgs);
+        return {
+            args: redactArgs ? undefined : job.args,
+            argsRedacted: redactArgs,
+            attempts: job.attempts,
+            completedAtMs: job.completedAtMs,
+            createdAtMs: job.createdAtMs,
+            failedAtMs: job.failedAtMs,
+            forked: job.forked,
+            handedOffAtMs: job.handedOffAtMs,
+            id: job.id,
+            jobName: job.jobName,
+            lastError: job.lastError,
+            maxRetries: job.maxRetries,
+            orphanedAtMs: job.orphanedAtMs,
+            scheduledAtMs: job.scheduledAtMs,
+            status: job.status,
+            workerId: job.workerId
+        };
+    }
+    /**
+     * @param {import("../../configuration-types.js").ScheduledBackgroundJobsConfiguration | undefined} scheduled - Scheduled jobs config.
+     * @returns {Array<Record<string, any>>} - Serialized recurring jobs.
+     */
+    _serializeSchedule(scheduled) {
+        const jobs = scheduled?.jobs;
+        if (!jobs || typeof jobs !== "object")
+            return [];
+        const redactArgs = Boolean(this._mountOptions().redactArgs);
+        return Object.keys(jobs).map((name) => {
+            const entry = jobs[name] || /** @type {any} */ ({});
+            return {
+                args: redactArgs ? undefined : (entry.args || []),
+                cron: entry.cron,
+                enabled: entry.enabled !== false,
+                every: entry.every,
+                jobName: typeof entry.class === "function" ? entry.class.name : undefined,
+                name,
+                options: entry.options || {}
+            };
+        });
+    }
+    /**
+     * @param {unknown} value - Raw status param.
+     * @returns {string | undefined} - Valid status or undefined.
+     */
+    _sanitizeStatus(value) {
+        return typeof value === "string" && DASHBOARD_STATUSES.includes(value) ? value : undefined;
+    }
+    /**
+     * @param {unknown} value - Raw sort param (e.g. "createdAtMs" or "-failedAtMs").
+     * @returns {{sortColumn: string, sortDirection: "ASC" | "DESC"}} - Normalized sort.
+     */
+    _sanitizeSort(value) {
+        if (typeof value !== "string" || value.length === 0) {
+            return { sortColumn: "createdAtMs", sortDirection: "DESC" };
+        }
+        const descending = value.startsWith("-");
+        const key = descending ? value.slice(1) : value;
+        const sortColumn = SORTABLE_KEYS.includes(key) ? key : "createdAtMs";
+        return { sortColumn, sortDirection: descending ? "DESC" : "ASC" };
+    }
+    /**
+     * @param {unknown} value - Raw numeric param.
+     * @param {number} fallback - Fallback when invalid.
+     * @returns {number} - Positive integer.
+     */
+    _positiveInt(value, fallback) {
+        const numeric = Number(Array.isArray(value) ? value[0] : value);
+        if (!Number.isFinite(numeric) || numeric < 1)
+            return fallback;
+        return Math.floor(numeric);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controller.js","sourceRoot":"","sources":["../../../../src/background-jobs/web/controller.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Controller from \"../../controller.js\"\nimport BackgroundJobsStore from \"../store.js\"\nimport {authorizeJobsRequest} from \"./authorization.js\"\nimport {getJobsMount} from \"./registry.js\"\n\nconst DASHBOARD_STATUSES = [\"queued\", \"handed_off\", \"completed\", \"failed\", \"orphaned\"]\nconst SORTABLE_KEYS = [\"attempts\", \"completedAtMs\", \"createdAtMs\", \"failedAtMs\", \"handedOffAtMs\", \"scheduledAtMs\"]\nconst DEFAULT_PER_PAGE = 25\nconst MAX_PER_PAGE = 100\n\n/**\n * Read-only HTTP API backing the background-jobs dashboard. Mounted by\n * {@link import(\"./index.js\").default} as a route-resolver hook so it can ship\n * inside the velocious package. Every action is gated by {@link authorizeJobsRequest}.\n */\nexport default class VelociousBackgroundJobsWebController extends Controller {\n  /** @returns {import(\"./registry.js\").JobsMountOptions} - Options for the mount that matched this request. */\n  _mountOptions() {\n    const at = this.params().velociousJobsMountAt\n\n    return getJobsMount(this.getConfiguration(), at) || {}\n  }\n\n  /** @returns {BackgroundJobsStore} - Jobs store scoped to the mount's database. */\n  _store() {\n    if (!this._jobsStore) {\n      this._jobsStore = new BackgroundJobsStore({\n        configuration: this.getConfiguration(),\n        databaseIdentifier: this._mountOptions().databaseIdentifier\n      })\n    }\n\n    return this._jobsStore\n  }\n\n  /**\n   * Adds CORS headers when the request origin is allowed, so the standalone\n   * browser dashboard can read the API cross-origin.\n   * @param {import(\"./registry.js\").JobsMountOptions} options - Mount options.\n   * @returns {void} - No return value.\n   */\n  _applyCorsHeaders(options) {\n    const allowedOrigins = Array.isArray(options.allowedOrigins) ? options.allowedOrigins : []\n\n    if (allowedOrigins.length === 0) return\n\n    const origin = this.request().origin()\n    const allowAll = allowedOrigins.includes(\"*\")\n\n    if (!origin) return\n    if (!allowAll && !allowedOrigins.includes(origin)) return\n\n    const response = this.response()\n\n    response.setHeader(\"Access-Control-Allow-Origin\", allowAll ? \"*\" : origin)\n    response.setHeader(\"Vary\", \"Origin\")\n    response.setHeader(\"Access-Control-Allow-Headers\", \"authorization, content-type\")\n    response.setHeader(\"Access-Control-Allow-Methods\", \"GET, POST, DELETE, OPTIONS\")\n  }\n\n  /**\n   * Applies CORS headers, authorizes the request, and runs the action body only\n   * when authorized. Renders a 401 otherwise. The base controller has no\n   * before-action halting, so authorization is enforced here per action.\n   * @param {() => Promise<void>} actionFn - Action body.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _respond(actionFn) {\n    const options = this._mountOptions()\n\n    this._applyCorsHeaders(options)\n\n    const authorized = await authorizeJobsRequest({\n      ability: this.currentAbility(),\n      configuration: this.getConfiguration(),\n      options,\n      request: this.request()\n    })\n\n    if (!authorized) {\n      await this.render({json: {error: \"unauthorized\"}, status: 401})\n      return\n    }\n\n    await actionFn()\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete. */\n  async health() {\n    await this._respond(async () => {\n      await this.render({json: {ok: true, service: \"velocious-background-jobs\"}})\n    })\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete. */\n  async stats() {\n    await this._respond(async () => {\n      const counts = await this._store().countsByStatus()\n      /** @type {Record<string, number>} */\n      const byStatus = {}\n      let total = 0\n\n      for (const status of DASHBOARD_STATUSES) {\n        byStatus[status] = counts[status] || 0\n      }\n\n      for (const value of Object.values(counts)) {\n        total += value\n      }\n\n      await this.render({json: {counts: byStatus, generatedAtMs: Date.now(), total}})\n    })\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete. */\n  async index() {\n    await this._respond(async () => {\n      const params = this.params()\n      const status = this._sanitizeStatus(params.status)\n      const jobName = typeof params.jobName === \"string\" && params.jobName.length > 0 ? params.jobName : undefined\n      const page = this._positiveInt(params.page, 1)\n      const perPage = Math.min(this._positiveInt(params.perPage, DEFAULT_PER_PAGE), MAX_PER_PAGE)\n      const {sortColumn, sortDirection} = this._sanitizeSort(params.sort)\n      const store = this._store()\n      const jobs = await store.listJobs({jobName, limit: perPage, offset: (page - 1) * perPage, sortColumn, sortDirection, status})\n      const total = await store.countJobs({jobName, status})\n\n      await this.render({json: {\n        jobs: jobs.map((job) => this._serializeJob(job)),\n        pagination: {page, perPage, total, totalPages: perPage > 0 ? Math.ceil(total / perPage) : 0}\n      }})\n    })\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete. */\n  async show() {\n    await this._respond(async () => {\n      const job = await this._store().getJob(this.params().id)\n\n      if (!job) {\n        await this.render({json: {error: \"not_found\"}, status: 404})\n        return\n      }\n\n      await this.render({json: {job: this._serializeJob(job)}})\n    })\n  }\n\n  /** @returns {Promise<void>} - Resolves when complete. */\n  async schedule() {\n    await this._respond(async () => {\n      const scheduled = await this.getConfiguration().getScheduledBackgroundJobsConfig()\n\n      await this.render({json: {schedule: this._serializeSchedule(scheduled)}})\n    })\n  }\n\n  /**\n   * @param {import(\"../types.js\").BackgroundJobRow} job - Job row.\n   * @returns {Record<string, any>} - Serialized job for the API.\n   */\n  _serializeJob(job) {\n    const redactArgs = Boolean(this._mountOptions().redactArgs)\n\n    return {\n      args: redactArgs ? undefined : job.args,\n      argsRedacted: redactArgs,\n      attempts: job.attempts,\n      completedAtMs: job.completedAtMs,\n      createdAtMs: job.createdAtMs,\n      failedAtMs: job.failedAtMs,\n      forked: job.forked,\n      handedOffAtMs: job.handedOffAtMs,\n      id: job.id,\n      jobName: job.jobName,\n      lastError: job.lastError,\n      maxRetries: job.maxRetries,\n      orphanedAtMs: job.orphanedAtMs,\n      scheduledAtMs: job.scheduledAtMs,\n      status: job.status,\n      workerId: job.workerId\n    }\n  }\n\n  /**\n   * @param {import(\"../../configuration-types.js\").ScheduledBackgroundJobsConfiguration | undefined} scheduled - Scheduled jobs config.\n   * @returns {Array<Record<string, any>>} - Serialized recurring jobs.\n   */\n  _serializeSchedule(scheduled) {\n    const jobs = scheduled?.jobs\n\n    if (!jobs || typeof jobs !== \"object\") return []\n\n    const redactArgs = Boolean(this._mountOptions().redactArgs)\n\n    return Object.keys(jobs).map((name) => {\n      const entry = jobs[name] || /** @type {any} */ ({})\n\n      return {\n        args: redactArgs ? undefined : (entry.args || []),\n        cron: entry.cron,\n        enabled: entry.enabled !== false,\n        every: entry.every,\n        jobName: typeof entry.class === \"function\" ? entry.class.name : undefined,\n        name,\n        options: entry.options || {}\n      }\n    })\n  }\n\n  /**\n   * @param {unknown} value - Raw status param.\n   * @returns {string | undefined} - Valid status or undefined.\n   */\n  _sanitizeStatus(value) {\n    return typeof value === \"string\" && DASHBOARD_STATUSES.includes(value) ? value : undefined\n  }\n\n  /**\n   * @param {unknown} value - Raw sort param (e.g. \"createdAtMs\" or \"-failedAtMs\").\n   * @returns {{sortColumn: string, sortDirection: \"ASC\" | \"DESC\"}} - Normalized sort.\n   */\n  _sanitizeSort(value) {\n    if (typeof value !== \"string\" || value.length === 0) {\n      return {sortColumn: \"createdAtMs\", sortDirection: \"DESC\"}\n    }\n\n    const descending = value.startsWith(\"-\")\n    const key = descending ? value.slice(1) : value\n    const sortColumn = SORTABLE_KEYS.includes(key) ? key : \"createdAtMs\"\n\n    return {sortColumn, sortDirection: descending ? \"DESC\" : \"ASC\"}\n  }\n\n  /**\n   * @param {unknown} value - Raw numeric param.\n   * @param {number} fallback - Fallback when invalid.\n   * @returns {number} - Positive integer.\n   */\n  _positiveInt(value, fallback) {\n    const numeric = Number(Array.isArray(value) ? value[0] : value)\n\n    if (!Number.isFinite(numeric) || numeric < 1) return fallback\n\n    return Math.floor(numeric)\n  }\n}\n"]}

package/build/src/background-jobs/web/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Mountable read-only background-jobs dashboard API. Include it in a routes file
+ * the way Sidekiq::Web is mounted in Rails:
+ *
+ * ```js
+ * routes.draw((route) => {
+ *   route.mount(VelociousBackgroundJobsApi, {
+ *     at: "/velocious/jobs",
+ *     authorize: async ({request, ability}) => { ... },
+ *     accessTokens: [process.env.VELOCIOUS_JOBS_TOKEN]
+ *   })
+ * })
+ * ```
+ */
+export default class VelociousBackgroundJobsApi {
+    /**
+     * Registers the jobs API under `at`. Implemented as a route-resolver hook so
+     * the controller can live inside the velocious package rather than the host
+     * app's `src/routes` directory. Invoked by the routing layer for each
+     * `route.mount(...)` registration.
+     * @param {object} args - Options.
+     * @param {import("../../configuration.js").default} args.configuration - Configuration instance.
+     * @param {string} args.at - Mount path prefix (e.g. "/velocious/jobs").
+     * @param {import("./registry.js").JobsMountOptions["authorize"]} [args.authorize] - Authorization callback.
+     * @param {string[]} [args.accessTokens] - Accepted bearer tokens for cross-origin/native access.
+     * @param {string[]} [args.allowedOrigins] - Allowed CORS origins for browser access.
+     * @param {boolean} [args.redactArgs] - When true, job arguments are omitted from responses.
+     * @param {string} [args.databaseIdentifier] - Database identifier the jobs store reads from.
+     * @returns {void} - No return value.
+     */
+    static mountInto({ accessTokens, allowedOrigins, at, authorize, configuration, databaseIdentifier, redactArgs }: {
+        configuration: import("../../configuration.js").default;
+        at: string;
+        authorize?: import("./registry.js").JobsMountOptions["authorize"];
+        accessTokens?: string[] | undefined;
+        allowedOrigins?: string[] | undefined;
+        redactArgs?: boolean | undefined;
+        databaseIdentifier?: string | undefined;
+    }): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/build/src/background-jobs/web/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/background-jobs/web/index.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH;IACE;;;;;;;;;;;;;;OAcG;IACH,iHATG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;QAC3B,EAAE,EAAf,MAAM;QACuD,SAAS,GAAtE,OAAO,eAAe,EAAE,gBAAgB,CAAC,WAAW,CAAC;QACrC,YAAY;QACZ,cAAc;QACf,UAAU;QACX,kBAAkB;KACxC,GAAU,IAAI,CAqBhB;CACF"}

package/build/src/background-jobs/web/index.js

@@ -0,0 +1,53 @@
+// @ts-check
+import VelociousBackgroundJobsWebController from "./controller.js";
+import { matchJobsApiPath, normalizeMountPrefix } from "./path-matcher.js";
+import { registerJobsMount } from "./registry.js";
+/**
+ * Mountable read-only background-jobs dashboard API. Include it in a routes file
+ * the way Sidekiq::Web is mounted in Rails:
+ *
+ * ```js
+ * routes.draw((route) => {
+ *   route.mount(VelociousBackgroundJobsApi, {
+ *     at: "/velocious/jobs",
+ *     authorize: async ({request, ability}) => { ... },
+ *     accessTokens: [process.env.VELOCIOUS_JOBS_TOKEN]
+ *   })
+ * })
+ * ```
+ */
+export default class VelociousBackgroundJobsApi {
+    /**
+     * Registers the jobs API under `at`. Implemented as a route-resolver hook so
+     * the controller can live inside the velocious package rather than the host
+     * app's `src/routes` directory. Invoked by the routing layer for each
+     * `route.mount(...)` registration.
+     * @param {object} args - Options.
+     * @param {import("../../configuration.js").default} args.configuration - Configuration instance.
+     * @param {string} args.at - Mount path prefix (e.g. "/velocious/jobs").
+     * @param {import("./registry.js").JobsMountOptions["authorize"]} [args.authorize] - Authorization callback.
+     * @param {string[]} [args.accessTokens] - Accepted bearer tokens for cross-origin/native access.
+     * @param {string[]} [args.allowedOrigins] - Allowed CORS origins for browser access.
+     * @param {boolean} [args.redactArgs] - When true, job arguments are omitted from responses.
+     * @param {string} [args.databaseIdentifier] - Database identifier the jobs store reads from.
+     * @returns {void} - No return value.
+     */
+    static mountInto({ accessTokens, allowedOrigins, at, authorize, configuration, databaseIdentifier, redactArgs }) {
+        if (!configuration)
+            throw new Error("No configuration given");
+        const prefix = normalizeMountPrefix(at);
+        registerJobsMount(configuration, prefix, { accessTokens, allowedOrigins, authorize, databaseIdentifier, redactArgs });
+        configuration.addRouteResolverHook(({ currentPath, request }) => {
+            const match = matchJobsApiPath({ method: request.httpMethod(), path: currentPath, prefix });
+            if (!match)
+                return null;
+            return {
+                action: match.action,
+                controller: "velociousBackgroundJobsWeb",
+                controllerClass: VelociousBackgroundJobsWebController,
+                params: { ...match.params, velociousJobsMountAt: prefix }
+            };
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/background-jobs/web/path-matcher.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @typedef {object} JobsApiMatch
+ * @property {string} action - Controller action to run.
+ * @property {Record<string, string>} params - Extra params extracted from the path.
+ */
+/**
+ * Normalizes a mount prefix: ensures a leading slash and strips any trailing
+ * slash so `/velocious/jobs/` and `/velocious/jobs` behave identically.
+ * @param {string} at - Raw mount prefix.
+ * @returns {string} - Normalized prefix.
+ */
+export function normalizeMountPrefix(at: string): string;
+/**
+ * Matches an incoming request against the read-only jobs API routes that live
+ * under the mount prefix. Returns the controller action plus any extracted
+ * params, or null when the path/method isn't part of the jobs API.
+ * @param {object} args - Options.
+ * @param {string} args.prefix - Normalized mount prefix.
+ * @param {string} args.path - Request path without query string.
+ * @param {string} args.method - HTTP method.
+ * @returns {JobsApiMatch | null} - Matched action or null.
+ */
+export function matchJobsApiPath({ prefix, path, method }: {
+    prefix: string;
+    path: string;
+    method: string;
+}): JobsApiMatch | null;
+export type JobsApiMatch = {
+    /**
+     * - Controller action to run.
+     */
+    action: string;
+    /**
+     * - Extra params extracted from the path.
+     */
+    params: Record<string, string>;
+};
+//# sourceMappingURL=path-matcher.d.ts.map

package/build/src/background-jobs/web/path-matcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-matcher.d.ts","sourceRoot":"","sources":["../../../../src/background-jobs/web/path-matcher.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;GAKG;AACH,yCAHW,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;;GASG;AACH,2DALG;IAAqB,MAAM,EAAnB,MAAM;IACO,IAAI,EAAjB,MAAM;IACO,MAAM,EAAnB,MAAM;CACd,GAAU,YAAY,GAAG,IAAI,CAuC/B;;;;;YArEa,MAAM;;;;YACN,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC"}

package/build/src/background-jobs/web/path-matcher.js

@@ -0,0 +1,71 @@
+// @ts-check
+/**
+ * @typedef {object} JobsApiMatch
+ * @property {string} action - Controller action to run.
+ * @property {Record<string, string>} params - Extra params extracted from the path.
+ */
+/**
+ * Normalizes a mount prefix: ensures a leading slash and strips any trailing
+ * slash so `/velocious/jobs/` and `/velocious/jobs` behave identically.
+ * @param {string} at - Raw mount prefix.
+ * @returns {string} - Normalized prefix.
+ */
+export function normalizeMountPrefix(at) {
+    if (typeof at !== "string" || !at.startsWith("/")) {
+        throw new Error(`mount requires an 'at' path starting with '/', got: ${String(at)}`);
+    }
+    if (at.length > 1 && at.endsWith("/")) {
+        return at.slice(0, -1);
+    }
+    return at;
+}
+/**
+ * Matches an incoming request against the read-only jobs API routes that live
+ * under the mount prefix. Returns the controller action plus any extracted
+ * params, or null when the path/method isn't part of the jobs API.
+ * @param {object} args - Options.
+ * @param {string} args.prefix - Normalized mount prefix.
+ * @param {string} args.path - Request path without query string.
+ * @param {string} args.method - HTTP method.
+ * @returns {JobsApiMatch | null} - Matched action or null.
+ */
+export function matchJobsApiPath({ prefix, path, method }) {
+    /** @type {string} */
+    let subPath;
+    if (prefix === "/") {
+        // Root mount: the whole path is the sub-path (avoid building a "//" guard).
+        subPath = path;
+    }
+    else if (path === prefix) {
+        subPath = "/";
+    }
+    else if (path.startsWith(`${prefix}/`)) {
+        subPath = path.slice(prefix.length);
+    }
+    else {
+        return null;
+    }
+    if (method === "GET" && subPath === "/api/health")
+        return { action: "health", params: {} };
+    if (method === "GET" && subPath === "/api/stats")
+        return { action: "stats", params: {} };
+    if (method === "GET" && subPath === "/api/schedule")
+        return { action: "schedule", params: {} };
+    if (method === "GET" && subPath === "/api/jobs")
+        return { action: "index", params: {} };
+    if (method === "GET") {
+        const jobMatch = subPath.match(/^\/api\/jobs\/([^/]+)$/);
+        if (jobMatch) {
+            let id;
+            try {
+                id = decodeURIComponent(jobMatch[1]);
+            }
+            catch {
+                return null;
+            }
+            return { action: "show", params: { id } };
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/src/background-jobs/web/registry.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @param {import("../../configuration.js").default} configuration - Configuration instance.
+ * @param {string} at - Normalized mount path.
+ * @param {JobsMountOptions} options - Mount options.
+ * @returns {void} - No return value.
+ */
+export function registerJobsMount(configuration: import("../../configuration.js").default, at: string, options: JobsMountOptions): void;
+/**
+ * @param {import("../../configuration.js").default} configuration - Configuration instance.
+ * @param {string} at - Normalized mount path.
+ * @returns {JobsMountOptions | undefined} - Mount options if registered.
+ */
+export function getJobsMount(configuration: import("../../configuration.js").default, at: string): JobsMountOptions | undefined;
+export type JobsMountOptions = {
+    /**
+     * - Authorization callback. Return true to allow the request.
+     */
+    authorize?: ((args: {
+        request: import("../../http-server/client/request.js").default;
+        ability: (import("../../authorization/ability.js").default | undefined);
+        token: (string | null);
+        configuration: import("../../configuration.js").default;
+    }) => (boolean | void | Promise<boolean | void>)) | undefined;
+    /**
+     * - Bearer tokens accepted for cross-origin/native access.
+     */
+    accessTokens?: string[] | undefined;
+    /**
+     * - Origins allowed for cross-origin browser access.
+     */
+    allowedOrigins?: string[] | undefined;
+    /**
+     * - When true, job arguments are omitted from API responses.
+     */
+    redactArgs?: boolean | undefined;
+    /**
+     * - Database identifier the jobs store reads from.
+     */
+    databaseIdentifier?: string | undefined;
+};
+//# sourceMappingURL=registry.d.ts.map

package/build/src/background-jobs/web/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../src/background-jobs/web/registry.js"],"names":[],"mappings":"AAqBA;;;;;GAKG;AACH,iDALW,OAAO,wBAAwB,EAAE,OAAO,MACxC,MAAM,WACN,gBAAgB,GACd,IAAI,CAWhB;AAED;;;;GAIG;AACH,4CAJW,OAAO,wBAAwB,EAAE,OAAO,MACxC,MAAM,GACJ,gBAAgB,GAAG,SAAS,CAIxC;;;;;wBAzCoB;QAAC,OAAO,EAAE,OAAO,qCAAqC,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,CAAC,OAAO,gCAAgC,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC;QAAC,KAAK,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;QAAC,aAAa,EAAE,OAAO,wBAAwB,EAAE,OAAO,CAAA;KAAC,KAAK,CAAC,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC"}

package/build/src/background-jobs/web/registry.js

@@ -0,0 +1,41 @@
+// @ts-check
+/**
+ * @typedef {object} JobsMountOptions
+ * @property {(args: {request: import("../../http-server/client/request.js").default, ability: (import("../../authorization/ability.js").default | undefined), token: (string | null), configuration: import("../../configuration.js").default}) => (boolean | void | Promise<boolean | void>)} [authorize] - Authorization callback. Return true to allow the request.
+ * @property {string[]} [accessTokens] - Bearer tokens accepted for cross-origin/native access.
+ * @property {string[]} [allowedOrigins] - Origins allowed for cross-origin browser access.
+ * @property {boolean} [redactArgs] - When true, job arguments are omitted from API responses.
+ * @property {string} [databaseIdentifier] - Database identifier the jobs store reads from.
+ */
+/**
+ * Mount options are keyed by configuration so multiple configurations (e.g.
+ * across tests) never share state, and by mount path so a single configuration
+ * can mount the dashboard at more than one prefix. Functions in the options
+ * (the `authorize` callback) can't travel through route params, so the
+ * controller looks them up here using the plain `at` string it receives.
+ * @type {WeakMap<import("../../configuration.js").default, Map<string, JobsMountOptions>>}
+ */
+const registry = new WeakMap();
+/**
+ * @param {import("../../configuration.js").default} configuration - Configuration instance.
+ * @param {string} at - Normalized mount path.
+ * @param {JobsMountOptions} options - Mount options.
+ * @returns {void} - No return value.
+ */
+export function registerJobsMount(configuration, at, options) {
+    let byPath = registry.get(configuration);
+    if (!byPath) {
+        byPath = new Map();
+        registry.set(configuration, byPath);
+    }
+    byPath.set(at, options);
+}
+/**
+ * @param {import("../../configuration.js").default} configuration - Configuration instance.
+ * @param {string} at - Normalized mount path.
+ * @returns {JobsMountOptions | undefined} - Mount options if registered.
+ */
+export function getJobsMount(configuration, at) {
+    return registry.get(configuration)?.get(at);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYmFja2dyb3VuZC1qb2JzL3dlYi9yZWdpc3RyeS5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBRVo7Ozs7Ozs7R0FPRztBQUVIOzs7Ozs7O0dBT0c7QUFDSCxNQUFNLFFBQVEsR0FBRyxJQUFJLE9BQU8sRUFBRSxDQUFBO0FBRTlCOzs7OztHQUtHO0FBQ0gsTUFBTSxVQUFVLGlCQUFpQixDQUFDLGFBQWEsRUFBRSxFQUFFLEVBQUUsT0FBTztJQUMxRCxJQUFJLE1BQU0sR0FBRyxRQUFRLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxDQUFBO0lBRXhDLElBQUksQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUNaLE1BQU0sR0FBRyxJQUFJLEdBQUcsRUFBRSxDQUFBO1FBQ2xCLFFBQVEsQ0FBQyxHQUFHLENBQUMsYUFBYSxFQUFFLE1BQU0sQ0FBQyxDQUFBO0lBQ3JDLENBQUM7SUFFRCxNQUFNLENBQUMsR0FBRyxDQUFDLEVBQUUsRUFBRSxPQUFPLENBQUMsQ0FBQTtBQUN6QixDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILE1BQU0sVUFBVSxZQUFZLENBQUMsYUFBYSxFQUFFLEVBQUU7SUFDNUMsT0FBTyxRQUFRLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxFQUFFLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQTtBQUM3QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbi8qKlxuICogQHR5cGVkZWYge29iamVjdH0gSm9ic01vdW50T3B0aW9uc1xuICogQHByb3BlcnR5IHsoYXJnczoge3JlcXVlc3Q6IGltcG9ydChcIi4uLy4uL2h0dHAtc2VydmVyL2NsaWVudC9yZXF1ZXN0LmpzXCIpLmRlZmF1bHQsIGFiaWxpdHk6IChpbXBvcnQoXCIuLi8uLi9hdXRob3JpemF0aW9uL2FiaWxpdHkuanNcIikuZGVmYXVsdCB8IHVuZGVmaW5lZCksIHRva2VuOiAoc3RyaW5nIHwgbnVsbCksIGNvbmZpZ3VyYXRpb246IGltcG9ydChcIi4uLy4uL2NvbmZpZ3VyYXRpb24uanNcIikuZGVmYXVsdH0pID0+IChib29sZWFuIHwgdm9pZCB8IFByb21pc2U8Ym9vbGVhbiB8IHZvaWQ+KX0gW2F1dGhvcml6ZV0gLSBBdXRob3JpemF0aW9uIGNhbGxiYWNrLiBSZXR1cm4gdHJ1ZSB0byBhbGxvdyB0aGUgcmVxdWVzdC5cbiAqIEBwcm9wZXJ0eSB7c3RyaW5nW119IFthY2Nlc3NUb2tlbnNdIC0gQmVhcmVyIHRva2VucyBhY2NlcHRlZCBmb3IgY3Jvc3Mtb3JpZ2luL25hdGl2ZSBhY2Nlc3MuXG4gKiBAcHJvcGVydHkge3N0cmluZ1tdfSBbYWxsb3dlZE9yaWdpbnNdIC0gT3JpZ2lucyBhbGxvd2VkIGZvciBjcm9zcy1vcmlnaW4gYnJvd3NlciBhY2Nlc3MuXG4gKiBAcHJvcGVydHkge2Jvb2xlYW59IFtyZWRhY3RBcmdzXSAtIFdoZW4gdHJ1ZSwgam9iIGFyZ3VtZW50cyBhcmUgb21pdHRlZCBmcm9tIEFQSSByZXNwb25zZXMuXG4gKiBAcHJvcGVydHkge3N0cmluZ30gW2RhdGFiYXNlSWRlbnRpZmllcl0gLSBEYXRhYmFzZSBpZGVudGlmaWVyIHRoZSBqb2JzIHN0b3JlIHJlYWRzIGZyb20uXG4gKi9cblxuLyoqXG4gKiBNb3VudCBvcHRpb25zIGFyZSBrZXllZCBieSBjb25maWd1cmF0aW9uIHNvIG11bHRpcGxlIGNvbmZpZ3VyYXRpb25zIChlLmcuXG4gKiBhY3Jvc3MgdGVzdHMpIG5ldmVyIHNoYXJlIHN0YXRlLCBhbmQgYnkgbW91bnQgcGF0aCBzbyBhIHNpbmdsZSBjb25maWd1cmF0aW9uXG4gKiBjYW4gbW91bnQgdGhlIGRhc2hib2FyZCBhdCBtb3JlIHRoYW4gb25lIHByZWZpeC4gRnVuY3Rpb25zIGluIHRoZSBvcHRpb25zXG4gKiAodGhlIGBhdXRob3JpemVgIGNhbGxiYWNrKSBjYW4ndCB0cmF2ZWwgdGhyb3VnaCByb3V0ZSBwYXJhbXMsIHNvIHRoZVxuICogY29udHJvbGxlciBsb29rcyB0aGVtIHVwIGhlcmUgdXNpbmcgdGhlIHBsYWluIGBhdGAgc3RyaW5nIGl0IHJlY2VpdmVzLlxuICogQHR5cGUge1dlYWtNYXA8aW1wb3J0KFwiLi4vLi4vY29uZmlndXJhdGlvbi5qc1wiKS5kZWZhdWx0LCBNYXA8c3RyaW5nLCBKb2JzTW91bnRPcHRpb25zPj59XG4gKi9cbmNvbnN0IHJlZ2lzdHJ5ID0gbmV3IFdlYWtNYXAoKVxuXG4vKipcbiAqIEBwYXJhbSB7aW1wb3J0KFwiLi4vLi4vY29uZmlndXJhdGlvbi5qc1wiKS5kZWZhdWx0fSBjb25maWd1cmF0aW9uIC0gQ29uZmlndXJhdGlvbiBpbnN0YW5jZS5cbiAqIEBwYXJhbSB7c3RyaW5nfSBhdCAtIE5vcm1hbGl6ZWQgbW91bnQgcGF0aC5cbiAqIEBwYXJhbSB7Sm9ic01vdW50T3B0aW9uc30gb3B0aW9ucyAtIE1vdW50IG9wdGlvbnMuXG4gKiBAcmV0dXJucyB7dm9pZH0gLSBObyByZXR1cm4gdmFsdWUuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiByZWdpc3RlckpvYnNNb3VudChjb25maWd1cmF0aW9uLCBhdCwgb3B0aW9ucykge1xuICBsZXQgYnlQYXRoID0gcmVnaXN0cnkuZ2V0KGNvbmZpZ3VyYXRpb24pXG5cbiAgaWYgKCFieVBhdGgpIHtcbiAgICBieVBhdGggPSBuZXcgTWFwKClcbiAgICByZWdpc3RyeS5zZXQoY29uZmlndXJhdGlvbiwgYnlQYXRoKVxuICB9XG5cbiAgYnlQYXRoLnNldChhdCwgb3B0aW9ucylcbn1cblxuLyoqXG4gKiBAcGFyYW0ge2ltcG9ydChcIi4uLy4uL2NvbmZpZ3VyYXRpb24uanNcIikuZGVmYXVsdH0gY29uZmlndXJhdGlvbiAtIENvbmZpZ3VyYXRpb24gaW5zdGFuY2UuXG4gKiBAcGFyYW0ge3N0cmluZ30gYXQgLSBOb3JtYWxpemVkIG1vdW50IHBhdGguXG4gKiBAcmV0dXJucyB7Sm9ic01vdW50T3B0aW9ucyB8IHVuZGVmaW5lZH0gLSBNb3VudCBvcHRpb25zIGlmIHJlZ2lzdGVyZWQuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRKb2JzTW91bnQoY29uZmlndXJhdGlvbiwgYXQpIHtcbiAgcmV0dXJuIHJlZ2lzdHJ5LmdldChjb25maWd1cmF0aW9uKT8uZ2V0KGF0KVxufVxuIl19

package/build/src/configuration.d.ts

@@ -84,6 +84,8 @@ export default class VelociousConfiguration {
     _logging: import("./configuration-types.js").LoggingConfiguration | undefined;
     _mailerBackend: import("./configuration-types.js").MailerBackend | undefined;
     _routeResolverHooks: import("./configuration-types.js").RouteResolverHookType[];
+    /** @type {WeakSet<object>} */
+    _appliedRouteMounts: WeakSet<object>;
     _errorEvents: import("eventemitter3").EventEmitter<string | symbol, any>;
     /** @type {{[key: string]: import("./database/pool/base.js").default}} */
     databasePools: {
@@ -481,6 +483,15 @@ export default class VelociousConfiguration {
      */
     setRoutes(newRoutes: import("./routes/index.js").default): void;
     _routes: import("./routes/index.js").default | undefined;
+    /**
+     * Applies any `route.mount(...)` registrations from the routes file by letting
+     * each mountable register its routes (typically route-resolver hooks) against
+     * this configuration. Guarded so repeated setRoutes calls with the same routes
+     * don't register a mount more than once.
+     * @param {import("./routes/index.js").default} newRoutes - Routes instance.
+     * @returns {void} - No return value.
+     */
+    _applyRouteMounts(newRoutes: import("./routes/index.js").default): void;
     /**
      * Adds plugin/library routes using a lightweight route DSL backed by route resolver hooks.
      * @param {(routes: import("./routes/plugin-routes.js").default) => void} callback - Routes callback.