@rebasepro/server-core 0.0.1-canary.09e5ec5

package/src/cron/cron-routes.test.ts

@@ -0,0 +1,265 @@
+import { describe, it, expect, beforeEach } from "@jest/globals";
+import { Hono } from "hono";
+import { CronScheduler } from "./cron-scheduler";
+import { createCronRoutes } from "./cron-routes";
+import type { LoadedCronJob } from "./cron-loader";
+import type { CronJobDefinition } from "@rebasepro/types";
+
+// ─── Helpers ────────────────────────────────────────────────────────
+
+function makeJob(
+    id: string,
+    overrides: Partial<CronJobDefinition> = {}
+): LoadedCronJob {
+    return {
+        id,
+        definition: {
+            schedule: "0 * * * *",
+            name: `Job ${id}`,
+            enabled: true,
+            timeoutSeconds: 5,
+            handler: async (ctx) => {
+                ctx.log("executed");
+                return { ran: true };
+            },
+            ...overrides
+        }
+    };
+}
+
+async function jsonBody(res: Response): Promise<Record<string, unknown>> {
+    return res.json() as Promise<Record<string, unknown>>;
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────
+
+describe("cron-routes", () => {
+    let scheduler: CronScheduler;
+    let app: Hono;
+
+    beforeEach(() => {
+        scheduler = new CronScheduler();
+        scheduler.registerJobs([
+            makeJob("job-a", { name: "Job A",
+description: "First job" }),
+            makeJob("job-b", { name: "Job B" })
+        ]);
+
+        app = new Hono();
+        app.route("/cron", createCronRoutes(scheduler));
+    });
+
+    // ── GET / (list) ────────────────────────────────────────────────
+
+    describe("GET /cron", () => {
+        it("returns all registered jobs", async () => {
+            const res = await app.request("/cron");
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            const jobs = body.jobs as Array<Record<string, unknown>>;
+            expect(jobs).toHaveLength(2);
+            expect(jobs.map((j) => j.id).sort()).toEqual(["job-a", "job-b"]);
+        });
+
+        it("each job has the expected shape", async () => {
+            const res = await app.request("/cron");
+            const body = await jsonBody(res);
+            const jobs = body.jobs as Array<Record<string, unknown>>;
+            const jobA = jobs.find((j) => j.id === "job-a")!;
+
+            expect(jobA.name).toBe("Job A");
+            expect(jobA.description).toBe("First job");
+            expect(jobA.schedule).toBe("0 * * * *");
+            expect(jobA.enabled).toBe(true);
+            expect(jobA.state).toBe("idle");
+            expect(jobA.totalRuns).toBe(0);
+            expect(jobA.totalFailures).toBe(0);
+        });
+    });
+
+    // ── GET /:id (single) ───────────────────────────────────────────
+
+    describe("GET /cron/:id", () => {
+        it("returns a single job", async () => {
+            const res = await app.request("/cron/job-a");
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            const job = body.job as Record<string, unknown>;
+            expect(job.id).toBe("job-a");
+            expect(job.name).toBe("Job A");
+        });
+
+        it("returns 404 for nonexistent job", async () => {
+            const res = await app.request("/cron/nonexistent");
+            expect(res.status).toBe(404);
+
+            const body = await jsonBody(res);
+            expect((body.error as Record<string, unknown>).code).toBe("NOT_FOUND");
+        });
+    });
+
+    // ── POST /:id/trigger ───────────────────────────────────────────
+
+    describe("POST /cron/:id/trigger", () => {
+        it("triggers a job and returns log + updated status", async () => {
+            const res = await app.request("/cron/job-a/trigger", {
+                method: "POST"
+            });
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            const log = body.log as Record<string, unknown>;
+            const job = body.job as Record<string, unknown>;
+
+            expect(log.jobId).toBe("job-a");
+            expect(log.success).toBe(true);
+            expect(log.manual).toBe(true);
+            expect((log.logs as string[])).toContain("executed");
+            expect(log.result).toEqual({ ran: true });
+
+            expect(job.totalRuns).toBe(1);
+        });
+
+        it("returns 404 for nonexistent job", async () => {
+            const res = await app.request("/cron/ghost/trigger", {
+                method: "POST"
+            });
+            expect(res.status).toBe(404);
+        });
+    });
+
+    // ── GET /:id/logs ───────────────────────────────────────────────
+
+    describe("GET /cron/:id/logs", () => {
+        it("returns empty logs before any execution", async () => {
+            const res = await app.request("/cron/job-a/logs");
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            expect(body.logs).toEqual([]);
+        });
+
+        it("returns logs after trigger", async () => {
+            // Trigger first
+            await app.request("/cron/job-a/trigger", { method: "POST" });
+
+            const res = await app.request("/cron/job-a/logs");
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            const logs = body.logs as Array<Record<string, unknown>>;
+            expect(logs).toHaveLength(1);
+            expect(logs[0].success).toBe(true);
+        });
+
+        it("respects limit query parameter", async () => {
+            await app.request("/cron/job-a/trigger", { method: "POST" });
+            await app.request("/cron/job-a/trigger", { method: "POST" });
+            await app.request("/cron/job-a/trigger", { method: "POST" });
+
+            const res = await app.request("/cron/job-a/logs?limit=2");
+            const body = await jsonBody(res);
+            expect((body.logs as unknown[]).length).toBe(2);
+        });
+
+        it("returns 404 for nonexistent job", async () => {
+            const res = await app.request("/cron/ghost/logs");
+            expect(res.status).toBe(404);
+        });
+    });
+
+    // ── PUT /:id (enable/disable) ───────────────────────────────────
+
+    describe("PUT /cron/:id", () => {
+        it("disables a job", async () => {
+            const res = await app.request("/cron/job-a", {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ enabled: false })
+            });
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            const job = body.job as Record<string, unknown>;
+            expect(job.enabled).toBe(false);
+            expect(job.state).toBe("disabled");
+        });
+
+        it("re-enables a disabled job", async () => {
+            // Disable first
+            await app.request("/cron/job-a", {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ enabled: false })
+            });
+
+            // Re-enable
+            const res = await app.request("/cron/job-a", {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ enabled: true })
+            });
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            expect((body.job as Record<string, unknown>).enabled).toBe(true);
+        });
+
+        it("returns 400 if enabled is missing from body", async () => {
+            const res = await app.request("/cron/job-a", {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ something: "else" })
+            });
+            expect(res.status).toBe(400);
+
+            const body = await jsonBody(res);
+            expect((body.error as Record<string, unknown>).code).toBe("BAD_REQUEST");
+        });
+
+        it("returns 404 for nonexistent job", async () => {
+            const res = await app.request("/cron/ghost", {
+                method: "PUT",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ enabled: false })
+            });
+            expect(res.status).toBe(404);
+        });
+    });
+
+    // ── Edge cases ──────────────────────────────────────────────────
+
+    describe("edge cases", () => {
+        it("handles a failing job trigger gracefully", async () => {
+            scheduler.registerJobs([
+                makeJob("fail-job", {
+                    handler: async () => {
+                        throw new Error("kaboom");
+                    }
+                })
+            ]);
+
+            const res = await app.request("/cron/fail-job/trigger", {
+                method: "POST"
+            });
+            expect(res.status).toBe(200); // trigger still returns 200
+
+            const body = await jsonBody(res);
+            const log = body.log as Record<string, unknown>;
+            expect(log.success).toBe(false);
+            expect(log.error).toBe("kaboom");
+        });
+
+        it("handles URL-encoded job IDs", async () => {
+            scheduler.registerJobs([makeJob("has-dash", { name: "Dashed" })]);
+
+            const res = await app.request("/cron/has-dash");
+            expect(res.status).toBe(200);
+
+            const body = await jsonBody(res);
+            expect((body.job as Record<string, unknown>).id).toBe("has-dash");
+        });
+    });
+});

package/src/cron/cron-routes.ts

@@ -0,0 +1,85 @@
+import { Hono } from "hono";
+import type { HonoEnv } from "../api/types";
+import type { CronScheduler } from "./cron-scheduler";
+
+/**
+ * Create admin REST routes for managing cron jobs.
+ *
+ * Routes:
+ *   GET    /          → list all cron jobs
+ *   GET    /:id       → get a single job's status
+ *   POST   /:id/trigger → manually trigger a job
+ *   GET    /:id/logs  → get execution logs for a job
+ *   PUT    /:id       → update job (enable/disable)
+ */
+export function createCronRoutes(scheduler: CronScheduler): Hono<HonoEnv> {
+    const router = new Hono<HonoEnv>();
+
+    // List all jobs
+    router.get("/", (c) => {
+        const jobs = scheduler.listJobs();
+        return c.json({ jobs });
+    });
+
+    // Get single job
+    router.get("/:id", (c) => {
+        const id = c.req.param("id");
+        const job = scheduler.getJob(id);
+        if (!job) {
+            return c.json({ error: { message: `Cron job "${id}" not found`,
+code: "NOT_FOUND" } }, 404);
+        }
+        return c.json({ job });
+    });
+
+    // Trigger a job manually
+    router.post("/:id/trigger", async (c) => {
+        const id = c.req.param("id");
+        const job = scheduler.getJob(id);
+        if (!job) {
+            return c.json({ error: { message: `Cron job "${id}" not found`,
+code: "NOT_FOUND" } }, 404);
+        }
+
+        const log = await scheduler.triggerJob(id);
+        return c.json({ log,
+job: scheduler.getJob(id) });
+    });
+
+    // Get job logs
+    router.get("/:id/logs", async (c) => {
+        const id = c.req.param("id");
+        const limitStr = c.req.query("limit");
+        const limit = limitStr ? parseInt(limitStr, 10) : undefined;
+
+        const job = scheduler.getJob(id);
+        if (!job) {
+            return c.json({ error: { message: `Cron job "${id}" not found`,
+code: "NOT_FOUND" } }, 404);
+        }
+
+        const logs = await scheduler.getJobLogsFromDb(id, limit);
+        return c.json({ logs });
+    });
+
+    // Enable/disable a job
+    router.put("/:id", async (c) => {
+        const id = c.req.param("id");
+        const body = await c.req.json().catch(() => ({})) as { enabled: boolean };
+
+        if (typeof body.enabled !== "boolean") {
+            return c.json({ error: { message: "Missing 'enabled' boolean in body",
+code: "BAD_REQUEST" } }, 400);
+        }
+
+        const job = scheduler.setJobEnabled(id, body.enabled);
+        if (!job) {
+            return c.json({ error: { message: `Cron job "${id}" not found`,
+code: "NOT_FOUND" } }, 404);
+        }
+
+        return c.json({ job });
+    });
+
+    return router;
+}