@rebasepro/server-core 0.7.0 → 0.9.0

package/src/collections/loader.ts

@@ -1,50 +0,0 @@
-import { EntityCollection } from "@rebasepro/types";
-import * as fs from "fs";
-import * as path from "path";
-import { pathToFileURL } from "url";
-import { logger } from "../utils/logger";
-
-/**
- * Asynchronously load collection files from a directory for backend initialization
- */
-export async function loadCollectionsFromDirectory(directory: string): Promise<EntityCollection[]> {
-    const collections: EntityCollection[] = [];
-    try {
-        if (!fs.existsSync(directory)) {
-            logger.warn(`[loadCollectionsFromDirectory] Collections directory not found: ${directory}`);
-            return collections;
-        }
-
-        const files = fs.readdirSync(directory);
-        for (const file of files) {
-            // Only load .ts and .js files, ignore test files and declaration files
-            if ((file.endsWith(".ts") || file.endsWith(".js")) &&
-                !file.includes(".test.") &&
-                !file.endsWith(".d.ts") &&
-                file !== "index.ts" && file !== "index.js") {
-
-                const filePath = path.join(directory, file);
-                try {
-                    const fileUrl = pathToFileURL(filePath).href;
-
-                    // Use standard import() so that tsx/loader hooks can
-                    // resolve .ts files and workspace bare-specifiers.
-                    const module = await import(fileUrl);
-
-                    // Expect the collection to be the default export
-                    if (module && module.default) {
-                        collections.push(module.default);
-                    } else {
-                        logger.warn(`[loadCollectionsFromDirectory] File ${file} does not have a default export. Skipping.`);
-                    }
-                } catch (err: unknown) {
-                    const message = err instanceof Error ? err.message : String(err);
-                    logger.error(`[loadCollectionsFromDirectory] Failed to load collection from ${file}: ${message}`);
-                }
-            }
-        }
-    } catch (err) {
-        logger.error(`[loadCollectionsFromDirectory] Error reading collections directory: ${err}`);
-    }
-    return collections;
-}

package/src/cron/cron-loader.ts

@@ -1,84 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { pathToFileURL } from "url";
-import type { CronJobDefinition } from "@rebasepro/types";
-import { logger } from "../utils/logger.js";
-
-export interface LoadedCronJob {
-    /** Job ID derived from filename (e.g. "cleanup-sessions"). */
-    id: string;
-    /** The full definition. */
-    definition: CronJobDefinition;
-}
-
-/**
- * Auto-discover cron job files from a directory.
- *
- * Each file should default-export a `CronJobDefinition`.
- * The filename (without extension) becomes the job ID:
- *   `crons/cleanup-sessions.ts` → id = "cleanup-sessions"
- *
- * Follows the same discovery pattern as `loadFunctionsFromDirectory`.
- */
-export async function loadCronJobsFromDirectory(
-    directory: string
-): Promise<LoadedCronJob[]> {
-    const jobs: LoadedCronJob[] = [];
-
-    if (!fs.existsSync(directory)) {
-        return jobs;
-    }
-
-    const files = fs.readdirSync(directory);
-    for (const file of files) {
-        if (
-            (file.endsWith(".ts") || file.endsWith(".js")) &&
-            !file.includes(".test.") &&
-            !file.endsWith(".d.ts") &&
-            file !== "index.ts" &&
-            file !== "index.js"
-        ) {
-            const filePath = path.join(directory, file);
-            try {
-                const fileUrl = pathToFileURL(filePath).href;
-
-                // Native dynamic import — bypasses tsc down-compilation
-                const dynamicImport = new Function("url", "return import(url)");
-                const mod = await dynamicImport(fileUrl);
-
-                const exported: unknown = mod.default;
-
-                if (!exported || typeof exported !== "object") {
-                    logger.warn(`[cron] ${file}: no valid default export. Skipping.`);
-                    continue;
-                }
-
-                const def = exported as Record<string, unknown>;
-                if (typeof def.schedule !== "string" || typeof def.handler !== "function") {
-                    logger.warn(`[cron] ${file}: default export missing required 'schedule' or 'handler'. Skipping.`);
-                    continue;
-                }
-
-                const id = path.basename(file, path.extname(file));
-                const definition: CronJobDefinition = {
-                    schedule: def.schedule as string,
-                    name: (def.name as string) || id,
-                    description: def.description as string | undefined,
-                    enabled: def.enabled !== false,
-                    timeoutSeconds: (def.timeoutSeconds as number) || 300,
-                    handler: def.handler as CronJobDefinition["handler"]
-                };
-
-                jobs.push({ id,
-definition });
-                logger.info(`⏰ Loaded cron job: ${id} (${definition.schedule})`);
-            } catch (err: unknown) {
-                const message =
-                    err instanceof Error ? err.message : String(err);
-                logger.error(`[cron] Failed to load ${file}: ${message}`);
-            }
-        }
-    }
-
-    return jobs;
-}

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

@@ -1,265 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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;
-}