@rebasepro/server-core 0.7.0 → 0.9.0

package/test/routed-realtime-service.test.ts

@@ -1,86 +0,0 @@
-import { describe, it, expect, jest, beforeEach } from "@jest/globals";
-import { createRoutedRealtimeService } from "../src/services/routed-realtime-service";
-import type { RealtimeProvider } from "@rebasepro/types";
-
-function mockProvider() {
-    return {
-        addClient: jest.fn(),
-        handleClientMessage: jest.fn(async () => {}),
-        subscribeToCollection: jest.fn(),
-        subscribeToEntity: jest.fn(),
-        unsubscribe: jest.fn(),
-        notifyEntityUpdate: jest.fn(async () => {}),
-        onServerReady: jest.fn(),
-        destroy: jest.fn(async () => {}),
-        stopListening: jest.fn(async () => {})
-    };
-}
-
-describe("createRoutedRealtimeService", () => {
-    let pg: ReturnType<typeof mockProvider>;
-    let mongo: ReturnType<typeof mockProvider>;
-    let routed: ReturnType<typeof createRoutedRealtimeService>;
-
-    beforeEach(() => {
-        pg = mockProvider();
-        mongo = mockProvider();
-        routed = createRoutedRealtimeService({
-            providers: { "(default)": pg as unknown as RealtimeProvider, mongo: mongo as unknown as RealtimeProvider },
-            defaultKey: "(default)",
-            resolveKey: (path) => (path.split("/")[0] === "events" ? "mongo" : "(default)")
-        });
-    });
-
-    it("routes subscribe_collection to the provider owning the collection", async () => {
-        await routed.handleClientMessage("c1", { type: "subscribe_collection", payload: { path: "events", subscriptionId: "s1" } });
-        expect(mongo.handleClientMessage).toHaveBeenCalledTimes(1);
-        expect(pg.handleClientMessage).not.toHaveBeenCalled();
-    });
-
-    it("routes subscribe_entity by path", async () => {
-        await routed.handleClientMessage("c1", { type: "subscribe_entity", payload: { path: "products", subscriptionId: "s2" } });
-        expect(pg.handleClientMessage).toHaveBeenCalledTimes(1);
-        expect(mongo.handleClientMessage).not.toHaveBeenCalled();
-    });
-
-    it("forwards unsubscribe to all providers (owner acts, others no-op)", async () => {
-        await routed.handleClientMessage("c1", { type: "unsubscribe", subscriptionId: "s1" });
-        expect(pg.handleClientMessage).toHaveBeenCalledTimes(1);
-        expect(mongo.handleClientMessage).toHaveBeenCalledTimes(1);
-    });
-
-    it("sends channel/presence/broadcast to the default provider only", async () => {
-        await routed.handleClientMessage("c1", { type: "broadcast", payload: { channel: "room", event: "x" } });
-        await routed.handleClientMessage("c1", { type: "join_channel", payload: { channel: "room" } });
-        await routed.handleClientMessage("c1", { type: "presence_track", payload: { channel: "room" } });
-        expect(pg.handleClientMessage).toHaveBeenCalledTimes(3);
-        expect(mongo.handleClientMessage).not.toHaveBeenCalled();
-    });
-
-    it("addClient is forwarded to every provider", () => {
-        const ws = {};
-        routed.addClient("c1", ws);
-        expect(pg.addClient).toHaveBeenCalledWith("c1", ws);
-        expect(mongo.addClient).toHaveBeenCalledWith("c1", ws);
-    });
-
-    it("notifyEntityUpdate routes by path", async () => {
-        await routed.notifyEntityUpdate("events", "e1", null);
-        expect(mongo.notifyEntityUpdate).toHaveBeenCalledTimes(1);
-        expect(pg.notifyEntityUpdate).not.toHaveBeenCalled();
-    });
-
-    it("unknown path falls back to the default provider", async () => {
-        await routed.handleClientMessage("c1", { type: "subscribe_collection", payload: { path: "mystery", subscriptionId: "s9" } });
-        expect(pg.handleClientMessage).toHaveBeenCalledTimes(1);
-    });
-
-    it("lifecycle methods fan out to all providers", async () => {
-        routed.onServerReady?.({ port: 3000 });
-        await routed.destroy?.();
-        expect(pg.onServerReady).toHaveBeenCalledTimes(1);
-        expect(mongo.onServerReady).toHaveBeenCalledTimes(1);
-        expect(pg.destroy).toHaveBeenCalledTimes(1);
-        expect(mongo.destroy).toHaveBeenCalledTimes(1);
-    });
-});

package/test/safe-compare.test.ts

@@ -1,66 +0,0 @@
-/**
- * Tests for the safeCompare function used in auth middleware.
- *
- * Since safeCompare is not exported, we test it indirectly through
- * the createAuthMiddleware behavior with service keys. However, for
- * unit-level verification we replicate the logic here.
- */
-import { timingSafeEqual } from "crypto";
-
-// Replicate the safeCompare implementation to test in isolation
-function safeCompare(a: string, b: string): boolean {
-    const maxLen = Math.max(a.length, b.length);
-    const bufA = Buffer.alloc(maxLen);
-    const bufB = Buffer.alloc(maxLen);
-    bufA.write(a);
-    bufB.write(b);
-    try {
-        const isEqual = timingSafeEqual(bufA, bufB);
-        return isEqual && a.length === b.length;
-    } catch {
-        return false;
-    }
-}
-
-describe("safeCompare", () => {
-    it("should return true for identical strings", () => {
-        expect(safeCompare("my-secret-key-12345678901234567890", "my-secret-key-12345678901234567890")).toBe(true);
-    });
-
-    it("should return false for different strings of same length", () => {
-        expect(safeCompare("aaaa", "bbbb")).toBe(false);
-    });
-
-    it("should return false for different length strings", () => {
-        expect(safeCompare("short", "a-much-longer-string")).toBe(false);
-    });
-
-    it("should return false when one string is a prefix of the other", () => {
-        // This is the critical case: "abc" vs "abc\0\0\0" would match
-        // without the length check, since Buffer.alloc zero-fills
-        expect(safeCompare("abc", "abc\0\0\0")).toBe(false);
-    });
-
-    it("should return false for empty string vs non-empty", () => {
-        expect(safeCompare("", "something")).toBe(false);
-    });
-
-    it("should return true for two empty strings", () => {
-        expect(safeCompare("", "")).toBe(true);
-    });
-
-    it("should handle unicode strings", () => {
-        expect(safeCompare("café", "café")).toBe(true);
-        expect(safeCompare("café", "cafe")).toBe(false);
-    });
-
-    it("should not leak length information via early return", () => {
-        // Both comparisons should take similar time (constant-time)
-        // We can't easily assert timing, but we verify they both
-        // go through the same code path
-        const result1 = safeCompare("a", "bb");
-        const result2 = safeCompare("aa", "bb");
-        expect(result1).toBe(false);
-        expect(result2).toBe(false);
-    });
-});

package/test/singleton.test.ts

@@ -1,59 +0,0 @@
-import { rebase, _initRebase, _setRebaseMock, _resetRebaseMock } from "../src/singleton";
-import type { RebaseClient } from "@rebasepro/types";
-
-describe("rebase singleton", () => {
-    afterEach(() => {
-        // Reset after each test to avoid interference
-        process.env.NODE_ENV = "test";
-        _resetRebaseMock();
-    });
-
-    it("should throw when accessing properties before initialization", () => {
-        expect(() => rebase.data).toThrow(/server not initialized yet/);
-    });
-
-    it("should allow property access after initialization", () => {
-        const mockData = { find: jest.fn() };
-        _setRebaseMock({ data: mockData } as Partial<RebaseClient>);
-
-        expect(rebase.data).toBe(mockData);
-    });
-
-    it("should throw on property assignment (set trap)", () => {
-        _setRebaseMock({ data: {} } as Partial<RebaseClient>);
-
-        expect(() => {
-            (rebase as Record<string, unknown>).data = "overwritten";
-        }).toThrow(/Cannot set rebase\.data directly/);
-    });
-
-    it("should reset properly with _resetRebaseMock", () => {
-        _setRebaseMock({ data: {} } as Partial<RebaseClient>);
-        expect(() => rebase.data).not.toThrow();
-
-        _resetRebaseMock();
-        expect(() => rebase.data).toThrow(/server not initialized yet/);
-    });
-
-    it("should throw if _setRebaseMock is called outside test env", () => {
-        const originalEnv = process.env.NODE_ENV;
-        process.env.NODE_ENV = "production";
-
-        expect(() => _setRebaseMock({} as Partial<RebaseClient>)).toThrow(
-            /can only be called in a test environment/
-        );
-
-        process.env.NODE_ENV = originalEnv;
-    });
-
-    it("should throw if _resetRebaseMock is called outside test env", () => {
-        const originalEnv = process.env.NODE_ENV;
-        process.env.NODE_ENV = "production";
-
-        expect(() => _resetRebaseMock()).toThrow(
-            /can only be called in a test environment/
-        );
-
-        process.env.NODE_ENV = originalEnv;
-    });
-});

package/test/smtp-email-service.test.ts

@@ -1,169 +0,0 @@
-import { SMTPEmailService } from "../src/email/smtp-email-service";
-import nodemailer from "nodemailer";
-
-jest.mock("nodemailer", () => {
-    const mockTransporter = {
-        verify: jest.fn().mockResolvedValue(true),
-        sendMail: jest.fn().mockResolvedValue(true)
-    };
-    return {
-        createTransport: jest.fn().mockReturnValue(mockTransporter)
-    };
-});
-
-describe("SMTPEmailService", () => {
-    let mockCreateTransport: jest.Mock;
-    let mockTransporter: any;
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockCreateTransport = nodemailer.createTransport as jest.Mock;
-        mockTransporter = mockCreateTransport({} as any); // gets the mocked object
-        mockCreateTransport.mockClear();
-    });
-
-    it("should create transport with explicit name", () => {
-        new SMTPEmailService({
-            from: "test@example.com",
-            smtp: {
-                host: "smtp.example.com",
-                port: 587,
-                name: "explicit-hostname"
-            }
-        });
-
-        expect(mockCreateTransport).toHaveBeenCalledWith(
-            expect.objectContaining({
-                name: "explicit-hostname",
-                host: "smtp.example.com",
-                port: 587
-            })
-        );
-    });
-
-    it("should infer name from FRONTEND_URL if smtp.name is undefined", () => {
-        const originalFrontendUrl = process.env.FRONTEND_URL;
-        process.env.FRONTEND_URL = "https://frontend-url.com/some-path";
-
-        try {
-            new SMTPEmailService({
-                from: "test@example.com",
-                smtp: {
-                    host: "smtp.example.com",
-                    port: 587
-                }
-            });
-
-            expect(mockCreateTransport).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    name: "frontend-url.com"
-                })
-            );
-        } finally {
-            process.env.FRONTEND_URL = originalFrontendUrl;
-        }
-    });
-
-    it("should infer name from resetPasswordUrl if FRONTEND_URL and smtp.name are undefined", () => {
-        const originalFrontendUrl = process.env.FRONTEND_URL;
-        delete process.env.FRONTEND_URL;
-
-        try {
-            new SMTPEmailService({
-                from: "test@example.com",
-                smtp: {
-                    host: "smtp.example.com",
-                    port: 587
-                },
-                resetPasswordUrl: "http://reset-password-url.org"
-            });
-
-            expect(mockCreateTransport).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    name: "reset-password-url.org"
-                })
-            );
-        } finally {
-            process.env.FRONTEND_URL = originalFrontendUrl;
-        }
-    });
-
-    it("should infer name from verifyEmailUrl if FRONTEND_URL, resetPasswordUrl and smtp.name are undefined", () => {
-        const originalFrontendUrl = process.env.FRONTEND_URL;
-        delete process.env.FRONTEND_URL;
-
-        try {
-            new SMTPEmailService({
-                from: "test@example.com",
-                smtp: {
-                    host: "smtp.example.com",
-                    port: 587
-                },
-                verifyEmailUrl: "verify-email-url.net/auth"
-            });
-
-            expect(mockCreateTransport).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    name: "verify-email-url.net"
-                })
-            );
-        } finally {
-            process.env.FRONTEND_URL = originalFrontendUrl;
-        }
-    });
-
-    it("should leave name undefined if no URLs are provided", () => {
-        const originalFrontendUrl = process.env.FRONTEND_URL;
-        delete process.env.FRONTEND_URL;
-
-        try {
-            new SMTPEmailService({
-                from: "test@example.com",
-                smtp: {
-                    host: "smtp.example.com",
-                    port: 587
-                }
-            });
-
-            expect(mockCreateTransport).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    name: undefined
-                })
-            );
-        } finally {
-            process.env.FRONTEND_URL = originalFrontendUrl;
-        }
-    });
-
-    it("should successfully verify SMTP connection", async () => {
-        mockTransporter.verify.mockResolvedValueOnce(true);
-
-        const service = new SMTPEmailService({
-            from: "test@example.com",
-            smtp: {
-                host: "smtp.example.com",
-                port: 587
-            }
-        });
-
-        const verified = await service.verifyConnection();
-        expect(verified).toBe(true);
-        expect(mockTransporter.verify).toHaveBeenCalled();
-    });
-
-    it("should return false if SMTP connection verification fails", async () => {
-        mockTransporter.verify.mockRejectedValueOnce(new Error("Connection timeout"));
-
-        const service = new SMTPEmailService({
-            from: "test@example.com",
-            smtp: {
-                host: "smtp.example.com",
-                port: 587
-            }
-        });
-
-        const verified = await service.verifyConnection();
-        expect(verified).toBe(false);
-        expect(mockTransporter.verify).toHaveBeenCalled();
-    });
-});

package/test/storage-local.test.ts

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