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

package/test/storage-routes.test.ts

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

package/test/storage-s3.test.ts

@@ -0,0 +1,304 @@
+import { describe, it, expect, beforeEach, afterEach, jest as vi } from "@jest/globals";
+import { S3StorageController } from "../src/storage/S3StorageController";
+
+// Mock the AWS SDK before importing the controller
+vi.mock("@aws-sdk/client-s3", () => ({
+    S3Client: vi.fn().mockImplementation(function() {
+        return { send: vi.fn() };
+    }),
+    PutObjectCommand: vi.fn(),
+    GetObjectCommand: vi.fn(),
+    DeleteObjectCommand: vi.fn(),
+    ListObjectsV2Command: vi.fn(),
+    HeadObjectCommand: vi.fn()
+}));
+
+vi.mock("@aws-sdk/s3-request-presigner", () => ({
+    getSignedUrl: vi.fn().mockResolvedValue("https://presigned-url.example.com")
+}));
+
+import { S3Client, PutObjectCommand, GetObjectCommand, DeleteObjectCommand, ListObjectsV2Command } from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+
+describe("S3StorageController", () => {
+    let controller: S3StorageController;
+    let mockSend: vi.Mock;
+
+    const defaultConfig = {
+        bucket: "test-bucket",
+        region: "us-east-1",
+        accessKeyId: "test-access-key",
+        secretAccessKey: "test-secret-key"
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockSend = vi.fn();
+        vi.mocked(S3Client).mockImplementation(function() {
+            return { send: mockSend };
+        } as any);
+        controller = new S3StorageController(defaultConfig);
+    });
+
+    describe("constructor", () => {
+        it("should initialize S3 client with credentials", () => {
+            expect(S3Client).toHaveBeenCalledWith(expect.objectContaining({
+                region: "us-east-1",
+                credentials: {
+                    accessKeyId: "test-access-key",
+                    secretAccessKey: "test-secret-key"
+                }
+            }));
+        });
+
+        it("should initialize with endpoint for S3-compatible services", () => {
+            vi.clearAllMocks();
+            new S3StorageController({
+                ...defaultConfig,
+                endpoint: "https://minio.example.com",
+                forcePathStyle: true
+            });
+
+            expect(S3Client).toHaveBeenCalledWith(expect.objectContaining({
+                endpoint: "https://minio.example.com",
+                forcePathStyle: true
+            }));
+        });
+
+        it("should return 's3' as type", () => {
+            expect(controller.getType()).toBe("s3");
+        });
+    });
+
+    describe("putObject", () => {
+        it("should upload file using PutObjectCommand", async () => {
+            const content = Buffer.from("Test content");
+            const file = new File([content], "test.txt", { type: "text/plain" });
+
+            mockSend.mockResolvedValueOnce({});
+
+            const result = await controller.putObject({
+                file,
+                key: "uploads/test.txt"
+            });
+
+            expect(PutObjectCommand).toHaveBeenCalledWith(expect.objectContaining({
+                Bucket: "test-bucket",
+                Key: "uploads/test.txt",
+                ContentType: "text/plain"
+            }));
+            expect(mockSend).toHaveBeenCalled();
+            expect(result.key).toBe("uploads/test.txt");
+        });
+
+        it("should include metadata in upload", async () => {
+            const file = new File(["content"], "test.txt", { type: "text/plain" });
+
+            mockSend.mockResolvedValueOnce({});
+
+            await controller.putObject({
+                file,
+                key: "uploads/test.txt",
+                metadata: { customKey: "customValue" }
+            });
+
+            expect(PutObjectCommand).toHaveBeenCalledWith(expect.objectContaining({
+                Metadata: expect.objectContaining({
+                    customKey: "customValue" // Keys are passed as-is, S3 handles casing
+                })
+            }));
+        });
+
+        it("should use custom bucket when specified", async () => {
+            const file = new File(["content"], "test.txt", { type: "text/plain" });
+
+            mockSend.mockResolvedValueOnce({});
+
+            await controller.putObject({
+                file,
+                key: "uploads/test.txt",
+                bucket: "custom-bucket"
+            });
+
+            expect(PutObjectCommand).toHaveBeenCalledWith(expect.objectContaining({
+                Bucket: "custom-bucket"
+            }));
+        });
+    });
+
+    describe("getSignedUrl", () => {
+        it("should generate presigned URL", async () => {
+            mockSend.mockResolvedValueOnce({
+                ContentType: "text/plain",
+                ContentLength: 100,
+                LastModified: new Date(),
+                Metadata: {}
+            });
+
+            const result = await controller.getSignedUrl("uploads/test.txt");
+
+            expect(getSignedUrl).toHaveBeenCalled();
+            expect(result.url).toBe("https://presigned-url.example.com");
+        });
+
+        it("should include metadata in download config", async () => {
+            const lastModified = new Date("2024-01-15T10:00:00Z");
+            mockSend.mockResolvedValueOnce({
+                ContentType: "image/png",
+                ContentLength: 5000,
+                LastModified: lastModified,
+                Metadata: { originalName: "photo.png" }
+            });
+
+            const result = await controller.getSignedUrl("images/photo.png");
+
+            expect(result.metadata).toBeDefined();
+            expect(result.metadata?.contentType).toBe("image/png");
+        });
+    });
+
+    describe("getObject", () => {
+        it("should return null for non-existent file", async () => {
+            const error = new Error("NoSuchKey");
+            (error as any).name = "NoSuchKey";
+            mockSend.mockRejectedValueOnce(error);
+
+            const result = await controller.getObject("nonexistent.txt");
+
+            expect(result).toBeNull();
+        });
+    });
+
+    describe("deleteObject", () => {
+        it("should delete file from S3", async () => {
+            mockSend.mockResolvedValueOnce({});
+
+            await controller.deleteObject("uploads/test.txt");
+
+            expect(DeleteObjectCommand).toHaveBeenCalledWith(expect.objectContaining({
+                Bucket: "test-bucket",
+                Key: "uploads/test.txt"
+            }));
+        });
+
+        it("should not throw for non-existent file", async () => {
+            mockSend.mockResolvedValueOnce({});
+
+            await expect(controller.deleteObject("nonexistent.txt")).resolves.not.toThrow();
+        });
+    });
+
+    describe("list", () => {
+        it("should list objects in S3 bucket", async () => {
+            mockSend.mockResolvedValueOnce({
+                Contents: [
+                    { Key: "uploads/file1.txt",
+Size: 100,
+LastModified: new Date() },
+                    { Key: "uploads/file2.txt",
+Size: 200,
+LastModified: new Date() }
+                ],
+                CommonPrefixes: [],
+                IsTruncated: false
+            });
+
+            const result = await controller.listObjects("uploads");
+
+            expect(ListObjectsV2Command).toHaveBeenCalledWith(expect.objectContaining({
+                Bucket: "test-bucket",
+                Prefix: "uploads" // Implementation doesn't add trailing slash
+            }));
+            expect(result.items).toHaveLength(2);
+        });
+
+        it("should handle pagination with maxResults", async () => {
+            mockSend.mockResolvedValueOnce({
+                Contents: [
+                    { Key: "uploads/file1.txt",
+Size: 100,
+LastModified: new Date() }
+                ],
+                CommonPrefixes: [],
+                IsTruncated: true,
+                NextContinuationToken: "token123"
+            });
+
+            const result = await controller.listObjects("uploads", { maxResults: 1 });
+
+            expect(ListObjectsV2Command).toHaveBeenCalledWith(expect.objectContaining({
+                MaxKeys: 1
+            }));
+            expect(result.nextPageToken).toBe("token123");
+        });
+
+        it("should include common prefixes as subdirectories", async () => {
+            mockSend.mockResolvedValueOnce({
+                Contents: [],
+                CommonPrefixes: [
+                    { Prefix: "uploads/images/" },
+                    { Prefix: "uploads/documents/" }
+                ],
+                IsTruncated: false
+            });
+
+            const result = await controller.listObjects("uploads");
+
+            expect(result.prefixes).toHaveLength(2);
+        });
+
+        it("should use pageToken for continuation", async () => {
+            mockSend.mockResolvedValueOnce({
+                Contents: [],
+                CommonPrefixes: [],
+                IsTruncated: false
+            });
+
+            await controller.listObjects("uploads", { pageToken: "continue-token" });
+
+            expect(ListObjectsV2Command).toHaveBeenCalledWith(expect.objectContaining({
+                ContinuationToken: "continue-token"
+            }));
+        });
+    });
+
+    describe("validateFile", () => {
+        it("should accept valid file", () => {
+            const file = new File(["content"], "valid.txt", { type: "text/plain" });
+
+            expect(() => {
+                (controller as any).validateFile(file);
+            }).not.toThrow();
+        });
+
+        it("should reject file exceeding max size", () => {
+            const smallController = new S3StorageController({
+                ...defaultConfig,
+                maxFileSize: 10 // 10 bytes
+            });
+
+            const largeContent = Buffer.alloc(100);
+            const file = new File([largeContent], "large.txt", { type: "text/plain" });
+
+            expect(() => {
+                (smallController as any).validateFile(file);
+            }).toThrow(/exceeds/i);
+        });
+    });
+
+    describe("flattenMetadata", () => {
+        it("should flatten nested metadata to strings", () => {
+            const metadata = {
+                simple: "value",
+                number: 42,
+                nested: { key: "value" }
+            };
+
+            const flattened = (controller as any).flattenMetadata(metadata);
+
+            expect(flattened.simple).toBe("value");
+            expect(flattened.number).toBe("42");
+            expect(typeof flattened.nested).toBe("string");
+        });
+    });
+});

package/test-ast.ts

@@ -0,0 +1,28 @@
+import { AstSchemaEditor } from "./src/api/ast-schema-editor";
+import * as fs from "fs";
+
+const collectionsDir = __dirname + "/collections-test";
+fs.mkdirSync(collectionsDir, { recursive: true });
+fs.writeFileSync(collectionsDir + "/users.ts", `
+export default {
+    name: "Users",
+    slug: "users",
+    properties: {},
+    securityRules: [
+        { name: "test", operation: "read", mode: "permissive", roles: ["public"] }
+    ]
+};
+`);
+
+async function main() {
+  const editor = new AstSchemaEditor(collectionsDir);
+  await editor.saveCollection("users", {
+    name: "Users",
+    slug: "users",
+    properties: {},
+    securityRules: []
+  });
+  console.log("AFTER SAVE:", fs.readFileSync(collectionsDir + "/users.ts", "utf8"));
+}
+
+main().catch(console.error);

package/test.ts

@@ -0,0 +1,6 @@
+interface I {
+    verify: (payload: any) => void;
+}
+const obj: I = {
+    verify: (payload: { code: string }) => {}
+};