@rebasepro/server-core 0.7.0 → 0.9.0

package/test/driver-registry.test.ts

@@ -1,282 +0,0 @@
-import {
-    DriverRegistry,
-    DefaultDriverRegistry,
-    DEFAULT_DRIVER_ID
-} from "../src/services/driver-registry";
-import { DataDriver } from "@rebasepro/types";
-
-/**
- * Mock DataDriver for testing
- */
-function createMockDataDriverDelegate(key: string): DataDriver {
-    return {
-        key,
-        initialised: true,
-        fetchCollection: jest.fn().mockResolvedValue([]),
-        fetchEntity: jest.fn().mockResolvedValue(undefined),
-        saveEntity: jest.fn().mockResolvedValue({ id: "test-id",
-path: "test",
-values: {} }),
-        deleteEntity: jest.fn().mockResolvedValue(undefined),
-        checkUniqueField: jest.fn().mockResolvedValue(true)
-    };
-}
-
-describe("DriverRegistry", () => {
-    describe("DEFAULT_DRIVER_ID", () => {
-        it("should be '(default)'", () => {
-            expect(DEFAULT_DRIVER_ID).toBe("(default)");
-        });
-    });
-
-    describe("DefaultDriverRegistry", () => {
-        describe("constructor and basic operations", () => {
-            it("should create an empty registry", () => {
-                const registry = new DefaultDriverRegistry();
-                expect(registry.size()).toBe(0);
-                expect(registry.list()).toEqual([]);
-            });
-
-            it("should register a driver", () => {
-                const registry = new DefaultDriverRegistry();
-                const mockDelegate = createMockDataDriverDelegate("postgres");
-
-                registry.register("test-db", mockDelegate);
-
-                expect(registry.has("test-db")).toBe(true);
-                expect(registry.size()).toBe(1);
-                expect(registry.list()).toContain("test-db");
-            });
-
-            it("should get a registered driver", () => {
-                const registry = new DefaultDriverRegistry();
-                const mockDelegate = createMockDataDriverDelegate("postgres");
-
-                registry.register("my-db", mockDelegate);
-
-                const retrieved = registry.get("my-db");
-                expect(retrieved).toBe(mockDelegate);
-            });
-
-            it("should return undefined for non-existent driver", () => {
-                const registry = new DefaultDriverRegistry();
-                expect(registry.get("non-existent")).toBeUndefined();
-            });
-        });
-
-        describe("default driver handling", () => {
-            it("should get default driver with get(undefined)", () => {
-                const registry = new DefaultDriverRegistry();
-                const mockDelegate = createMockDataDriverDelegate("postgres");
-
-                registry.register(DEFAULT_DRIVER_ID, mockDelegate);
-
-                expect(registry.get(undefined)).toBe(mockDelegate);
-                expect(registry.get(null)).toBe(mockDelegate);
-            });
-
-            it("should get default driver with getDefault()", () => {
-                const registry = new DefaultDriverRegistry();
-                const mockDelegate = createMockDataDriverDelegate("postgres");
-
-                registry.register(DEFAULT_DRIVER_ID, mockDelegate);
-
-                expect(registry.getDefault()).toBe(mockDelegate);
-            });
-
-            it("should throw error when no default driver exists", () => {
-                const registry = new DefaultDriverRegistry();
-
-                expect(() => registry.getDefault()).toThrow(
-                    "[DriverRegistry] No default driver registered."
-                );
-            });
-        });
-
-        describe("getOrDefault", () => {
-            let registry: DefaultDriverRegistry;
-            let defaultDelegate: DataDriver;
-            let analyticsDelegate: DataDriver;
-
-            beforeEach(() => {
-                registry = new DefaultDriverRegistry();
-                defaultDelegate = createMockDataDriverDelegate("default-postgres");
-                analyticsDelegate = createMockDataDriverDelegate("analytics-postgres");
-
-                registry.register(DEFAULT_DRIVER_ID, defaultDelegate);
-                registry.register("analytics", analyticsDelegate);
-            });
-
-            it("should return specific driver when found", () => {
-                expect(registry.getOrDefault("analytics")).toBe(analyticsDelegate);
-            });
-
-            it("should return default when id is undefined", () => {
-                expect(registry.getOrDefault(undefined)).toBe(defaultDelegate);
-            });
-
-            it("should return default when id is null", () => {
-                expect(registry.getOrDefault(null)).toBe(defaultDelegate);
-            });
-
-            it("should fallback to default when id not found", () => {
-                // This should log a warning and return the default
-                const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
-
-                expect(registry.getOrDefault("non-existent")).toBe(defaultDelegate);
-                expect(consoleSpy).toHaveBeenCalledWith(
-                    expect.stringContaining('Driver "non-existent" not found')
-                );
-
-                consoleSpy.mockRestore();
-            });
-
-            it("should throw when fallback fails (no default)", () => {
-                const emptyRegistry = new DefaultDriverRegistry();
-
-                expect(() => emptyRegistry.getOrDefault("anything")).toThrow();
-            });
-        });
-
-        describe("overwriting drivers", () => {
-            it("should overwrite existing driver with same id", () => {
-                const registry = new DefaultDriverRegistry();
-                const original = createMockDataDriverDelegate("original");
-                const replacement = createMockDataDriverDelegate("replacement");
-
-                const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
-
-                registry.register("my-db", original);
-                registry.register("my-db", replacement);
-
-                expect(registry.get("my-db")).toBe(replacement);
-                expect(consoleSpy).toHaveBeenCalledWith(
-                    expect.stringContaining('Overwriting driver with id "my-db"')
-                );
-
-                consoleSpy.mockRestore();
-            });
-        });
-
-        describe("list and size", () => {
-            it("should list all registered drivers", () => {
-                const registry = new DefaultDriverRegistry();
-
-                registry.register("db-1", createMockDataDriverDelegate("pg1"));
-                registry.register("db-2", createMockDataDriverDelegate("pg2"));
-                registry.register(DEFAULT_DRIVER_ID, createMockDataDriverDelegate("default"));
-
-                const list = registry.list();
-                expect(list).toHaveLength(3);
-                expect(list).toContain("db-1");
-                expect(list).toContain("db-2");
-                expect(list).toContain(DEFAULT_DRIVER_ID);
-            });
-
-            it("should return correct size", () => {
-                const registry = new DefaultDriverRegistry();
-
-                expect(registry.size()).toBe(0);
-
-                registry.register("db-1", createMockDataDriverDelegate("pg1"));
-                expect(registry.size()).toBe(1);
-
-                registry.register("db-2", createMockDataDriverDelegate("pg2"));
-                expect(registry.size()).toBe(2);
-            });
-        });
-    });
-
-    describe("DefaultDriverRegistry.create() factory", () => {
-        describe("with single DataDriver", () => {
-            it('should register single delegate as "(default)"', () => {
-                const mockDelegate = createMockDataDriverDelegate("postgres");
-
-                const registry = DefaultDriverRegistry.create(mockDelegate);
-
-                expect(registry.has(DEFAULT_DRIVER_ID)).toBe(true);
-                expect(registry.getDefault()).toBe(mockDelegate);
-                expect(registry.size()).toBe(1);
-            });
-        });
-
-        describe("with map of DataDriverDelegates", () => {
-            it("should register all delegates from map", () => {
-                const defaultDelegate = createMockDataDriverDelegate("default-pg");
-                const analyticsDelegate = createMockDataDriverDelegate("analytics-pg");
-
-                const registry = DefaultDriverRegistry.create({
-                    [DEFAULT_DRIVER_ID]: defaultDelegate,
-                    "analytics": analyticsDelegate
-                });
-
-                expect(registry.size()).toBe(2);
-                expect(registry.getDefault()).toBe(defaultDelegate);
-                expect(registry.get("analytics")).toBe(analyticsDelegate);
-            });
-
-            it("should use first entry as default if no explicit default provided", () => {
-                const db1 = createMockDataDriverDelegate("db1");
-                const db2 = createMockDataDriverDelegate("db2");
-
-                const consoleSpy = jest.spyOn(console, "warn").mockImplementation();
-
-                const registry = DefaultDriverRegistry.create({
-                    "primary": db1,
-                    "secondary": db2
-                });
-
-                // Should have registered both + created default pointing to first
-                expect(registry.size()).toBe(3); // primary, secondary, (default)
-                expect(registry.has(DEFAULT_DRIVER_ID)).toBe(true);
-                expect(consoleSpy).toHaveBeenCalledWith(
-                    expect.stringContaining('No "(default)" driver provided')
-                );
-
-                consoleSpy.mockRestore();
-            });
-
-            it("should handle empty map gracefully", () => {
-                const registry = DefaultDriverRegistry.create({});
-
-                expect(registry.size()).toBe(0);
-                expect(() => registry.getDefault()).toThrow();
-            });
-        });
-    });
-
-    describe("type detection (isDataDriverDelegate)", () => {
-        it("should correctly identify a DataDriver", () => {
-            const mockDelegate = createMockDataDriverDelegate("postgres");
-
-            // The factory should recognize it as a single delegate
-            const registry = DefaultDriverRegistry.create(mockDelegate);
-            expect(registry.size()).toBe(1);
-            expect(registry.has(DEFAULT_DRIVER_ID)).toBe(true);
-        });
-
-        it("should correctly identify a map of DataDriverDelegates", () => {
-            const delegates = {
-                [DEFAULT_DRIVER_ID]: createMockDataDriverDelegate("pg1"),
-                "other": createMockDataDriverDelegate("pg2")
-            };
-
-            // The factory should recognize it as a map
-            const registry = DefaultDriverRegistry.create(delegates);
-            expect(registry.size()).toBe(2);
-        });
-
-        it("should not mistakenly identify a map as a single delegate", () => {
-            // A map doesn't have the required DataDriver methods
-            const map = {
-                key: "not-a-delegate", // This looks like the key property but...
-                db1: createMockDataDriverDelegate("pg1")
-            };
-
-            // This should be treated as a map (and show a warning because 'key' isn't a valid delegate)
-            const registry = DefaultDriverRegistry.create(map as any);
-            // 'key' entry will be ignored since it's not a valid delegate
-            expect(registry.has("db1")).toBe(true);
-        });
-    });
-});

package/test/email-templates.test.ts

@@ -1,174 +0,0 @@
-import {
-    getPasswordResetTemplate,
-    getEmailVerificationTemplate,
-    getUserInvitationTemplate,
-    getWelcomeEmailTemplate
-} from "../src/email/templates";
-
-describe("getPasswordResetTemplate", () => {
-    const user = { email: "john@example.com",
-displayName: "John Doe" };
-    const resetUrl = "https://example.com/reset?token=abc123";
-
-    it("returns subject, html, and text", () => {
-        const result = getPasswordResetTemplate(resetUrl, user);
-        expect(result.subject).toBeTruthy();
-        expect(result.html).toBeTruthy();
-        expect(result.text).toBeTruthy();
-    });
-
-    it("subject includes default app name", () => {
-        const result = getPasswordResetTemplate(resetUrl, user);
-        expect(result.subject).toContain("Rebase");
-    });
-
-    it("subject includes custom app name", () => {
-        const result = getPasswordResetTemplate(resetUrl, user, "MyApp");
-        expect(result.subject).toContain("MyApp");
-    });
-
-    it("html contains the reset URL", () => {
-        const result = getPasswordResetTemplate(resetUrl, user);
-        expect(result.html).toContain(resetUrl);
-    });
-
-    it("text contains the reset URL", () => {
-        const result = getPasswordResetTemplate(resetUrl, user);
-        expect(result.text).toContain(resetUrl);
-    });
-
-    it("uses displayName for greeting", () => {
-        const result = getPasswordResetTemplate(resetUrl, user);
-        expect(result.html).toContain("John Doe");
-        expect(result.text).toContain("John Doe");
-    });
-
-    it("falls back to email prefix when displayName is null", () => {
-        const userNoName = { email: "jane@example.com",
-displayName: null };
-        const result = getPasswordResetTemplate(resetUrl, userNoName);
-        expect(result.html).toContain("jane");
-        expect(result.text).toContain("jane");
-    });
-
-    it("html contains DOCTYPE and body tags", () => {
-        const result = getPasswordResetTemplate(resetUrl, user);
-        expect(result.html).toContain("<!DOCTYPE html>");
-        expect(result.html).toContain("<body");
-        expect(result.html).toContain("</body>");
-    });
-});
-
-describe("getEmailVerificationTemplate", () => {
-    const user = { email: "alice@example.com",
-displayName: "Alice" };
-    const verifyUrl = "https://example.com/verify?token=xyz789";
-
-    it("returns subject, html, and text", () => {
-        const result = getEmailVerificationTemplate(verifyUrl, user);
-        expect(result.subject).toBeTruthy();
-        expect(result.html).toBeTruthy();
-        expect(result.text).toBeTruthy();
-    });
-
-    it("subject mentions email verification", () => {
-        const result = getEmailVerificationTemplate(verifyUrl, user);
-        expect(result.subject.toLowerCase()).toContain("verify");
-    });
-
-    it("html contains the verification URL", () => {
-        const result = getEmailVerificationTemplate(verifyUrl, user);
-        expect(result.html).toContain(verifyUrl);
-    });
-
-    it("text contains the verification URL", () => {
-        const result = getEmailVerificationTemplate(verifyUrl, user);
-        expect(result.text).toContain(verifyUrl);
-    });
-
-    it("uses displayName when available", () => {
-        const result = getEmailVerificationTemplate(verifyUrl, user);
-        expect(result.html).toContain("Alice");
-    });
-
-    it("uses custom app name", () => {
-        const result = getEmailVerificationTemplate(verifyUrl, user, "CustomApp");
-        expect(result.subject).toContain("CustomApp");
-        expect(result.html).toContain("CustomApp");
-    });
-});
-
-describe("getUserInvitationTemplate", () => {
-    const user = { email: "bob@example.com",
-displayName: "Bob" };
-    const setPasswordUrl = "https://example.com/set-password?token=def456";
-
-    it("returns subject, html, and text", () => {
-        const result = getUserInvitationTemplate(setPasswordUrl, user);
-        expect(result.subject).toBeTruthy();
-        expect(result.html).toBeTruthy();
-        expect(result.text).toBeTruthy();
-    });
-
-    it("subject mentions invitation", () => {
-        const result = getUserInvitationTemplate(setPasswordUrl, user);
-        expect(result.subject.toLowerCase()).toContain("invited");
-    });
-
-    it("html contains the set password URL", () => {
-        const result = getUserInvitationTemplate(setPasswordUrl, user);
-        expect(result.html).toContain(setPasswordUrl);
-    });
-
-    it("text contains the set password URL", () => {
-        const result = getUserInvitationTemplate(setPasswordUrl, user);
-        expect(result.text).toContain(setPasswordUrl);
-    });
-
-    it("falls back to email prefix when no displayName", () => {
-        const userNoName = { email: "charlie@example.com" };
-        const result = getUserInvitationTemplate(setPasswordUrl, userNoName);
-        expect(result.html).toContain("charlie");
-    });
-});
-
-describe("getWelcomeEmailTemplate", () => {
-    const user = { email: "dave@example.com",
-displayName: "Dave" };
-
-    it("returns subject, html, and text", () => {
-        const result = getWelcomeEmailTemplate(user);
-        expect(result.subject).toBeTruthy();
-        expect(result.html).toBeTruthy();
-        expect(result.text).toBeTruthy();
-    });
-
-    it("includes the app name in subject", () => {
-        const result = getWelcomeEmailTemplate(user, "SuperApp");
-        expect(result.subject).toContain("SuperApp");
-    });
-
-    it("uses displayName for greeting", () => {
-        const result = getWelcomeEmailTemplate(user);
-        expect(result.html).toContain("Dave");
-    });
-
-    it("includes login URL when provided", () => {
-        const loginUrl = "https://example.com/login";
-        const result = getWelcomeEmailTemplate(user, "Rebase", loginUrl);
-        expect(result.html).toContain(loginUrl);
-        expect(result.text).toContain(loginUrl);
-    });
-
-    it("handles missing login URL gracefully", () => {
-        const result = getWelcomeEmailTemplate(user);
-        expect(result.html).toBeTruthy();
-        expect(result.text).toBeTruthy();
-    });
-
-    it("html contains proper structure", () => {
-        const result = getWelcomeEmailTemplate(user);
-        expect(result.html).toContain("<!DOCTYPE html>");
-        expect(result.html).toContain("<body");
-    });
-});

package/test/env.test.ts

@@ -1,128 +0,0 @@
-import { loadEnv } from "../src/env";
-import { z } from "zod";
-
-describe("env configuration and localhost validation", () => {
-    const originalEnv = { ...process.env };
-
-    beforeEach(() => {
-        // Clear process.env to ensure fresh test runs
-        process.env = {};
-        // Add basic fallback requirements to prevent bootstrap crashes
-        process.env.DATABASE_URL = "postgresql://localhost:5432/rebase";
-        process.env.JWT_SECRET = "super-secret-jwt-key-must-be-long-long-long";
-    });
-
-    afterEach(() => {
-        process.env = { ...originalEnv };
-    });
-
-    it("should parse default env variables in development mode", () => {
-        expect(() => loadEnv()).not.toThrow();
-        const env = loadEnv();
-        expect(env.DATABASE_URL).toBe("postgresql://localhost:5432/rebase");
-    });
-
-    it("should fail validation in production if DATABASE_URL contains localhost", () => {
-        process.env.NODE_ENV = "production";
-        process.env.DATABASE_URL = "postgresql://localhost:5432/rebase";
-        process.env.JWT_SECRET = "12345678901234567890123456789012";
-        process.env.FRONTEND_URL = "https://my-app.com";
-
-        expect(() => loadEnv()).toThrow(/postgresql:\/\/localhost:5432\/rebase/);
-    });
-
-    it("should fail validation in production if DATABASE_URL contains 127.0.0.1", () => {
-        process.env.NODE_ENV = "production";
-        process.env.DATABASE_URL = "postgresql://127.0.0.1:5432/rebase";
-        process.env.JWT_SECRET = "12345678901234567890123456789012";
-        process.env.FRONTEND_URL = "https://my-app.com";
-
-        expect(() => loadEnv()).toThrow(/postgresql:\/\/127\.0\.0\.1:5432\/rebase/);
-    });
-
-    it("should fail validation in production if DATABASE_URL contains an IPv6 loopback [::1]", () => {
-        process.env.NODE_ENV = "production";
-        process.env.DATABASE_URL = "postgresql://[::1]:5432/rebase";
-        process.env.JWT_SECRET = "12345678901234567890123456789012";
-        process.env.FRONTEND_URL = "https://my-app.com";
-
-        expect(() => loadEnv()).toThrow(/postgresql:\/\/\[::1\]:5432\/rebase/);
-    });
-
-    it("should fail validation in production if DATABASE_URL contains a loopback in the 127.x.x.x range", () => {
-        process.env.NODE_ENV = "production";
-        process.env.DATABASE_URL = "postgresql://127.0.0.2:5432/rebase";
-        process.env.JWT_SECRET = "12345678901234567890123456789012";
-        process.env.FRONTEND_URL = "https://my-app.com";
-
-        expect(() => loadEnv()).toThrow(/postgresql:\/\/127\.0\.0\.2:5432\/rebase/);
-    });
-
-    it("should succeed validation in production with a non-localhost DATABASE_URL", () => {
-        process.env.NODE_ENV = "production";
-        process.env.DATABASE_URL = "postgresql://db.my-app.com:5432/rebase";
-        process.env.JWT_SECRET = "12345678901234567890123456789012";
-        process.env.FRONTEND_URL = "https://my-app.com";
-
-        expect(() => loadEnv()).not.toThrow();
-        const env = loadEnv();
-        expect(env.DATABASE_URL).toBe("postgresql://db.my-app.com:5432/rebase");
-    });
-
-    it("should allow localhost URLs in production if ALLOW_LOCALHOST_IN_PRODUCTION is set to true", () => {
-        process.env.NODE_ENV = "production";
-        process.env.DATABASE_URL = "postgresql://localhost:5432/rebase";
-        process.env.JWT_SECRET = "12345678901234567890123456789012";
-        process.env.FRONTEND_URL = "https://my-app.com";
-        process.env.ALLOW_LOCALHOST_IN_PRODUCTION = "true";
-
-        expect(() => loadEnv()).not.toThrow();
-        const env = loadEnv();
-        expect(env.DATABASE_URL).toBe("postgresql://localhost:5432/rebase");
-    });
-
-    it("should not block localhost URLs in CORS_ORIGINS in production mode", () => {
-        process.env.NODE_ENV = "production";
-        process.env.DATABASE_URL = "postgresql://db.my-app.com:5432/rebase";
-        process.env.JWT_SECRET = "12345678901234567890123456789012";
-        process.env.FRONTEND_URL = "https://my-app.com";
-        process.env.CORS_ORIGINS = "http://localhost:3000,https://my-app.com";
-
-        expect(() => loadEnv()).not.toThrow();
-        const env = loadEnv();
-        expect(env.CORS_ORIGINS).toBe("http://localhost:3000,https://my-app.com");
-    });
-
-    it("should validate and block localhost in extended variables", () => {
-        process.env.NODE_ENV = "production";
-        process.env.DATABASE_URL = "postgresql://db.my-app.com:5432/rebase";
-        process.env.JWT_SECRET = "12345678901234567890123456789012";
-        process.env.FRONTEND_URL = "https://my-app.com";
-        // Extended URL points to localhost
-        process.env.EXTERNAL_SERVICE_URL = "https://localhost:8080/api";
-
-        const extension = {
-            extend: z.object({
-                EXTERNAL_SERVICE_URL: z.string().url()
-            })
-        };
-
-        expect(() => loadEnv(extension)).toThrow(/https:\/\/localhost:8080\/api/);
-    });
-
-    it("should validate and block plain host string matching localhost", () => {
-        process.env.NODE_ENV = "production";
-        process.env.DATABASE_URL = "postgresql://db.my-app.com:5432/rebase";
-        process.env.JWT_SECRET = "12345678901234567890123456789012";
-        process.env.FRONTEND_URL = "https://my-app.com";
-        process.env.DB_HOST = "localhost";
-
-        const extension = {
-            extend: z.object({
-                DB_HOST: z.string()
-            })
-        };
-
-        expect(() => loadEnv(extension)).toThrow(/localhost/);
-    });
-});