velocious 1.0.430 → 1.0.431

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

@@ -1,244 +1,280 @@
 // @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;
+
+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 {
-    /**
-     * Runs mount options.
-     * @returns {import("./registry.js").JobsMountOptions} - Options for the mount that matched this request.
-     */
-    _mountOptions() {
-        const at = this.params().velociousJobsMountAt;
-        return getJobsMount(this.getConfiguration(), at) || {};
+  /**
+   * Runs mount options.
+   * @returns {import("./registry.js").JobsMountOptions} - Options for the mount that matched this request.
+   */
+  _mountOptions() {
+    const at = this.params().velociousJobsMountAt
+
+    return getJobsMount(this.getConfiguration(), at) || {}
+  }
+
+  /**
+   * Runs store.
+   * @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
+      })
     }
-    /**
-     * Runs store.
-     * @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;
+
+    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
     }
-    /**
-     * 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");
+
+    await actionFn()
+  }
+
+  /**
+   * Runs health.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async health() {
+    await this._respond(async () => {
+      await this.render({json: {ok: true, service: "velocious-background-jobs"}})
+    })
+  }
+
+  /**
+   * Runs stats.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async stats() {
+    await this._respond(async () => {
+      const counts = await this._store().countsByStatus()
+      /**
+       * By status.
+        @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}})
+    })
+  }
+
+  /**
+   * Runs index.
+   * @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}
+      }})
+    })
+  }
+
+  /**
+   * Runs show.
+   * @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)}})
+    })
+  }
+
+  /**
+   * Runs schedule.
+   * @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)}})
+    })
+  }
+
+  /**
+   * Runs serialize job.
+   * @param {import("../types.js").BackgroundJobRow} job - Job row.
+   * @returns {Record<string, ?>} - 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,
+      executionMode: job.executionMode,
+      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
     }
-    /**
-     * 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();
-    }
-    /**
-     * Runs health.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async health() {
-        await this._respond(async () => {
-            await this.render({ json: { ok: true, service: "velocious-background-jobs" } });
-        });
-    }
-    /**
-     * Runs stats.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async stats() {
-        await this._respond(async () => {
-            const counts = await this._store().countsByStatus();
-            /**
-             * By status.
-              @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 } });
-        });
-    }
-    /**
-     * Runs index.
-     * @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 }
-                } });
-        });
-    }
-    /**
-     * Runs show.
-     * @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) } });
-        });
-    }
-    /**
-     * Runs schedule.
-     * @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) } });
-        });
-    }
-    /**
-     * Runs serialize job.
-     * @param {import("../types.js").BackgroundJobRow} job - Job row.
-     * @returns {Record<string, ?>} - 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,
-            executionMode: job.executionMode,
-            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
-        };
-    }
-    /**
-     * Runs serialize schedule.
-     * @param {import("../../configuration-types.js").ScheduledBackgroundJobsConfiguration | undefined} scheduled - Scheduled jobs config.
-     * @returns {Array<Record<string, ?>>} - 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] || /**
-                                         * Narrows the runtime value to the documented type.
-                                          @type {?} */
-                ({});
-            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 || {}
-            };
-        });
-    }
-    /**
-     * Runs sanitize status.
-     * @param {?} value - Raw status param.
-     * @returns {string | undefined} - Valid status or undefined.
-     */
-    _sanitizeStatus(value) {
-        return typeof value === "string" && DASHBOARD_STATUSES.includes(value) ? value : undefined;
-    }
-    /**
-     * Runs sanitize sort.
-     * @param {?} 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" };
-    }
-    /**
-     * Runs positive int.
-     * @param {?} 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);
+  }
+
+  /**
+   * Runs serialize schedule.
+   * @param {import("../../configuration-types.js").ScheduledBackgroundJobsConfiguration | undefined} scheduled - Scheduled jobs config.
+   * @returns {Array<Record<string, ?>>} - 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] || /**
+                                   * Narrows the runtime value to the documented type.
+                                    @type {?} */ ({})
+
+      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 || {}
+      }
+    })
+  }
+
+  /**
+   * Runs sanitize status.
+   * @param {?} value - Raw status param.
+   * @returns {string | undefined} - Valid status or undefined.
+   */
+  _sanitizeStatus(value) {
+    return typeof value === "string" && DASHBOARD_STATUSES.includes(value) ? value : undefined
+  }
+
+  /**
+   * Runs sanitize sort.
+   * @param {?} 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"}
+  }
+
+  /**
+   * Runs positive int.
+   * @param {?} 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  /**\n   * Runs mount options.\n   * @returns {import(\"./registry.js\").JobsMountOptions} - Options for the mount that matched this request.\n   */\n  _mountOptions() {\n    const at = this.params().velociousJobsMountAt\n\n    return getJobsMount(this.getConfiguration(), at) || {}\n  }\n\n  /**\n   * Runs store.\n   * @returns {BackgroundJobsStore} - Jobs store scoped to the mount's database.\n   */\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  /**\n   * Runs health.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async health() {\n    await this._respond(async () => {\n      await this.render({json: {ok: true, service: \"velocious-background-jobs\"}})\n    })\n  }\n\n  /**\n   * Runs stats.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async stats() {\n    await this._respond(async () => {\n      const counts = await this._store().countsByStatus()\n      /**\n       * By status.\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  /**\n   * Runs index.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\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  /**\n   * Runs show.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\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  /**\n   * Runs schedule.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\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   * Runs serialize job.\n   * @param {import(\"../types.js\").BackgroundJobRow} job - Job row.\n   * @returns {Record<string, ?>} - 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      executionMode: job.executionMode,\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   * Runs serialize schedule.\n   * @param {import(\"../../configuration-types.js\").ScheduledBackgroundJobsConfiguration | undefined} scheduled - Scheduled jobs config.\n   * @returns {Array<Record<string, ?>>} - 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] || /**\n                                   * Narrows the runtime value to the documented type.\n                                    @type {?} */ ({})\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   * Runs sanitize status.\n   * @param {?} 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   * Runs sanitize sort.\n   * @param {?} 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   * Runs positive int.\n   * @param {?} 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.js

@@ -1,7 +1,9 @@
 // @ts-check
-import VelociousBackgroundJobsWebController from "./controller.js";
-import { matchJobsApiPath, normalizeMountPrefix } from "./path-matcher.js";
-import { registerJobsMount } from "./registry.js";
+
+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:
@@ -17,37 +19,39 @@ import { registerJobsMount } from "./registry.js";
  * ```
  */
 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 }
-            };
-        });
-    }
+  /**
+   * 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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