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

package/test/storage-local.test.ts

@@ -0,0 +1,271 @@
+import { describe, it, expect, beforeEach, afterEach, jest as vi } from "@jest/globals";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { LocalStorageController } from "../src/storage/LocalStorageController";
+
+describe("LocalStorageController", () => {
+    let controller: LocalStorageController;
+    let tempDir: string;
+
+    beforeEach(async () => {
+        // Create a temporary directory for tests
+        tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "rebase-storage-test-"));
+        controller = new LocalStorageController({
+            basePath: tempDir
+        });
+    });
+
+    afterEach(async () => {
+        // Clean up temporary directory
+        await fs.promises.rm(tempDir, { recursive: true,
+force: true });
+    });
+
+    describe("constructor", () => {
+        it("should initialize with basePath", () => {
+            expect(controller.getBasePath()).toBe(tempDir);
+        });
+
+        it("should return 'local' as type", () => {
+            expect(controller.getType()).toBe("local");
+        });
+    });
+
+    describe("putObject", () => {
+        it("should upload a file and return metadata", async () => {
+            const content = Buffer.from("Hello, World!");
+            const file = new File([content], "test.txt", { type: "text/plain" });
+
+            const result = await controller.putObject({
+                file,
+                key: "uploads/test.txt"
+            });
+
+            expect(result.key).toContain("uploads");
+            expect(result.key).toContain("test.txt");
+
+            // Verify file exists on disk (uses default bucket)
+            const filePath = path.join(tempDir, "default", "uploads", "test.txt");
+            const exists = await fs.promises.access(filePath).then(() => true).catch(() => false);
+            expect(exists).toBe(true);
+        });
+
+        it("should create nested directories", async () => {
+            const content = Buffer.from("Nested content");
+            const file = new File([content], "nested.txt", { type: "text/plain" });
+
+            await controller.putObject({
+                file,
+                key: "level1/level2/level3/nested.txt"
+            });
+
+            const filePath = path.join(tempDir, "default", "level1", "level2", "level3", "nested.txt");
+            const exists = await fs.promises.access(filePath).then(() => true).catch(() => false);
+            expect(exists).toBe(true);
+        });
+
+        it("should handle custom bucket", async () => {
+            const content = Buffer.from("Bucket content");
+            const file = new File([content], "bucket.txt", { type: "text/plain" });
+
+            await controller.putObject({
+                file,
+                key: "files/bucket.txt",
+                bucket: "custom-bucket"
+            });
+
+            const filePath = path.join(tempDir, "custom-bucket", "files", "bucket.txt");
+            const exists = await fs.promises.access(filePath).then(() => true).catch(() => false);
+            expect(exists).toBe(true);
+        });
+
+        it("should store metadata alongside file", async () => {
+            const content = Buffer.from("With metadata");
+            const file = new File([content], "meta.txt", { type: "text/plain" });
+
+            await controller.putObject({
+                file,
+                key: "uploads/meta.txt",
+                metadata: { customField: "customValue" }
+            });
+
+            // Implementation uses .metadata.json extension
+            const metadataPath = path.join(tempDir, "default", "uploads", "meta.txt.metadata.json");
+            const exists = await fs.promises.access(metadataPath).then(() => true).catch(() => false);
+            expect(exists).toBe(true);
+        });
+    });
+
+    describe("getObject", () => {
+        it("should retrieve an uploaded file using local:// URL format", async () => {
+            const content = Buffer.from("Retrieve me");
+            const file = new File([content], "retrieve.txt", { type: "text/plain" });
+
+            const uploadResult = await controller.putObject({
+                file,
+                key: "uploads/retrieve.txt"
+            });
+
+            // Use the storageUrl from upload result (local:// format)
+            const retrieved = await controller.getObject(uploadResult.storageUrl!);
+
+            expect(retrieved).not.toBeNull();
+            expect(retrieved?.name).toBe("retrieve.txt");
+        });
+
+        it("should return null for non-existent file", async () => {
+            const result = await controller.getObject("local://default/nonexistent/file.txt");
+            expect(result).toBeNull();
+        });
+    });
+
+    describe("deleteObject", () => {
+        it("should delete an uploaded file using local:// URL format", async () => {
+            const content = Buffer.from("Delete me");
+            const file = new File([content], "delete.txt", { type: "text/plain" });
+
+            const uploadResult = await controller.putObject({
+                file,
+                key: "uploads/delete.txt"
+            });
+
+            // Verify file exists
+            const filePath = path.join(tempDir, "default", "uploads", "delete.txt");
+            let exists = await fs.promises.access(filePath).then(() => true).catch(() => false);
+            expect(exists).toBe(true);
+
+            // Delete the file using local:// URL format
+            await controller.deleteObject(uploadResult.storageUrl!);
+
+            // Verify file no longer exists
+            exists = await fs.promises.access(filePath).then(() => true).catch(() => false);
+            expect(exists).toBe(false);
+        });
+
+        it("should not throw when deleting non-existent file", async () => {
+            await expect(controller.deleteObject("local://default/nonexistent/file.txt")).resolves.not.toThrow();
+        });
+
+        it("should also delete metadata file", async () => {
+            const content = Buffer.from("Delete with metadata");
+            const file = new File([content], "withmeta.txt", { type: "text/plain" });
+
+            const uploadResult = await controller.putObject({
+                file,
+                key: "uploads/withmeta.txt",
+                metadata: { key: "value" }
+            });
+
+            await controller.deleteObject(uploadResult.storageUrl!);
+
+            const metadataPath = path.join(tempDir, "default", "uploads", "withmeta.txt.metadata.json");
+            const exists = await fs.promises.access(metadataPath).then(() => true).catch(() => false);
+            expect(exists).toBe(false);
+        });
+    });
+
+    describe("list", () => {
+        beforeEach(async () => {
+            // Upload some test files
+            for (let i = 1; i <= 5; i++) {
+                const file = new File([`Content ${i}`], `file${i}.txt`, { type: "text/plain" });
+                await controller.putObject({
+                    file,
+                    key: `listtest/file${i}.txt`
+                });
+            }
+        });
+
+        it("should list files in a directory", async () => {
+            const result = await controller.listObjects("listtest", { bucket: "default" });
+
+            // Items should be the actual files (not metadata files)
+            expect(result.items.length).toBeGreaterThanOrEqual(5);
+        });
+
+        it("should return empty list for non-existent directory", async () => {
+            const result = await controller.listObjects("nonexistent", { bucket: "default" });
+
+            expect(result.items).toHaveLength(0);
+        });
+    });
+
+    describe("getSignedUrl", () => {
+        it("should return download URL for existing file", async () => {
+            const content = Buffer.from("Download me");
+            const file = new File([content], "download.txt", { type: "text/plain" });
+
+            const uploadResult = await controller.putObject({
+                file,
+                key: "uploads/download.txt"
+            });
+
+            // Use the storageUrl from upload result
+            const result = await controller.getSignedUrl(uploadResult.storageUrl!);
+
+            expect(result.url).toBeTruthy();
+            expect(result.fileNotFound).toBeFalsy();
+        });
+
+        it("should return fileNotFound for non-existent file", async () => {
+            const result = await controller.getSignedUrl("local://default/nonexistent/file.txt");
+
+            expect(result.fileNotFound).toBe(true);
+        });
+    });
+
+    describe("getAbsolutePath", () => {
+        it("should return absolute filesystem path without bucket", () => {
+            const absPath = controller.getAbsolutePath("uploads/test.txt");
+
+            // getAbsolutePath uses getFullPath which doesn't include bucket unless specified
+            expect(absPath).toBe(path.join(tempDir, "uploads", "test.txt"));
+        });
+
+        it("should handle custom bucket", () => {
+            const absPath = controller.getAbsolutePath("uploads/test.txt", "custom");
+
+            expect(absPath).toBe(path.join(tempDir, "custom", "uploads", "test.txt"));
+        });
+    });
+
+    describe("validateFile", () => {
+        it("should accept valid file", () => {
+            const file = new File(["content"], "valid.txt", { type: "text/plain" });
+
+            // Should not throw
+            expect(() => {
+                (controller as {validateFile: (f: File) => void}).validateFile(file);
+            }).not.toThrow();
+        });
+
+        it("should reject file exceeding max size", () => {
+            // Create a controller with small max size
+            const smallController = new LocalStorageController({
+                basePath: tempDir,
+                maxFileSize: 10 // 10 bytes
+            });
+
+            const largeContent = Buffer.alloc(100);
+            const file = new File([largeContent], "large.txt", { type: "text/plain" });
+
+            expect(() => {
+                (smallController as {validateFile: (f: File) => void}).validateFile(file);
+            }).toThrow(/exceeds/i);
+        });
+
+        it("should reject disallowed file types", () => {
+            const controllerWithTypes = new LocalStorageController({
+                basePath: tempDir,
+                allowedMimeTypes: ["image/png", "image/jpeg"]
+            });
+
+            const file = new File(["content"], "script.js", { type: "application/javascript" });
+
+            expect(() => {
+                (controllerWithTypes as {validateFile: (f: File) => void}).validateFile(file);
+            }).toThrow(/not allowed/i);
+        });
+    });
+});

package/test/storage-registry.test.ts

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