velocious 1.0.431 → 1.0.433

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

@@ -1,280 +1,244 @@
 // @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 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 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) || {};
     }
-
-    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
+    /**
+     * 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;
     }
-
-    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
+    /**
+     * 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");
     }
-  }
-
-  /**
-   * 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"}
+    /**
+     * 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);
     }
-
-    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,9 +1,7 @@
 // @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:
@@ -19,39 +17,37 @@ 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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