@rebasepro/server-core 0.7.0 → 0.8.0

package/test/storage-routes.test.ts

@@ -13,6 +13,7 @@ import { Hono } from "hono";
 import { HonoEnv } from "../src/api/types";
 import { errorHandler } from "../src/api/errors";
 import { LocalStorageController } from "../src/storage/LocalStorageController";
+import { DefaultStorageRegistry } from "../src/storage/storage-registry";
 import { createStorageRoutes, extractWildcardPath } from "../src/storage/routes";
 
 // ──────────────────────────────────────────────────────────────────────
@@ -191,6 +192,38 @@ force: true });
         });
     });
 
+    describe("GET /sources", () => {
+        it("returns the default source in single-controller mode", async () => {
+            const res = await app.fetch(new Request("http://localhost/api/storage/sources"));
+            expect(res.status).toBe(200);
+            const body = await res.json() as { success: boolean; data: Array<{ key: string; engine: string; transport: string }> };
+            expect(body.success).toBe(true);
+            expect(body.data).toEqual([
+                { key: "(default)", engine: "local", transport: "server" }
+            ]);
+        });
+
+        it("merges declared definitions, including direct sources and labels", async () => {
+            const declaredApp = new Hono<HonoEnv>();
+            declaredApp.onError(errorHandler);
+            const routes = createStorageRoutes({
+                controller,
+                requireAuth: false,
+                sources: [
+                    { key: "(default)", engine: "local", transport: "server", label: "Local" },
+                    { key: "firebase", engine: "firebase", transport: "direct", label: "Firebase Storage" }
+                ]
+            });
+            declaredApp.route("/api/storage", routes);
+
+            const res = await declaredApp.fetch(new Request("http://localhost/api/storage/sources"));
+            expect(res.status).toBe(200);
+            const body = await res.json() as { success: boolean; data: Array<{ key: string; engine: string; transport: string; label?: string }> };
+            expect(body.data).toContainEqual({ key: "(default)", engine: "local", transport: "server", label: "Local" });
+            expect(body.data).toContainEqual({ key: "firebase", engine: "firebase", transport: "direct", label: "Firebase Storage" });
+        });
+    });
+
     describe("DELETE /file/*", () => {
         it("should delete an existing file", async () => {
             // Upload another file to delete
@@ -220,3 +253,130 @@ key: "photos/deleteme.txt" });
         });
     });
 });
+
+// ──────────────────────────────────────────────────────────────────────
+// Multi-backend routing through the StorageRegistry
+// ──────────────────────────────────────────────────────────────────────
+describe("Storage routes — multi-backend routing (registry)", () => {
+    let app: Hono<HonoEnv>;
+    let defaultDir: string;
+    let secondaryDir: string;
+
+    beforeEach(async () => {
+        defaultDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "rebase-default-"));
+        secondaryDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "rebase-secondary-"));
+
+        const registry = DefaultStorageRegistry.create({
+            "(default)": new LocalStorageController({ basePath: defaultDir }),
+            secondary: new LocalStorageController({ basePath: secondaryDir })
+        });
+
+        app = new Hono<HonoEnv>();
+        app.onError(errorHandler);
+        app.route("/api/storage", createStorageRoutes({
+            registry,
+            requireAuth: false,
+            sources: [
+                { key: "(default)", engine: "local", transport: "server" },
+                { key: "secondary", engine: "local", transport: "server", label: "Secondary" }
+            ]
+        }));
+    });
+
+    afterEach(async () => {
+        await fs.promises.rm(defaultDir, { recursive: true, force: true });
+        await fs.promises.rm(secondaryDir, { recursive: true, force: true });
+    });
+
+    async function upload(storageId: string | undefined, key: string, content: string) {
+        const fd = new FormData();
+        fd.append("file", new File([Buffer.from(content)], "file.txt", { type: "text/plain" }));
+        fd.append("key", key);
+        if (storageId) fd.append("storageId", storageId);
+        return app.fetch(new Request("http://localhost/api/storage/upload", { method: "POST", body: fd }));
+    }
+
+    it("routes an upload to the backend named by storageId", async () => {
+        const res = await upload("secondary", "docs/secret.txt", "in-secondary");
+        expect(res.ok).toBe(true);
+
+        // It physically landed in the secondary backend, not the default one.
+        const inSecondary = await app.fetch(
+            new Request("http://localhost/api/storage/file/default/docs/secret.txt?storageId=secondary")
+        );
+        expect(inSecondary.status).toBe(200);
+        expect(await inSecondary.text()).toBe("in-secondary");
+
+        // The default backend does not have it.
+        const inDefault = await app.fetch(
+            new Request("http://localhost/api/storage/file/default/docs/secret.txt")
+        );
+        expect(inDefault.status).toBe(404);
+    });
+
+    it("keeps the same key isolated per backend", async () => {
+        await upload(undefined, "shared.txt", "from-default");
+        await upload("secondary", "shared.txt", "from-secondary");
+
+        const d = await app.fetch(new Request("http://localhost/api/storage/file/default/shared.txt"));
+        const s = await app.fetch(new Request("http://localhost/api/storage/file/default/shared.txt?storageId=secondary"));
+        expect(await d.text()).toBe("from-default");
+        expect(await s.text()).toBe("from-secondary");
+    });
+
+    it("serves metadata from the backend named by storageId", async () => {
+        await upload("secondary", "m.txt", "x");
+        const res = await app.fetch(
+            new Request("http://localhost/api/storage/metadata/default/m.txt?storageId=secondary")
+        );
+        expect(res.status).toBe(200);
+        const body = await res.json() as { success: boolean; data: { contentType: string } };
+        expect(body.success).toBe(true);
+        expect(body.data.contentType).toBe("text/plain");
+    });
+
+    it("lists only the targeted backend's contents", async () => {
+        await upload(undefined, "only-default.txt", "a");
+        await upload("secondary", "only-secondary.txt", "b");
+
+        const res = await app.fetch(new Request("http://localhost/api/storage/list?storageId=secondary"));
+        const body = await res.json() as { data: { items: Array<{ name: string }> } };
+        const names = body.data.items.map((i) => i.name);
+        expect(names).toContain("only-secondary.txt");
+        expect(names).not.toContain("only-default.txt");
+    });
+
+    it("deletes from the backend named by storageId", async () => {
+        await upload("secondary", "del.txt", "bye");
+
+        const del = await app.fetch(
+            new Request("http://localhost/api/storage/file/default/del.txt?storageId=secondary", { method: "DELETE" })
+        );
+        expect(del.status).toBe(200);
+
+        const after = await app.fetch(
+            new Request("http://localhost/api/storage/file/default/del.txt?storageId=secondary")
+        );
+        expect(after.status).toBe(404);
+    });
+
+    it("falls back to the default backend for an unknown storageId", async () => {
+        const res = await upload("does-not-exist", "fallback.txt", "fell-back");
+        expect(res.ok).toBe(true);
+
+        // Unknown id falls back to default, so the file is in the default backend.
+        const inDefault = await app.fetch(
+            new Request("http://localhost/api/storage/file/default/fallback.txt")
+        );
+        expect(inDefault.status).toBe(200);
+        expect(await inDefault.text()).toBe("fell-back");
+    });
+
+    it("lists both backends via GET /sources", async () => {
+        const res = await app.fetch(new Request("http://localhost/api/storage/sources"));
+        const body = await res.json() as { data: Array<{ key: string; engine: string; label?: string }> };
+        const keys = body.data.map((s) => s.key);
+        expect(keys).toEqual(expect.arrayContaining(["(default)", "secondary"]));
+        expect(body.data.find((s) => s.key === "secondary")?.label).toBe("Secondary");
+    });
+});

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");
-        });
-    });
-});