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

package/test/driver-registry.test.ts

@@ -0,0 +1,282 @@
+import {
+    DriverRegistry,
+    DefaultDriverRegistry,
+    DEFAULT_DRIVER_ID
+} from "../src/services/driver-registry";
+import { DataDriver } from "@rebasepro/types";
+
+/**
+ * Mock DataDriver for testing
+ */
+function createMockDataDriverDelegate(key: string): DataDriver {
+    return {
+        key,
+        initialised: true,
+        fetchCollection: jest.fn().mockResolvedValue([]),
+        fetchEntity: jest.fn().mockResolvedValue(undefined),
+        saveEntity: jest.fn().mockResolvedValue({ id: "test-id",
+path: "test",
+values: {} }),
+        deleteEntity: jest.fn().mockResolvedValue(undefined),
+        checkUniqueField: jest.fn().mockResolvedValue(true)
+    };
+}
+
+describe("DriverRegistry", () => {
+    describe("DEFAULT_DRIVER_ID", () => {
+        it("should be '(default)'", () => {
+            expect(DEFAULT_DRIVER_ID).toBe("(default)");
+        });
+    });
+
+    describe("DefaultDriverRegistry", () => {
+        describe("constructor and basic operations", () => {
+            it("should create an empty registry", () => {
+                const registry = new DefaultDriverRegistry();
+                expect(registry.size()).toBe(0);
+                expect(registry.list()).toEqual([]);
+            });
+
+            it("should register a driver", () => {
+                const registry = new DefaultDriverRegistry();
+                const mockDelegate = createMockDataDriverDelegate("postgres");
+
+                registry.register("test-db", mockDelegate);
+
+                expect(registry.has("test-db")).toBe(true);
+                expect(registry.size()).toBe(1);
+                expect(registry.list()).toContain("test-db");
+            });
+
+            it("should get a registered driver", () => {
+                const registry = new DefaultDriverRegistry();
+                const mockDelegate = createMockDataDriverDelegate("postgres");
+
+                registry.register("my-db", mockDelegate);
+
+                const retrieved = registry.get("my-db");
+                expect(retrieved).toBe(mockDelegate);
+            });
+
+            it("should return undefined for non-existent driver", () => {
+                const registry = new DefaultDriverRegistry();
+                expect(registry.get("non-existent")).toBeUndefined();
+            });
+        });
+
+        describe("default driver handling", () => {
+            it("should get default driver with get(undefined)", () => {
+                const registry = new DefaultDriverRegistry();
+                const mockDelegate = createMockDataDriverDelegate("postgres");
+
+                registry.register(DEFAULT_DRIVER_ID, mockDelegate);
+
+                expect(registry.get(undefined)).toBe(mockDelegate);
+                expect(registry.get(null)).toBe(mockDelegate);
+            });
+
+            it("should get default driver with getDefault()", () => {
+                const registry = new DefaultDriverRegistry();
+                const mockDelegate = createMockDataDriverDelegate("postgres");
+
+                registry.register(DEFAULT_DRIVER_ID, mockDelegate);
+
+                expect(registry.getDefault()).toBe(mockDelegate);
+            });
+
+            it("should throw error when no default driver exists", () => {
+                const registry = new DefaultDriverRegistry();
+
+                expect(() => registry.getDefault()).toThrow(
+                    "[DriverRegistry] No default driver registered."
+                );
+            });
+        });
+
+        describe("getOrDefault", () => {
+            let registry: DefaultDriverRegistry;
+            let defaultDelegate: DataDriver;
+            let analyticsDelegate: DataDriver;
+
+            beforeEach(() => {
+                registry = new DefaultDriverRegistry();
+                defaultDelegate = createMockDataDriverDelegate("default-postgres");
+                analyticsDelegate = createMockDataDriverDelegate("analytics-postgres");
+
+                registry.register(DEFAULT_DRIVER_ID, defaultDelegate);
+                registry.register("analytics", analyticsDelegate);
+            });
+
+            it("should return specific driver when found", () => {
+                expect(registry.getOrDefault("analytics")).toBe(analyticsDelegate);
+            });
+
+            it("should return default when id is undefined", () => {
+                expect(registry.getOrDefault(undefined)).toBe(defaultDelegate);
+            });
+
+            it("should return default when id is null", () => {
+                expect(registry.getOrDefault(null)).toBe(defaultDelegate);
+            });
+
+            it("should fallback to default when id not found", () => {
+                // This should log a warning and return the default
+                const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
+
+                expect(registry.getOrDefault("non-existent")).toBe(defaultDelegate);
+                expect(consoleSpy).toHaveBeenCalledWith(
+                    expect.stringContaining('Driver "non-existent" not found')
+                );
+
+                consoleSpy.mockRestore();
+            });
+
+            it("should throw when fallback fails (no default)", () => {
+                const emptyRegistry = new DefaultDriverRegistry();
+
+                expect(() => emptyRegistry.getOrDefault("anything")).toThrow();
+            });
+        });
+
+        describe("overwriting drivers", () => {
+            it("should overwrite existing driver with same id", () => {
+                const registry = new DefaultDriverRegistry();
+                const original = createMockDataDriverDelegate("original");
+                const replacement = createMockDataDriverDelegate("replacement");
+
+                const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
+
+                registry.register("my-db", original);
+                registry.register("my-db", replacement);
+
+                expect(registry.get("my-db")).toBe(replacement);
+                expect(consoleSpy).toHaveBeenCalledWith(
+                    expect.stringContaining('Overwriting driver with id "my-db"')
+                );
+
+                consoleSpy.mockRestore();
+            });
+        });
+
+        describe("list and size", () => {
+            it("should list all registered drivers", () => {
+                const registry = new DefaultDriverRegistry();
+
+                registry.register("db-1", createMockDataDriverDelegate("pg1"));
+                registry.register("db-2", createMockDataDriverDelegate("pg2"));
+                registry.register(DEFAULT_DRIVER_ID, createMockDataDriverDelegate("default"));
+
+                const list = registry.list();
+                expect(list).toHaveLength(3);
+                expect(list).toContain("db-1");
+                expect(list).toContain("db-2");
+                expect(list).toContain(DEFAULT_DRIVER_ID);
+            });
+
+            it("should return correct size", () => {
+                const registry = new DefaultDriverRegistry();
+
+                expect(registry.size()).toBe(0);
+
+                registry.register("db-1", createMockDataDriverDelegate("pg1"));
+                expect(registry.size()).toBe(1);
+
+                registry.register("db-2", createMockDataDriverDelegate("pg2"));
+                expect(registry.size()).toBe(2);
+            });
+        });
+    });
+
+    describe("DefaultDriverRegistry.create() factory", () => {
+        describe("with single DataDriver", () => {
+            it('should register single delegate as "(default)"', () => {
+                const mockDelegate = createMockDataDriverDelegate("postgres");
+
+                const registry = DefaultDriverRegistry.create(mockDelegate);
+
+                expect(registry.has(DEFAULT_DRIVER_ID)).toBe(true);
+                expect(registry.getDefault()).toBe(mockDelegate);
+                expect(registry.size()).toBe(1);
+            });
+        });
+
+        describe("with map of DataDriverDelegates", () => {
+            it("should register all delegates from map", () => {
+                const defaultDelegate = createMockDataDriverDelegate("default-pg");
+                const analyticsDelegate = createMockDataDriverDelegate("analytics-pg");
+
+                const registry = DefaultDriverRegistry.create({
+                    [DEFAULT_DRIVER_ID]: defaultDelegate,
+                    "analytics": analyticsDelegate
+                });
+
+                expect(registry.size()).toBe(2);
+                expect(registry.getDefault()).toBe(defaultDelegate);
+                expect(registry.get("analytics")).toBe(analyticsDelegate);
+            });
+
+            it("should use first entry as default if no explicit default provided", () => {
+                const db1 = createMockDataDriverDelegate("db1");
+                const db2 = createMockDataDriverDelegate("db2");
+
+                const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
+
+                const registry = DefaultDriverRegistry.create({
+                    "primary": db1,
+                    "secondary": db2
+                });
+
+                // Should have registered both + created default pointing to first
+                expect(registry.size()).toBe(3); // primary, secondary, (default)
+                expect(registry.has(DEFAULT_DRIVER_ID)).toBe(true);
+                expect(consoleSpy).toHaveBeenCalledWith(
+                    expect.stringContaining('No "(default)" driver provided')
+                );
+
+                consoleSpy.mockRestore();
+            });
+
+            it("should handle empty map gracefully", () => {
+                const registry = DefaultDriverRegistry.create({});
+
+                expect(registry.size()).toBe(0);
+                expect(() => registry.getDefault()).toThrow();
+            });
+        });
+    });
+
+    describe("type detection (isDataDriverDelegate)", () => {
+        it("should correctly identify a DataDriver", () => {
+            const mockDelegate = createMockDataDriverDelegate("postgres");
+
+            // The factory should recognize it as a single delegate
+            const registry = DefaultDriverRegistry.create(mockDelegate);
+            expect(registry.size()).toBe(1);
+            expect(registry.has(DEFAULT_DRIVER_ID)).toBe(true);
+        });
+
+        it("should correctly identify a map of DataDriverDelegates", () => {
+            const delegates = {
+                [DEFAULT_DRIVER_ID]: createMockDataDriverDelegate("pg1"),
+                "other": createMockDataDriverDelegate("pg2")
+            };
+
+            // The factory should recognize it as a map
+            const registry = DefaultDriverRegistry.create(delegates);
+            expect(registry.size()).toBe(2);
+        });
+
+        it("should not mistakenly identify a map as a single delegate", () => {
+            // A map doesn't have the required DataDriver methods
+            const map = {
+                key: "not-a-delegate", // This looks like the key property but...
+                db1: createMockDataDriverDelegate("pg1")
+            };
+
+            // This should be treated as a map (and show a warning because 'key' isn't a valid delegate)
+            const registry = DefaultDriverRegistry.create(map as any);
+            // 'key' entry will be ignored since it's not a valid delegate
+            expect(registry.has("db1")).toBe(true);
+        });
+    });
+});

package/test/error-propagation.test.ts

@@ -0,0 +1,226 @@
+import { Hono } from "hono";
+import { ApiError, errorHandler } from "../src/api/errors";
+import { HonoEnv } from "../src/api/types";
+
+/**
+ * End-to-end tests that verify ApiError thrown inside Hono sub-routers
+ * produces the correct HTTP status code and JSON body WHEN the sub-router
+ * is mounted on a parent app — exactly simulating the init.ts mounting
+ * pattern.
+ *
+ * This is critical because Hono's `onError` does NOT propagate from parent
+ * to child routers. Each sub-router must have its own `router.onError(errorHandler)`.
+ */
+describe("Error Propagation through Sub-Routers", () => {
+
+    // ── Without onError on sub-router (broken behavior) ─────────────
+
+    describe("Sub-router WITHOUT onError (demonstrates the bug)", () => {
+        function createBrokenApp() {
+            // This simulates the REAL production scenario: the consumer's Hono app
+            // (e.g. SustenTalent's index.ts) does NOT set onError on the parent app.
+            // Without onError on the sub-router either, Hono's DEFAULT error handler
+            // catches ApiErrors and returns a generic 500 with a plain text body.
+            const parentApp = new Hono<HonoEnv>();
+            // NOTE: no parentApp.onError(errorHandler) — this is the real scenario
+
+            const subRouter = new Hono<HonoEnv>();
+            // NOTE: no subRouter.onError(errorHandler) — this is the bug
+            subRouter.get("/login", () => {
+                throw ApiError.unauthorized("Invalid credentials", "INVALID_CREDENTIALS");
+            });
+
+            parentApp.route("/api/auth", subRouter);
+            return parentApp;
+        }
+
+        it("ApiError.unauthorized returns 500 plain text without ANY onError handler", async () => {
+            const app = createBrokenApp();
+            const res = await app.request("/api/auth/login");
+            // Without any onError handler, Hono's default handler returns 500
+            expect(res.status).toBe(500);
+            // And the body is NOT our structured JSON — it's plain text
+            const text = await res.text();
+            expect(text).toBe("Internal Server Error");
+        });
+    });
+
+    // ── With onError on sub-router (fixed behavior) ─────────────────
+
+    describe("Sub-router WITH onError (correct behavior)", () => {
+        function createFixedApp() {
+            const parentApp = new Hono<HonoEnv>();
+            parentApp.onError(errorHandler);
+
+            const subRouter = new Hono<HonoEnv>();
+            subRouter.onError(errorHandler); // ← THE FIX
+
+            subRouter.get("/login", () => {
+                throw ApiError.unauthorized("Invalid credentials", "INVALID_CREDENTIALS");
+            });
+            subRouter.get("/register", () => {
+                throw ApiError.conflict("Email already exists", "EMAIL_EXISTS");
+            });
+            subRouter.get("/refresh", () => {
+                throw ApiError.unauthorized("Refresh token expired", "TOKEN_EXPIRED");
+            });
+            subRouter.get("/forbidden", () => {
+                throw ApiError.forbidden("Admin only");
+            });
+            subRouter.get("/not-found", () => {
+                throw ApiError.notFound("User not found");
+            });
+            subRouter.get("/bad-request", () => {
+                throw ApiError.badRequest("Missing email", "INVALID_INPUT", { field: "email" });
+            });
+            subRouter.get("/service-unavailable", () => {
+                throw ApiError.serviceUnavailable("Google login not configured", "NOT_CONFIGURED");
+            });
+            subRouter.get("/generic-error", () => {
+                throw new Error("Unexpected failure");
+            });
+
+            parentApp.route("/api/auth", subRouter);
+            return parentApp;
+        }
+
+        it("returns 401 for unauthorized errors", async () => {
+            const app = createFixedApp();
+            const res = await app.request("/api/auth/login");
+            expect(res.status).toBe(401);
+            const body = await res.json() as { error: { message: string; code: string } };
+            expect(body.error.message).toBe("Invalid credentials");
+            expect(body.error.code).toBe("INVALID_CREDENTIALS");
+        });
+
+        it("returns 409 for conflict errors", async () => {
+            const app = createFixedApp();
+            const res = await app.request("/api/auth/register");
+            expect(res.status).toBe(409);
+            const body = await res.json() as { error: { message: string; code: string } };
+            expect(body.error.message).toBe("Email already exists");
+            expect(body.error.code).toBe("EMAIL_EXISTS");
+        });
+
+        it("returns 401 for expired refresh token", async () => {
+            const app = createFixedApp();
+            const res = await app.request("/api/auth/refresh");
+            expect(res.status).toBe(401);
+            const body = await res.json() as { error: { message: string; code: string } };
+            expect(body.error.code).toBe("TOKEN_EXPIRED");
+        });
+
+        it("returns 403 for forbidden errors", async () => {
+            const app = createFixedApp();
+            const res = await app.request("/api/auth/forbidden");
+            expect(res.status).toBe(403);
+        });
+
+        it("returns 404 for not found errors", async () => {
+            const app = createFixedApp();
+            const res = await app.request("/api/auth/not-found");
+            expect(res.status).toBe(404);
+        });
+
+        it("returns 400 with details for bad request errors", async () => {
+            const app = createFixedApp();
+            const res = await app.request("/api/auth/bad-request");
+            expect(res.status).toBe(400);
+            const body = await res.json() as { error: { message: string; code: string; details: unknown } };
+            expect(body.error.code).toBe("INVALID_INPUT");
+            expect(body.error.details).toEqual({ field: "email" });
+        });
+
+        it("returns 503 for service unavailable errors", async () => {
+            const app = createFixedApp();
+            const res = await app.request("/api/auth/service-unavailable");
+            expect(res.status).toBe(503);
+            const body = await res.json() as { error: { message: string; code: string } };
+            expect(body.error.code).toBe("NOT_CONFIGURED");
+        });
+
+        it("returns 500 with sanitized message for generic errors", async () => {
+            const app = createFixedApp();
+            const res = await app.request("/api/auth/generic-error");
+            expect(res.status).toBe(500);
+            const body = await res.json() as { error: { message: string; code: string } };
+            expect(body.error.code).toBe("INTERNAL_ERROR");
+            // Should NOT leak the raw error message
+            expect(body.error.message).toBe("Internal Server Error");
+        });
+
+        it("returns consistent { error: { message, code } } shape for all error types", async () => {
+            const app = createFixedApp();
+            const paths = ["/api/auth/login", "/api/auth/register", "/api/auth/forbidden", "/api/auth/not-found", "/api/auth/bad-request"];
+
+            for (const path of paths) {
+                const res = await app.request(path);
+                const body = await res.json() as Record<string, unknown>;
+                expect(body).toHaveProperty("error");
+                expect(body.error).toHaveProperty("message");
+                expect(body.error).toHaveProperty("code");
+            }
+        });
+    });
+
+    // ── Multi-level nesting ─────────────────────────────────────────
+
+    describe("Deeply nested sub-routers", () => {
+        it("error handler works through two levels of nesting", async () => {
+            const root = new Hono<HonoEnv>();
+            root.onError(errorHandler);
+
+            const level1 = new Hono<HonoEnv>();
+            level1.onError(errorHandler);
+
+            const level2 = new Hono<HonoEnv>();
+            level2.onError(errorHandler);
+
+            level2.get("/deep", () => {
+                throw ApiError.unauthorized("Deep error");
+            });
+
+            level1.route("/nested", level2);
+            root.route("/api", level1);
+
+            const res = await root.request("/api/nested/deep");
+            expect(res.status).toBe(401);
+            const body = await res.json() as { error: { message: string } };
+            expect(body.error.message).toBe("Deep error");
+        });
+    });
+
+    // ── Data router simulation ──────────────────────────────────────
+
+    describe("Data router error propagation (simulates init.ts pattern)", () => {
+        function createDataApp() {
+            const app = new Hono<HonoEnv>();
+            app.onError(errorHandler);
+
+            const dataRouter = new Hono<HonoEnv>();
+            dataRouter.onError(errorHandler);
+
+            dataRouter.get("/posts/:id", () => {
+                throw ApiError.notFound("Entity not found");
+            });
+            dataRouter.post("/posts", () => {
+                throw ApiError.badRequest("Validation failed", "INVALID_INPUT");
+            });
+
+            app.route("/api/data", dataRouter);
+            return app;
+        }
+
+        it("returns 404 for entity not found", async () => {
+            const app = createDataApp();
+            const res = await app.request("/api/data/posts/999");
+            expect(res.status).toBe(404);
+        });
+
+        it("returns 400 for validation errors", async () => {
+            const app = createDataApp();
+            const res = await app.request("/api/data/posts", { method: "POST" });
+            expect(res.status).toBe(400);
+        });
+    });
+});

package/test/errors-hono.test.ts

@@ -0,0 +1,133 @@
+import { Hono } from "hono";
+import { ApiError, errorHandler } from "../src/api/errors";
+import { HonoEnv } from "../src/api/types";
+
+describe("Error Handler (Hono)", () => {
+    function createApp() {
+        const app = new Hono<HonoEnv>();
+        app.onError(errorHandler);
+
+        // Test routes that throw different errors
+        app.get("/bad-request", () => {
+            throw ApiError.badRequest("Missing required field", "MISSING_FIELD", { field: "email" });
+        });
+        app.get("/unauthorized", () => {
+            throw ApiError.unauthorized("Token expired", "TOKEN_EXPIRED");
+        });
+        app.get("/forbidden", () => {
+            throw ApiError.forbidden("Admin only", "FORBIDDEN");
+        });
+        app.get("/not-found", () => {
+            throw ApiError.notFound("Entity not found");
+        });
+        app.get("/conflict", () => {
+            throw ApiError.conflict("Email already exists", "EMAIL_EXISTS");
+        });
+        app.get("/internal", () => {
+            throw ApiError.internal("Database connection failed");
+        });
+        app.get("/service-unavailable", () => {
+            throw ApiError.serviceUnavailable("Feature not configured");
+        });
+        app.get("/generic-error", () => {
+            throw new Error("Something went wrong");
+        });
+        app.get("/error-with-code", () => {
+            const err = new Error("Rate limited") as Error & { code: string };
+            err.code = "RATE_LIMITED";
+            throw err;
+        });
+
+        return app;
+    }
+
+    it("formats ApiError with correct status and body structure", async () => {
+        const app = createApp();
+        const res = await app.request("/bad-request");
+        expect(res.status).toBe(400);
+        const body = await res.json() as any;
+        expect(body.error.message).toBe("Missing required field");
+        expect(body.error.code).toBe("MISSING_FIELD");
+        expect(body.error.details).toEqual({ field: "email" });
+    });
+
+    it("handles 401 Unauthorized", async () => {
+        const app = createApp();
+        const res = await app.request("/unauthorized");
+        expect(res.status).toBe(401);
+        const body = await res.json() as any;
+        expect(body.error.code).toBe("TOKEN_EXPIRED");
+    });
+
+    it("handles 403 Forbidden", async () => {
+        const app = createApp();
+        const res = await app.request("/forbidden");
+        expect(res.status).toBe(403);
+        const body = await res.json() as any;
+        expect(body.error.code).toBe("FORBIDDEN");
+    });
+
+    it("handles 404 Not Found", async () => {
+        const app = createApp();
+        const res = await app.request("/not-found");
+        expect(res.status).toBe(404);
+        const body = await res.json() as any;
+        expect(body.error.code).toBe("NOT_FOUND");
+    });
+
+    it("handles 409 Conflict", async () => {
+        const app = createApp();
+        const res = await app.request("/conflict");
+        expect(res.status).toBe(409);
+        const body = await res.json() as any;
+        expect(body.error.code).toBe("EMAIL_EXISTS");
+    });
+
+    it("handles 500 Internal", async () => {
+        const app = createApp();
+        const res = await app.request("/internal");
+        expect(res.status).toBe(500);
+    });
+
+    it("handles 503 Service Unavailable", async () => {
+        const app = createApp();
+        const res = await app.request("/service-unavailable");
+        expect(res.status).toBe(503);
+    });
+
+    it("converts generic Error to 500 with INTERNAL_ERROR code", async () => {
+        const app = createApp();
+        const res = await app.request("/generic-error");
+        expect(res.status).toBe(500);
+        const body = await res.json() as any;
+        expect(body.error.code).toBe("INTERNAL_ERROR");
+        expect(body.error.message).toBe("Internal Server Error");
+    });
+
+    it("maps known error codes to HTTP status codes", async () => {
+        const app = createApp();
+        const res = await app.request("/error-with-code");
+        // RATE_LIMITED is not in the code-to-status map, so it should default to 500
+        expect(res.status).toBe(500);
+    });
+
+    it("omits details when not provided", async () => {
+        const app = createApp();
+        const res = await app.request("/unauthorized");
+        const body = await res.json() as any;
+        expect(body.error.details).toBeUndefined();
+    });
+
+    it("returns consistent error shape for all error types", async () => {
+        const app = createApp();
+        const paths = ["/bad-request", "/unauthorized", "/forbidden", "/not-found", "/internal", "/generic-error"];
+
+        for (const path of paths) {
+            const res = await app.request(path);
+            const body = await res.json() as any;
+            expect(body).toHaveProperty("error");
+            expect(body.error).toHaveProperty("message");
+            expect(body.error).toHaveProperty("code");
+        }
+    });
+});