@mandujs/core 0.53.2 → 0.54.0

package/src/middleware/scheduler-cron.ts

@@ -1,96 +1,96 @@
-/**
- * `scheduler-cron` — request-level middleware that exposes the running
- * scheduler registration on `ctx` so handlers can inspect job status or
- * trigger an ad-hoc tick for debugging.
- *
- * This is intentionally a thin bridge — the cron jobs themselves are
- * defined with {@link import("../scheduler").defineCron} and started at
- * `startServer()` boot time. The middleware does NOT start or stop the
- * scheduler; its only job is to make the `CronRegistration` handle
- * available to downstream request handlers (e.g., an observability
- * dashboard API that wants to render `status()`).
- *
- * The middleware is opt-in — it's NOT part of the default chain. Add it
- * to `mandu.config.ts` `middleware: [...]` only if you have a route that
- * needs `ctx.scheduler`.
- *
- * @example
- * ```ts
- * // mandu.config.ts
- * import { defineConfig } from "@mandujs/core";
- * import { schedulerCron } from "@mandujs/core/middleware";
- * import { jobs } from "./jobs";
- *
- * export default defineConfig({
- *   scheduler: { jobs },
- *   middleware: [schedulerCron()],
- * });
- * ```
- */
-
-import { defineMiddleware } from "./define";
-import type { Middleware } from "./define";
-import type { CronRegistration } from "../scheduler";
-
-/**
- * Global handle to the active {@link CronRegistration}, set by
- * `startServer()` when it boots the scheduler. `scheduler-cron` middleware
- * reads this slot on every request so the registration is always the one
- * actually running.
- *
- * We store it on `globalThis` rather than module-scope so that multiple
- * bundles (e.g., `@mandujs/core` loaded twice in a monorepo hot-reload)
- * still see the same handle — matches the registry pattern in
- * `runtime/server.ts`.
- */
-const GLOBAL_KEY = "__MANDU_SCHEDULER_REGISTRATION__";
-
-interface SchedulerGlobal {
-  [GLOBAL_KEY]?: CronRegistration | null;
-}
-
-export function setActiveSchedulerRegistration(reg: CronRegistration | null): void {
-  (globalThis as unknown as SchedulerGlobal)[GLOBAL_KEY] = reg;
-}
-
-export function getActiveSchedulerRegistration(): CronRegistration | null {
-  return (globalThis as unknown as SchedulerGlobal)[GLOBAL_KEY] ?? null;
-}
-
-export interface SchedulerCronMiddlewareOptions {
-  /**
-   * Custom header to stamp on the response with the current scheduler job
-   * count. Useful for smoke-checking that the scheduler is running in a
-   * given environment. Default: no header is added.
-   */
-  statusHeader?: string;
-}
-
-/**
- * Creates a middleware that exposes the scheduler registration via a response
- * header and (optionally) stamps a status header. The registration itself is
- * wired into `ctx` via the request-level composition chain — downstream
- * code reads it with {@link getActiveSchedulerRegistration}.
- */
-export function schedulerCron(options: SchedulerCronMiddlewareOptions = {}): Middleware {
-  return defineMiddleware({
-    name: "scheduler-cron",
-    async handler(_req, next) {
-      const response = await next();
-      const reg = getActiveSchedulerRegistration();
-      if (reg && options.statusHeader) {
-        const status = reg.status();
-        const jobCount = Object.keys(status).length;
-        // Clone headers to avoid mutating an immutable response body.
-        const headers = new Headers(response.headers);
-        headers.set(options.statusHeader, String(jobCount));
-        return new Response(response.body, {
-          status: response.status,
-          statusText: response.statusText,
-          headers,
-        });
-      }
-      return response;
-    },
-  });
-}
+/**
+ * `scheduler-cron` — request-level middleware that exposes the running
+ * scheduler registration on `ctx` so handlers can inspect job status or
+ * trigger an ad-hoc tick for debugging.
+ *
+ * This is intentionally a thin bridge — the cron jobs themselves are
+ * defined with {@link import("../scheduler").defineCron} and started at
+ * `startServer()` boot time. The middleware does NOT start or stop the
+ * scheduler; its only job is to make the `CronRegistration` handle
+ * available to downstream request handlers (e.g., an observability
+ * dashboard API that wants to render `status()`).
+ *
+ * The middleware is opt-in — it's NOT part of the default chain. Add it
+ * to `mandu.config.ts` `middleware: [...]` only if you have a route that
+ * needs `ctx.scheduler`.
+ *
+ * @example
+ * ```ts
+ * // mandu.config.ts
+ * import { defineConfig } from "@mandujs/core";
+ * import { schedulerCron } from "@mandujs/core/middleware";
+ * import { jobs } from "./jobs";
+ *
+ * export default defineConfig({
+ *   scheduler: { jobs },
+ *   middleware: [schedulerCron()],
+ * });
+ * ```
+ */
+
+import { defineMiddleware } from "./define";
+import type { Middleware } from "./define";
+import type { CronRegistration } from "../scheduler";
+
+/**
+ * Global handle to the active {@link CronRegistration}, set by
+ * `startServer()` when it boots the scheduler. `scheduler-cron` middleware
+ * reads this slot on every request so the registration is always the one
+ * actually running.
+ *
+ * We store it on `globalThis` rather than module-scope so that multiple
+ * bundles (e.g., `@mandujs/core` loaded twice in a monorepo hot-reload)
+ * still see the same handle — matches the registry pattern in
+ * `runtime/server.ts`.
+ */
+const GLOBAL_KEY = "__MANDU_SCHEDULER_REGISTRATION__";
+
+interface SchedulerGlobal {
+  [GLOBAL_KEY]?: CronRegistration | null;
+}
+
+export function setActiveSchedulerRegistration(reg: CronRegistration | null): void {
+  (globalThis as unknown as SchedulerGlobal)[GLOBAL_KEY] = reg;
+}
+
+export function getActiveSchedulerRegistration(): CronRegistration | null {
+  return (globalThis as unknown as SchedulerGlobal)[GLOBAL_KEY] ?? null;
+}
+
+export interface SchedulerCronMiddlewareOptions {
+  /**
+   * Custom header to stamp on the response with the current scheduler job
+   * count. Useful for smoke-checking that the scheduler is running in a
+   * given environment. Default: no header is added.
+   */
+  statusHeader?: string;
+}
+
+/**
+ * Creates a middleware that exposes the scheduler registration via a response
+ * header and (optionally) stamps a status header. The registration itself is
+ * wired into `ctx` via the request-level composition chain — downstream
+ * code reads it with {@link getActiveSchedulerRegistration}.
+ */
+export function schedulerCron(options: SchedulerCronMiddlewareOptions = {}): Middleware {
+  return defineMiddleware({
+    name: "scheduler-cron",
+    async handler(_req, next) {
+      const response = await next();
+      const reg = getActiveSchedulerRegistration();
+      if (reg && options.statusHeader) {
+        const status = reg.status();
+        const jobCount = Object.keys(status).length;
+        // Clone headers to avoid mutating an immutable response body.
+        const headers = new Headers(response.headers);
+        headers.set(options.statusHeader, String(jobCount));
+        return new Response(response.body, {
+          status: response.status,
+          statusText: response.statusText,
+          headers,
+        });
+      }
+      return response;
+    },
+  });
+}