@rebasepro/server-core 0.7.0 → 0.9.0

package/test/storage-registry.test.ts

@@ -1,282 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, jest as vi } from "@jest/globals";
-import {
-    StorageRegistry,
-    DefaultStorageRegistry,
-    DEFAULT_STORAGE_ID
-} from "../src/storage/storage-registry";
-import { StorageController } from "../src/storage/types";
-
-/**
- * Mock StorageController for testing
- */
-function createMockStorageController(type: "local" | "s3"): StorageController {
-    return {
-        putObject: vi.fn().mockResolvedValue({ path: "test/file.txt" }),
-        getSignedUrl: vi.fn().mockResolvedValue({ url: "http://example.com/file.txt" }),
-        getObject: vi.fn().mockResolvedValue(null),
-        deleteObject: vi.fn().mockResolvedValue(undefined),
-        listObjects: vi.fn().mockResolvedValue({ items: [],
-prefixes: [] }),
-        getType: vi.fn().mockReturnValue(type)
-    };
-}
-
-describe("StorageRegistry", () => {
-    describe("DEFAULT_STORAGE_ID", () => {
-        it("should be '(default)'", () => {
-            expect(DEFAULT_STORAGE_ID).toBe("(default)");
-        });
-    });
-
-    describe("DefaultStorageRegistry", () => {
-        describe("constructor and basic operations", () => {
-            it("should create an empty registry", () => {
-                const registry = new DefaultStorageRegistry();
-                expect(registry.size()).toBe(0);
-                expect(registry.list()).toEqual([]);
-            });
-
-            it("should register a storage controller", () => {
-                const registry = new DefaultStorageRegistry();
-                const mockController = createMockStorageController("local");
-
-                registry.register("test-storage", mockController);
-
-                expect(registry.has("test-storage")).toBe(true);
-                expect(registry.size()).toBe(1);
-                expect(registry.list()).toContain("test-storage");
-            });
-
-            it("should get a registered storage controller", () => {
-                const registry = new DefaultStorageRegistry();
-                const mockController = createMockStorageController("s3");
-
-                registry.register("my-storage", mockController);
-
-                const retrieved = registry.get("my-storage");
-                expect(retrieved).toBe(mockController);
-            });
-
-            it("should return undefined for non-existent storage", () => {
-                const registry = new DefaultStorageRegistry();
-                expect(registry.get("non-existent")).toBeUndefined();
-            });
-        });
-
-        describe("default storage handling", () => {
-            it("should get default storage with get(undefined)", () => {
-                const registry = new DefaultStorageRegistry();
-                const mockController = createMockStorageController("local");
-
-                registry.register(DEFAULT_STORAGE_ID, mockController);
-
-                expect(registry.get(undefined)).toBe(mockController);
-                expect(registry.get(null)).toBe(mockController);
-            });
-
-            it("should get default storage with getDefault()", () => {
-                const registry = new DefaultStorageRegistry();
-                const mockController = createMockStorageController("local");
-
-                registry.register(DEFAULT_STORAGE_ID, mockController);
-
-                expect(registry.getDefault()).toBe(mockController);
-            });
-
-            it("should throw error when no default storage exists", () => {
-                const registry = new DefaultStorageRegistry();
-
-                expect(() => registry.getDefault()).toThrow(
-                    "[StorageRegistry] No default storage registered."
-                );
-            });
-        });
-
-        describe("getOrDefault", () => {
-            let registry: DefaultStorageRegistry;
-            let defaultController: StorageController;
-            let mediaController: StorageController;
-
-            beforeEach(() => {
-                registry = new DefaultStorageRegistry();
-                defaultController = createMockStorageController("local");
-                mediaController = createMockStorageController("s3");
-
-                registry.register(DEFAULT_STORAGE_ID, defaultController);
-                registry.register("media", mediaController);
-            });
-
-            it("should return specific storage when found", () => {
-                expect(registry.getOrDefault("media")).toBe(mediaController);
-            });
-
-            it("should return default when id is undefined", () => {
-                expect(registry.getOrDefault(undefined)).toBe(defaultController);
-            });
-
-            it("should return default when id is null", () => {
-                expect(registry.getOrDefault(null)).toBe(defaultController);
-            });
-
-            it("should fallback to default when id not found", () => {
-                const consoleSpy = vi.spyOn(console, "warn").mockImplementation();
-
-                expect(registry.getOrDefault("non-existent")).toBe(defaultController);
-                expect(consoleSpy).toHaveBeenCalledWith(
-                    expect.stringContaining('Storage "non-existent" not found')
-                );
-
-                consoleSpy.mockRestore();
-            });
-
-            it("should throw when fallback fails (no default)", () => {
-                const emptyRegistry = new DefaultStorageRegistry();
-
-                expect(() => emptyRegistry.getOrDefault("anything")).toThrow();
-            });
-        });
-
-        describe("overwriting storages", () => {
-            it("should overwrite existing storage with same id", () => {
-                const registry = new DefaultStorageRegistry();
-                const original = createMockStorageController("local");
-                const replacement = createMockStorageController("s3");
-
-                const consoleSpy = vi.spyOn(console, "warn").mockImplementation();
-
-                registry.register("my-storage", original);
-                registry.register("my-storage", replacement);
-
-                expect(registry.get("my-storage")).toBe(replacement);
-                expect(consoleSpy).toHaveBeenCalledWith(
-                    expect.stringContaining('Overwriting storage with id "my-storage"')
-                );
-
-                consoleSpy.mockRestore();
-            });
-        });
-
-        describe("list and size", () => {
-            it("should list all registered storages", () => {
-                const registry = new DefaultStorageRegistry();
-
-                registry.register("storage-1", createMockStorageController("local"));
-                registry.register("storage-2", createMockStorageController("s3"));
-                registry.register(DEFAULT_STORAGE_ID, createMockStorageController("local"));
-
-                const list = registry.list();
-                expect(list).toHaveLength(3);
-                expect(list).toContain("storage-1");
-                expect(list).toContain("storage-2");
-                expect(list).toContain(DEFAULT_STORAGE_ID);
-            });
-
-            it("should return correct size", () => {
-                const registry = new DefaultStorageRegistry();
-
-                expect(registry.size()).toBe(0);
-
-                registry.register("storage-1", createMockStorageController("local"));
-                expect(registry.size()).toBe(1);
-
-                registry.register("storage-2", createMockStorageController("s3"));
-                expect(registry.size()).toBe(2);
-            });
-        });
-    });
-
-    describe("DefaultStorageRegistry.create() factory", () => {
-        describe("with single StorageController", () => {
-            it('should register single controller as "(default)"', () => {
-                const mockController = createMockStorageController("local");
-
-                const registry = DefaultStorageRegistry.create(mockController);
-
-                expect(registry.has(DEFAULT_STORAGE_ID)).toBe(true);
-                expect(registry.getDefault()).toBe(mockController);
-                expect(registry.size()).toBe(1);
-            });
-        });
-
-        describe("with map of StorageControllers", () => {
-            it("should register all controllers from map", () => {
-                const defaultController = createMockStorageController("local");
-                const mediaController = createMockStorageController("s3");
-
-                const registry = DefaultStorageRegistry.create({
-                    [DEFAULT_STORAGE_ID]: defaultController,
-                    "media": mediaController
-                });
-
-                expect(registry.size()).toBe(2);
-                expect(registry.getDefault()).toBe(defaultController);
-                expect(registry.get("media")).toBe(mediaController);
-            });
-
-            it("should use first entry as default if no explicit default provided", () => {
-                const local = createMockStorageController("local");
-                const s3 = createMockStorageController("s3");
-
-                const consoleSpy = vi.spyOn(console, "warn").mockImplementation();
-
-                const registry = DefaultStorageRegistry.create({
-                    "primary": local,
-                    "secondary": s3
-                });
-
-                // Should have registered both + created default pointing to first
-                expect(registry.size()).toBe(3); // primary, secondary, (default)
-                expect(registry.has(DEFAULT_STORAGE_ID)).toBe(true);
-                expect(consoleSpy).toHaveBeenCalledWith(
-                    expect.stringContaining('No "(default)" storage provided')
-                );
-
-                consoleSpy.mockRestore();
-            });
-
-            it("should handle empty map gracefully", () => {
-                const registry = DefaultStorageRegistry.create({});
-
-                expect(registry.size()).toBe(0);
-                expect(() => registry.getDefault()).toThrow();
-            });
-        });
-    });
-
-    describe("type detection (isStorageController)", () => {
-        it("should correctly identify a StorageController", () => {
-            const mockController = createMockStorageController("local");
-
-            // The factory should recognize it as a single controller
-            const registry = DefaultStorageRegistry.create(mockController);
-            expect(registry.size()).toBe(1);
-            expect(registry.has(DEFAULT_STORAGE_ID)).toBe(true);
-        });
-
-        it("should correctly identify a map of StorageControllers", () => {
-            const controllers = {
-                [DEFAULT_STORAGE_ID]: createMockStorageController("local"),
-                "other": createMockStorageController("s3")
-            };
-
-            // The factory should recognize it as a map
-            const registry = DefaultStorageRegistry.create(controllers);
-            expect(registry.size()).toBe(2);
-        });
-    });
-
-    describe("integration with storage types", () => {
-        it("should correctly report storage types", () => {
-            const localController = createMockStorageController("local");
-            const s3Controller = createMockStorageController("s3");
-
-            const registry = DefaultStorageRegistry.create({
-                [DEFAULT_STORAGE_ID]: localController,
-                "media": s3Controller
-            });
-
-            expect(registry.getDefault().getType()).toBe("local");
-            expect(registry.get("media")?.getType()).toBe("s3");
-        });
-    });
-});

package/test/storage-routes.test.ts

@@ -1,222 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, jest as vi } from "@jest/globals";
-/**
- * Tests for storage routes — specifically the sub-router wildcard extraction
- * that broke when Hono's c.req.param('*') stopped working in mounted sub-routers.
- *
- * These tests use Hono's built-in `app.fetch()` to simulate requests without
- * needing a running HTTP server, which keeps them fast and deterministic.
- */
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { Hono } from "hono";
-import { HonoEnv } from "../src/api/types";
-import { errorHandler } from "../src/api/errors";
-import { LocalStorageController } from "../src/storage/LocalStorageController";
-import { createStorageRoutes, extractWildcardPath } from "../src/storage/routes";
-
-// ──────────────────────────────────────────────────────────────────────
-// Unit tests for extractWildcardPath
-// ──────────────────────────────────────────────────────────────────────
-
-describe("extractWildcardPath", () => {
-    it("should extract path after the route prefix", () => {
-        const result = extractWildcardPath({
-            req: {
-                path: "/api/storage/metadata/default/author_pictures/photo.jpg",
-                routePath: "/api/storage/metadata/*"
-            }
-        });
-        expect(result).toBe("default/author_pictures/photo.jpg");
-    });
-
-    it("should extract simple file path", () => {
-        const result = extractWildcardPath({
-            req: {
-                path: "/api/storage/file/testfile.jpg",
-                routePath: "/api/storage/file/*"
-            }
-        });
-        expect(result).toBe("testfile.jpg");
-    });
-
-    it("should return empty string for trailing-slash-only path", () => {
-        const result = extractWildcardPath({
-            req: {
-                path: "/api/storage/metadata/",
-                routePath: "/api/storage/metadata/*"
-            }
-        });
-        expect(result).toBe("");
-    });
-
-    it("should return empty string when path equals prefix (no trailing slash)", () => {
-        const result = extractWildcardPath({
-            req: {
-                path: "/api/storage/metadata",
-                routePath: "/api/storage/metadata/*"
-            }
-        });
-        expect(result).toBe("");
-    });
-
-    it("should handle deeply nested paths", () => {
-        const result = extractWildcardPath({
-            req: {
-                path: "/api/storage/file/bucket/a/b/c/d/file.png",
-                routePath: "/api/storage/file/*"
-            }
-        });
-        expect(result).toBe("bucket/a/b/c/d/file.png");
-    });
-
-    it("should handle paths with spaces and special chars", () => {
-        const result = extractWildcardPath({
-            req: {
-                path: "/api/storage/file/default/photos/my%20file%20(1).png",
-                routePath: "/api/storage/file/*"
-            }
-        });
-        expect(result).toBe("default/photos/my%20file%20(1).png");
-    });
-});
-
-// ──────────────────────────────────────────────────────────────────────
-// Integration tests: storage routes mounted as Hono sub-router
-// ──────────────────────────────────────────────────────────────────────
-
-describe("Storage routes (sub-router integration)", () => {
-    let app: Hono<HonoEnv>;
-    let tempDir: string;
-    let controller: LocalStorageController;
-
-    beforeEach(async () => {
-        tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "rebase-routes-test-"));
-        controller = new LocalStorageController({ basePath: tempDir });
-
-        // Upload a test file so we have something to serve
-        const content = Buffer.from("Hello test file");
-        const file = new File([content], "test.txt", { type: "text/plain" });
-        await controller.putObject({ file,
-key: "photos/test.txt" });
-
-        // Create the Hono app with storage routes mounted as a SUB-ROUTER
-        // (this is the exact pattern that caused the bug)
-        app = new Hono<HonoEnv>();
-        app.onError(errorHandler); // required to convert ApiError throws to proper HTTP responses
-        const storageRoutes = createStorageRoutes({
-            controller,
-            requireAuth: false // skip auth for tests
-        });
-        app.route("/api/storage", storageRoutes);
-    });
-
-    afterEach(async () => {
-        await fs.promises.rm(tempDir, { recursive: true,
-force: true });
-    });
-
-    describe("GET /metadata/*", () => {
-        it("should return metadata for a valid file path", async () => {
-            const res = await app.fetch(
-                new Request("http://localhost/api/storage/metadata/default/photos/test.txt")
-            );
-
-            expect(res.status).toBe(200);
-            const body = await res.json() as { success: boolean; data: { contentType: string } };
-            expect(body.success).toBe(true);
-            expect(body.data).toBeDefined();
-            expect(body.data.contentType).toBe("text/plain");
-        });
-
-        it("should return metadata without explicit bucket prefix", async () => {
-            const res = await app.fetch(
-                new Request("http://localhost/api/storage/metadata/photos/test.txt")
-            );
-
-            expect(res.status).toBe(200);
-            const body = await res.json() as { success: boolean; data: { contentType: string } };
-            expect(body.success).toBe(true);
-            expect(body.data).toBeDefined();
-        });
-
-        it("should return 404 for empty path", async () => {
-            const res = await app.fetch(
-                new Request("http://localhost/api/storage/metadata/")
-            );
-            expect(res.status).toBe(404);
-        });
-
-        it("should return 404 for non-existent file", async () => {
-            const res = await app.fetch(
-                new Request("http://localhost/api/storage/metadata/default/nope/missing.txt")
-            );
-            expect(res.status).toBe(404);
-        });
-    });
-
-    describe("GET /file/*", () => {
-        it("should serve file content for a valid path", async () => {
-            const res = await app.fetch(
-                new Request("http://localhost/api/storage/file/default/photos/test.txt")
-            );
-
-            expect(res.status).toBe(200);
-            const body = await res.text();
-            expect(body).toBe("Hello test file");
-        });
-
-        it("should serve file without explicit bucket prefix", async () => {
-            const res = await app.fetch(
-                new Request("http://localhost/api/storage/file/photos/test.txt")
-            );
-
-            expect(res.status).toBe(200);
-            const body = await res.text();
-            expect(body).toBe("Hello test file");
-        });
-
-        it("should return 404 for empty path", async () => {
-            const res = await app.fetch(
-                new Request("http://localhost/api/storage/file/")
-            );
-            expect(res.status).toBe(404);
-        });
-
-        it("should return 404 for non-existent file", async () => {
-            const res = await app.fetch(
-                new Request("http://localhost/api/storage/file/default/nope/missing.txt")
-            );
-            expect(res.status).toBe(404);
-        });
-    });
-
-    describe("DELETE /file/*", () => {
-        it("should delete an existing file", async () => {
-            // Upload another file to delete
-            const file = new File([Buffer.from("delete me")], "deleteme.txt", { type: "text/plain" });
-            await controller.putObject({ file,
-key: "photos/deleteme.txt" });
-
-            const res = await app.fetch(
-                new Request("http://localhost/api/storage/file/default/photos/deleteme.txt", { method: "DELETE" })
-            );
-
-            expect(res.status).toBe(200);
-            const body = await res.json() as { success: boolean };
-            expect(body.success).toBe(true);
-
-            // Verify the file is actually gone
-            const filePath = path.join(tempDir, "default", "photos", "deleteme.txt");
-            const exists = await fs.promises.access(filePath).then(() => true).catch(() => false);
-            expect(exists).toBe(false);
-        });
-
-        it("should handle empty path gracefully", async () => {
-            const res = await app.fetch(
-                new Request("http://localhost/api/storage/file/", { method: "DELETE" })
-            );
-            expect(res.status).toBe(200);
-        });
-    });
-});