@rebasepro/server-core 0.0.1-canary.4d4fb3e

package/test/driver-registry.test.ts

@@ -0,0 +1,280 @@
+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/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");
+        }
+    });
+});

package/test/errors.test.ts

@@ -0,0 +1,150 @@
+import { ApiError, errorHandler } from "../src/api/errors";
+
+// ── Minimal Hono-context mock ────────────────────────────────────────────
+function createMockContext(method = "GET", path = "/test") {
+    let capturedStatus: number | undefined;
+    let capturedBody: any;
+
+    const c = {
+        req: { method, path },
+        json: (body: any, status?: number) => {
+            capturedBody = body;
+            capturedStatus = status ?? 200;
+            return new Response(JSON.stringify(body), { status: capturedStatus });
+        },
+    } as any;
+
+    return {
+        c,
+        getStatus: () => capturedStatus,
+        getBody: () => capturedBody,
+    };
+}
+
+// ── ApiError class ────────────────────────────────────────────────────────
+describe("ApiError", () => {
+    describe("constructor", () => {
+        it("should create an error with statusCode, code, message, and details", () => {
+            const err = new ApiError(422, "VALIDATION_ERROR", "Invalid field", { field: "email" });
+            expect(err).toBeInstanceOf(Error);
+            expect(err).toBeInstanceOf(ApiError);
+            expect(err.statusCode).toBe(422);
+            expect(err.code).toBe("VALIDATION_ERROR");
+            expect(err.message).toBe("Invalid field");
+            expect(err.details).toEqual({ field: "email" });
+            expect(err.name).toBe("ApiError");
+        });
+
+        it("should default details to undefined", () => {
+            const err = new ApiError(400, "BAD_REQUEST", "Bad");
+            expect(err.details).toBeUndefined();
+        });
+    });
+
+    describe("factory methods", () => {
+        it("badRequest → 400", () => {
+            const err = ApiError.badRequest("Missing field", "MISSING_FIELD");
+            expect(err.statusCode).toBe(400);
+            expect(err.code).toBe("MISSING_FIELD");
+        });
+
+        it("badRequest uses default code", () => {
+            const err = ApiError.badRequest("Oops");
+            expect(err.code).toBe("BAD_REQUEST");
+        });
+
+        it("unauthorized → 401", () => {
+            const err = ApiError.unauthorized("Bad token");
+            expect(err.statusCode).toBe(401);
+            expect(err.code).toBe("UNAUTHORIZED");
+        });
+
+        it("forbidden → 403", () => {
+            const err = ApiError.forbidden("No access");
+            expect(err.statusCode).toBe(403);
+            expect(err.code).toBe("FORBIDDEN");
+        });
+
+        it("notFound → 404", () => {
+            const err = ApiError.notFound("Entity not found");
+            expect(err.statusCode).toBe(404);
+            expect(err.code).toBe("NOT_FOUND");
+        });
+
+        it("conflict → 409", () => {
+            const err = ApiError.conflict("Already exists", "EMAIL_EXISTS");
+            expect(err.statusCode).toBe(409);
+            expect(err.code).toBe("EMAIL_EXISTS");
+        });
+
+        it("internal → 500", () => {
+            const err = ApiError.internal("Boom");
+            expect(err.statusCode).toBe(500);
+            expect(err.code).toBe("INTERNAL_ERROR");
+        });
+
+        it("serviceUnavailable → 503", () => {
+            const err = ApiError.serviceUnavailable("Down");
+            expect(err.statusCode).toBe(503);
+            expect(err.code).toBe("SERVICE_UNAVAILABLE");
+        });
+    });
+});
+
+// ── errorHandler (Hono ErrorHandler) ──────────────────────────────────────
+describe("errorHandler", () => {
+    it("should format ApiError with statusCode, code, message", () => {
+        const { c, getStatus, getBody } = createMockContext();
+        const err = ApiError.notFound("User not found");
+        errorHandler(err, c);
+
+        expect(getStatus()).toBe(404);
+        expect(getBody()).toEqual({
+            error: { message: "User not found", code: "NOT_FOUND" }
+        });
+    });
+
+    it("should include details when present", () => {
+        const { c, getBody } = createMockContext();
+        const err = ApiError.badRequest("Validation failed", "VALIDATION", { fields: ["email"] });
+        errorHandler(err, c);
+
+        expect(getBody()).toEqual({
+            error: {
+                message: "Validation failed",
+                code: "VALIDATION",
+                details: { fields: ["email"] }
+            }
+        });
+    });
+
+    it("should handle plain Error with code property", () => {
+        const { c, getStatus, getBody } = createMockContext();
+        const err = Object.assign(new Error("Not found"), { code: "NOT_FOUND" });
+        errorHandler(err, c);
+
+        expect(getStatus()).toBe(404);
+        expect(getBody()).toEqual({
+            error: { message: "Not found", code: "NOT_FOUND" }
+        });
+    });
+
+    it("should default to 500 for unknown errors", () => {
+        const { c, getStatus, getBody } = createMockContext();
+        const err = new Error("Something broke");
+        errorHandler(err, c);
+
+        expect(getStatus()).toBe(500);
+        expect(getBody()).toEqual({
+            error: { message: "Internal Server Error", code: "INTERNAL_ERROR" }
+        });
+    });
+
+    it("should use statusCode from error if present", () => {
+        const { c, getStatus } = createMockContext();
+        const err = Object.assign(new Error("Rate limited"), { statusCode: 429, code: "RATE_LIMITED" });
+        errorHandler(err, c);
+
+        expect(getStatus()).toBe(429);
+    });
+});