@rebasepro/server-core 0.7.0 → 0.9.0

package/test/backend-hooks-data.test.ts

@@ -1,477 +0,0 @@
-/**
- * BackendHooks — Data (REST API) Integration Tests
- *
- * Verifies that DataHooks are correctly applied within RestApiGenerator
- * for all collection CRUD operations.
- */
-
-import { Hono } from "hono";
-import { RestApiGenerator } from "../src/api/rest/api-generator";
-import { errorHandler } from "../src/api/errors";
-import type { DataDriver } from "@rebasepro/types";
-import type { EntityCollection } from "@rebasepro/types";
-import type { DataHooks } from "@rebasepro/types";
-
-// ── Helpers ─────────────────────────────────────────────────────────────────
-
-function createMockDriver(): jest.Mocked<DataDriver> {
-    return {
-        key: "postgres",
-        initialised: true,
-        fetchCollection: jest.fn(),
-        listenCollection: jest.fn(),
-        fetchEntity: jest.fn(),
-        listenEntity: jest.fn(),
-        saveEntity: jest.fn(),
-        deleteEntity: jest.fn(),
-        checkUniqueField: jest.fn(),
-        countEntities: jest.fn(),
-        withAuth: jest.fn(),
-        admin: {} as any
-    } as unknown as jest.Mocked<DataDriver>;
-}
-
-const mockCollections: EntityCollection[] = [
-    { slug: "products",
-name: "Products",
-singularName: "Product",
-properties: {} } as any,
-    { slug: "orders",
-name: "Orders",
-singularName: "Order",
-properties: {} } as any
-];
-
-function createApp(mockDriver: jest.Mocked<DataDriver>, hooks?: DataHooks) {
-    const app = new Hono();
-    app.onError(errorHandler);
-    // RestApiGenerator.getScopedDriver reads from c.get("driver") which is
-    // normally set by auth middleware. Replicate that here for tests.
-    app.use("/api/*", async (c, next) => {
-        c.set("driver", mockDriver);
-        await next();
-    });
-    const generator = new RestApiGenerator(mockCollections, mockDriver, hooks);
-    app.route("/api", generator.generateRoutes());
-    return app;
-}
-
-// ═════════════════════════════════════════════════════════════════════════════
-// TESTS
-// ═════════════════════════════════════════════════════════════════════════════
-
-describe("DataHooks — REST API", () => {
-    let mockDriver: jest.Mocked<DataDriver>;
-
-    beforeEach(() => {
-        mockDriver = createMockDriver();
-    });
-
-    // ── afterRead ─────────────────────────────────────────────────────
-    describe("data.afterRead", () => {
-        it("transforms entities in GET list response", async () => {
-            const hooks: DataHooks = {
-                afterRead(slug, entity) {
-                    // Mask price for non-premium entities
-                    if (slug === "products") {
-                        return { ...entity,
-price: "***" };
-                    }
-                    return entity;
-                }
-            };
-            const app = createApp(mockDriver, hooks);
-
-            mockDriver.fetchCollection.mockResolvedValue([
-                { id: "p1",
-path: "products",
-values: { name: "Widget",
-price: 99 } } as any,
-                { id: "p2",
-path: "products",
-values: { name: "Gadget",
-price: 199 } } as any
-            ]);
-            mockDriver.countEntities!.mockResolvedValue(2);
-
-            const res = await app.request("/api/products");
-            expect(res.status).toBe(200);
-
-            const body = await res.json() as any;
-            expect(body.data).toHaveLength(2);
-            expect(body.data[0].price).toBe("***");
-            expect(body.data[1].price).toBe("***");
-            // Original field should still be there
-            expect(body.data[0].name).toBe("Widget");
-        });
-
-        it("filters out entities by returning null", async () => {
-            const hooks: DataHooks = {
-                afterRead(slug, entity) {
-                    // Hide draft products
-                    if (entity.status === "draft") return null;
-                    return entity;
-                }
-            };
-            const app = createApp(mockDriver, hooks);
-
-            mockDriver.fetchCollection.mockResolvedValue([
-                { id: "p1",
-path: "products",
-values: { name: "Published",
-status: "active" } } as any,
-                { id: "p2",
-path: "products",
-values: { name: "Draft",
-status: "draft" } } as any,
-                { id: "p3",
-path: "products",
-values: { name: "Also Published",
-status: "active" } } as any
-            ]);
-            mockDriver.countEntities!.mockResolvedValue(3);
-
-            const res = await app.request("/api/products");
-            const body = await res.json() as any;
-            expect(body.data).toHaveLength(2);
-            expect(body.data.map((d: any) => d.name)).toEqual(["Published", "Also Published"]);
-        });
-
-        it("transforms single entity GET response", async () => {
-            const hooks: DataHooks = {
-                afterRead(slug, entity) {
-                    return { ...entity,
-_readAt: "2024-01-01" };
-                }
-            };
-            const app = createApp(mockDriver, hooks);
-
-            mockDriver.fetchEntity.mockResolvedValue(
-                { id: "p1",
-path: "products",
-values: { name: "Widget" } } as any
-            );
-
-            const res = await app.request("/api/products/p1");
-            expect(res.status).toBe(200);
-
-            const body = await res.json() as any;
-            expect(body.name).toBe("Widget");
-            expect(body._readAt).toBe("2024-01-01");
-        });
-
-        it("returns 404 when afterRead filters a single entity", async () => {
-            const hooks: DataHooks = {
-                afterRead(slug, entity) {
-                    if (entity.id === "hidden") return null;
-                    return entity;
-                }
-            };
-            const app = createApp(mockDriver, hooks);
-
-            mockDriver.fetchEntity.mockResolvedValue(
-                { id: "hidden",
-path: "products",
-values: { name: "Secret" } } as any
-            );
-
-            const res = await app.request("/api/products/hidden");
-            expect(res.status).toBe(404);
-        });
-
-        it("only affects targeted collection slug", async () => {
-            const hooks: DataHooks = {
-                afterRead(slug, entity) {
-                    if (slug === "products") {
-                        return { ...entity,
-hooked: true };
-                    }
-                    return entity;
-                }
-            };
-            const app = createApp(mockDriver, hooks);
-
-            // Products should be hooked
-            mockDriver.fetchEntity.mockResolvedValueOnce(
-                { id: "p1",
-path: "products",
-values: { name: "Widget" } } as any
-            );
-            const prodRes = await app.request("/api/products/p1");
-            const prodBody = await prodRes.json() as any;
-            expect(prodBody.hooked).toBe(true);
-
-            // Orders should NOT be hooked
-            mockDriver.fetchEntity.mockResolvedValueOnce(
-                { id: "o1",
-path: "orders",
-values: { total: 42 } } as any
-            );
-            const orderRes = await app.request("/api/orders/o1");
-            const orderBody = await orderRes.json() as any;
-            expect(orderBody.hooked).toBeUndefined();
-        });
-    });
-
-    // ── beforeSave ────────────────────────────────────────────────────
-    describe("data.beforeSave", () => {
-        it("transforms values before POST (create)", async () => {
-            const hooks: DataHooks = {
-                beforeSave(slug, values, entityId) {
-                    return { ...values,
-slug: values.name?.toString().toLowerCase().replace(/\s+/g, "-") };
-                }
-            };
-            const app = createApp(mockDriver, hooks);
-
-            mockDriver.saveEntity.mockResolvedValue(
-                { id: "new-1",
-path: "products",
-values: { name: "Cool Widget",
-slug: "cool-widget" } } as any
-            );
-
-            const res = await app.request("/api/products", {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ name: "Cool Widget" })
-            });
-
-            expect(res.status).toBe(201);
-            expect(mockDriver.saveEntity).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    values: expect.objectContaining({ slug: "cool-widget" })
-                })
-            );
-        });
-
-        it("transforms values before PUT (update)", async () => {
-            const hooks: DataHooks = {
-                beforeSave(slug, values, entityId) {
-                    // Add an updatedBy field
-                    return { ...values,
-updatedBy: "hook" };
-                }
-            };
-            const app = createApp(mockDriver, hooks);
-
-            mockDriver.fetchEntity.mockResolvedValue({ id: "p1",
-path: "products",
-values: {} } as any);
-            mockDriver.saveEntity.mockResolvedValue(
-                { id: "p1",
-path: "products",
-values: { name: "Updated",
-updatedBy: "hook" } } as any
-            );
-
-            const res = await app.request("/api/products/p1", {
-                method: "PUT",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ name: "Updated" })
-            });
-
-            expect(res.status).toBe(200);
-            expect(mockDriver.saveEntity).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    values: expect.objectContaining({ updatedBy: "hook" })
-                })
-            );
-        });
-
-        it("receives entityId=undefined on POST, actual id on PUT", async () => {
-            const beforeSaveSpy = jest.fn((slug, values, entityId) => values);
-            const hooks: DataHooks = { beforeSave: beforeSaveSpy };
-            const app = createApp(mockDriver, hooks);
-
-            // POST
-            mockDriver.saveEntity.mockResolvedValueOnce(
-                { id: "new-1",
-path: "products",
-values: { name: "A" } } as any
-            );
-            await app.request("/api/products", {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ name: "A" })
-            });
-            expect(beforeSaveSpy.mock.calls[0][2]).toBeUndefined(); // entityId
-
-            // PUT
-            mockDriver.fetchEntity.mockResolvedValueOnce({ id: "p1",
-path: "products",
-values: {} } as any);
-            mockDriver.saveEntity.mockResolvedValueOnce(
-                { id: "p1",
-path: "products",
-values: { name: "B" } } as any
-            );
-            await app.request("/api/products/p1", {
-                method: "PUT",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ name: "B" })
-            });
-            expect(beforeSaveSpy.mock.calls[1][2]).toBe("p1"); // entityId
-        });
-
-        it("aborts save when beforeSave throws", async () => {
-            const hooks: DataHooks = {
-                beforeSave(slug, values) {
-                    if (!values.name) throw new Error("Name is required");
-                    return values;
-                }
-            };
-            const app = createApp(mockDriver, hooks);
-
-            const res = await app.request("/api/products", {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ price: 99 })
-            });
-
-            // Should get an error status
-            expect(res.status).toBeGreaterThanOrEqual(400);
-            expect(mockDriver.saveEntity).not.toHaveBeenCalled();
-        });
-    });
-
-    // ── afterSave ─────────────────────────────────────────────────────
-    describe("data.afterSave", () => {
-        it("fires afterSave after POST", async () => {
-            const afterSaveSpy = jest.fn();
-            const hooks: DataHooks = { afterSave: afterSaveSpy };
-            const app = createApp(mockDriver, hooks);
-
-            mockDriver.saveEntity.mockResolvedValue(
-                { id: "new-1",
-path: "products",
-values: { name: "Widget" } } as any
-            );
-
-            const res = await app.request("/api/products", {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ name: "Widget" })
-            });
-
-            expect(res.status).toBe(201);
-            await new Promise(r => setTimeout(r, 50));
-            expect(afterSaveSpy).toHaveBeenCalledTimes(1);
-            expect(afterSaveSpy).toHaveBeenCalledWith(
-                "products",
-                expect.objectContaining({ id: "new-1",
-name: "Widget" }),
-                expect.objectContaining({ method: "POST" })
-            );
-        });
-
-        it("fires afterSave after PUT", async () => {
-            const afterSaveSpy = jest.fn();
-            const hooks: DataHooks = { afterSave: afterSaveSpy };
-            const app = createApp(mockDriver, hooks);
-
-            mockDriver.fetchEntity.mockResolvedValue({ id: "p1",
-path: "products",
-values: {} } as any);
-            mockDriver.saveEntity.mockResolvedValue(
-                { id: "p1",
-path: "products",
-values: { name: "Updated" } } as any
-            );
-
-            await app.request("/api/products/p1", {
-                method: "PUT",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ name: "Updated" })
-            });
-
-            await new Promise(r => setTimeout(r, 50));
-            expect(afterSaveSpy).toHaveBeenCalledWith(
-                "products",
-                expect.objectContaining({ id: "p1" }),
-                expect.objectContaining({ method: "PUT" })
-            );
-        });
-    });
-
-    // ── beforeDelete / afterDelete ───────────────────────────────────
-    describe("data.beforeDelete / afterDelete", () => {
-        it("aborts deletion when beforeDelete throws", async () => {
-            const hooks: DataHooks = {
-                beforeDelete(slug, entityId) {
-                    if (entityId === "protected") {
-                        throw new Error("Cannot delete protected entity");
-                    }
-                }
-            };
-            const app = createApp(mockDriver, hooks);
-
-            mockDriver.fetchEntity.mockResolvedValue(
-                { id: "protected",
-path: "products",
-values: {} } as any
-            );
-
-            const res = await app.request("/api/products/protected", { method: "DELETE" });
-            expect(res.status).toBe(500);
-            expect(mockDriver.deleteEntity).not.toHaveBeenCalled();
-        });
-
-        it("allows deletion when beforeDelete does not throw", async () => {
-            const beforeDeleteSpy = jest.fn();
-            const hooks: DataHooks = { beforeDelete: beforeDeleteSpy };
-            const app = createApp(mockDriver, hooks);
-
-            const existingEntity = { id: "p1",
-path: "products",
-values: {} } as any;
-            mockDriver.fetchEntity.mockResolvedValue(existingEntity);
-            mockDriver.deleteEntity.mockResolvedValue();
-
-            const res = await app.request("/api/products/p1", { method: "DELETE" });
-            expect(res.status).toBe(204);
-            expect(beforeDeleteSpy).toHaveBeenCalledWith(
-                "products", "p1", expect.objectContaining({ method: "DELETE" })
-            );
-            expect(mockDriver.deleteEntity).toHaveBeenCalled();
-        });
-
-        it("fires afterDelete after successful deletion", async () => {
-            const afterDeleteSpy = jest.fn();
-            const hooks: DataHooks = { afterDelete: afterDeleteSpy };
-            const app = createApp(mockDriver, hooks);
-
-            mockDriver.fetchEntity.mockResolvedValue({ id: "p1",
-path: "products",
-values: {} } as any);
-            mockDriver.deleteEntity.mockResolvedValue();
-
-            await app.request("/api/products/p1", { method: "DELETE" });
-            await new Promise(r => setTimeout(r, 50));
-
-            expect(afterDeleteSpy).toHaveBeenCalledWith(
-                "products", "p1", expect.objectContaining({ method: "DELETE" })
-            );
-        });
-    });
-
-    // ── no hooks (passthrough) ──────────────────────────────────────
-    describe("no hooks configured", () => {
-        it("returns data unchanged when no hooks are provided", async () => {
-            const app = createApp(mockDriver); // no hooks
-            mockDriver.fetchCollection.mockResolvedValue([
-                { id: "p1",
-path: "products",
-values: { name: "Widget" } } as any
-            ]);
-            mockDriver.countEntities!.mockResolvedValue(1);
-
-            const res = await app.request("/api/products");
-            expect(res.status).toBe(200);
-
-            const body = await res.json() as any;
-            expect(body.data).toHaveLength(1);
-            expect(body.data[0].name).toBe("Widget");
-        });
-    });
-});

package/test/custom-auth-adapter.test.ts

@@ -1,189 +0,0 @@
-import { createCustomAuthAdapter } from "../src/auth/custom-auth-adapter";
-import type { AuthenticatedUser, AuthResponsePayload, CustomAuthAdapterOptions } from "@rebasepro/types";
-
-const TEST_USER: AuthenticatedUser = {
-    uid: "user-123",
-    email: "test@example.com",
-    displayName: "Test User",
-    roles: ["editor"],
-    isAdmin: false,
-    rawToken: "tok_abc"
-};
-
-const ADMIN_USER: AuthenticatedUser = {
-    uid: "admin-1",
-    email: "admin@example.com",
-    roles: ["admin"],
-    isAdmin: true
-};
-
-describe("createCustomAuthAdapter", () => {
-    it("sets the adapter id to 'custom'", () => {
-        const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null
-        });
-        expect(adapter.id).toBe("custom");
-    });
-
-    it("delegates verifyRequest to the provided function", async () => {
-        const verifyRequest = jest.fn(async () => TEST_USER);
-        const adapter = createCustomAuthAdapter({ verifyRequest });
-        const req = new Request("http://localhost/api", {
-            headers: { Authorization: "Bearer test-token" }
-        });
-        const result = await adapter.verifyRequest(req);
-        expect(verifyRequest).toHaveBeenCalledWith(req);
-        expect(result).toBe(TEST_USER);
-    });
-
-    it("returns null from verifyRequest when the user function returns null", async () => {
-        const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null
-        });
-        const result = await adapter.verifyRequest(new Request("http://localhost/"));
-        expect(result).toBeNull();
-    });
-
-    // ── verifyToken (fallback via synthetic Request) ──────────────────
-
-    it("synthesizes a Request when verifyToken is not provided", async () => {
-        const verifyRequest = jest.fn(async (request: Request) => {
-            const auth = request.headers.get("authorization");
-            if (auth === "Bearer my-token") return TEST_USER;
-            return null;
-        });
-        const adapter = createCustomAuthAdapter({ verifyRequest });
-
-        expect(adapter.verifyToken).toBeDefined();
-
-        const result = await adapter.verifyToken!("my-token");
-        expect(result).toBe(TEST_USER);
-
-        // Verify the synthetic request was created correctly
-        expect(verifyRequest).toHaveBeenCalledTimes(1);
-        const calledRequest = verifyRequest.mock.calls[0][0] as Request;
-        expect(calledRequest.headers.get("authorization")).toBe("Bearer my-token");
-        expect(calledRequest.url).toContain("_ws_auth");
-    });
-
-    it("returns null from fallback verifyToken for invalid token", async () => {
-        const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null
-        });
-        const result = await adapter.verifyToken!("bad-token");
-        expect(result).toBeNull();
-    });
-
-    // ── verifyToken (direct passthrough) ──────────────────────────────
-
-    it("uses the user-provided verifyToken when given", async () => {
-        const customVerifyToken = jest.fn(async (token: string) => {
-            if (token === "direct-token") return ADMIN_USER;
-            return null;
-        });
-        const verifyRequest = jest.fn(async () => null);
-        const adapter = createCustomAuthAdapter({
-            verifyRequest,
-            verifyToken: customVerifyToken
-        });
-
-        const result = await adapter.verifyToken!("direct-token");
-        expect(result).toBe(ADMIN_USER);
-
-        // verifyRequest should NOT be called — verifyToken takes precedence
-        expect(verifyRequest).not.toHaveBeenCalled();
-    });
-
-    it("returns null from user-provided verifyToken for unknown token", async () => {
-        const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null,
-            verifyToken: async () => null
-        });
-        const result = await adapter.verifyToken!("unknown");
-        expect(result).toBeNull();
-    });
-
-    // ── Capabilities ──────────────────────────────────────────────────
-
-    it("returns default capabilities when none are overridden", async () => {
-        const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null
-        });
-        const caps = await adapter.getCapabilities!();
-        expect(caps).toEqual({
-            hasBuiltInAuthRoutes: false,
-            emailPasswordLogin: false,
-            registration: false,
-            passwordReset: false,
-            sessionManagement: false,
-            profileUpdate: false,
-            emailVerification: false,
-            magicLink: false,
-            enabledProviders: []
-        });
-    });
-
-    it("merges user-provided capabilities with defaults", async () => {
-        const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null,
-            capabilities: { emailPasswordLogin: true,
-registration: true }
-        });
-        const caps = await adapter.getCapabilities!();
-        expect(caps.emailPasswordLogin).toBe(true);
-        expect(caps.registration).toBe(true);
-        expect(caps.hasBuiltInAuthRoutes).toBe(false);
-    });
-
-    // ── Optional fields ───────────────────────────────────────────────
-
-    it("passes through serviceKey", () => {
-        const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null,
-            serviceKey: "sk_live_123"
-        });
-        expect(adapter.serviceKey).toBe("sk_live_123");
-    });
-
-    it("passes through userManagement when provided", () => {
-        const userMgmt = {
-            getUser: jest.fn(),
-            listUsers: jest.fn(),
-            createUser: jest.fn(),
-            updateUser: jest.fn(),
-            deleteUser: jest.fn()
-        };
-
-        const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null,
-            userManagement: userMgmt as unknown as CustomAuthAdapterOptions["userManagement"]
-        });
-
-        expect(adapter.userManagement).toBe(userMgmt);
-    });
-
-    it("omits userManagement when not provided", () => {
-        const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null
-        });
-        expect(adapter.userManagement).toBeUndefined();
-    });
-
-    // ── transformAuthResponse ────────────────────────────────────────────
-
-    it("passes through transformAuthResponse when provided", () => {
-        const transformFn = jest.fn(async (response: AuthResponsePayload) => response);
-        const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null,
-            transformAuthResponse: transformFn
-        });
-        expect(adapter.transformAuthResponse).toBe(transformFn);
-    });
-
-    it("omits transformAuthResponse when not provided", () => {
-        const adapter = createCustomAuthAdapter({
-            verifyRequest: async () => null
-        });
-        expect(adapter.transformAuthResponse).toBeUndefined();
-    });
-});