@rebasepro/server-postgresql 0.6.1 → 0.7.0

package/test/cli-helpers.test.ts

@@ -0,0 +1,59 @@
+import { getDevDatabaseUrl, getTableIncludesFromCollections } from "../src/cli-helpers";
+
+describe("CLI Helpers", () => {
+    describe("getDevDatabaseUrl", () => {
+        it("should parse standard postgres URL and append _dev_diff", () => {
+            const dbUrl = "postgresql://user:pass@localhost:5432/my_db";
+            expect(getDevDatabaseUrl(dbUrl)).toBe("postgresql://user:pass@localhost:5432/my_db_dev_diff");
+        });
+
+        it("should parse postgres URL with query parameters", () => {
+            const dbUrl = "postgresql://user:pass@localhost:5432/my_db?sslmode=disable";
+            expect(getDevDatabaseUrl(dbUrl)).toBe("postgresql://user:pass@localhost:5432/my_db_dev_diff?sslmode=disable");
+        });
+
+        it("should fall back to simple string concatenation on invalid URL", () => {
+            const dbUrl = "invalid-url-string";
+            expect(getDevDatabaseUrl(dbUrl)).toBe("invalid-url-string_dev_diff");
+        });
+    });
+
+    describe("getTableIncludesFromCollections", () => {
+        it("should parse collections and return correct includes array", async () => {
+            const mockCollections = [
+                {
+                    slug: "users",
+                    table: "users",
+                    properties: {
+                        name: { type: "string" }
+                    }
+                },
+                {
+                    slug: "posts",
+                    table: "posts",
+                    properties: {
+                        title: { type: "string" }
+                    },
+                    relations: [
+                        {
+                            relationName: "tags",
+                            target: () => ({ table: "tags", slug: "tags" }),
+                            cardinality: "many",
+                            direction: "owning",
+                            through: {
+                                table: "posts_to_tags",
+                                sourceColumn: "post_id",
+                                targetColumn: "tag_id"
+                            }
+                        }
+                    ]
+                }
+            ];
+
+            const includes = await getTableIncludesFromCollections(mockCollections);
+            expect(includes).toContain("public.users");
+            expect(includes).toContain("public.posts");
+            expect(includes).toContain("public.posts_to_tags");
+        });
+    });
+});

package/test/connection.test.ts

@@ -0,0 +1,292 @@
+import { Pool, PoolConfig } from "pg";
+
+// ── Capture every Pool instantiation so we can inspect config & event handlers ──
+interface MockPoolInstance {
+    config: PoolConfig;
+    handlers: Record<string, ((...args: unknown[]) => void)[]>;
+    on: jest.Mock;
+    end: jest.Mock;
+}
+
+const poolInstances: MockPoolInstance[] = [];
+
+jest.mock("pg", () => {
+    const actual = jest.requireActual<typeof import("pg")>("pg");
+    const MockPool = jest.fn().mockImplementation((config: PoolConfig) => {
+        const handlers: Record<string, ((...args: unknown[]) => void)[]> = {};
+        const instance: MockPoolInstance = {
+            config,
+            handlers,
+            on: jest.fn((event: string, handler: (...args: unknown[]) => void) => {
+                handlers[event] = handlers[event] || [];
+                handlers[event].push(handler);
+                return instance;
+            }),
+            end: jest.fn().mockResolvedValue(undefined)
+        };
+        poolInstances.push(instance);
+        return instance;
+    });
+    return { ...actual, Pool: MockPool };
+});
+
+// ── Stub drizzle – we only care that it is called, not what it returns ──
+const mockDrizzle = jest.fn().mockReturnValue({ __drizzle: true });
+jest.mock("drizzle-orm/node-postgres", () => ({
+    drizzle: mockDrizzle
+}));
+
+// ── Stub the logger so it doesn't try to write anywhere ──
+jest.mock("@rebasepro/server-core", () => ({
+    logger: {
+        error: jest.fn(),
+        warn: jest.fn(),
+        info: jest.fn(),
+        debug: jest.fn()
+    }
+}));
+
+import {
+    createPostgresDatabaseConnection,
+    createDirectDatabaseConnection,
+    createReadReplicaConnection
+} from "../src/connection";
+import { logger } from "@rebasepro/server-core";
+
+// ── Helpers ──────────────────────────────────────────────────────────────────────
+function lastPool(): MockPoolInstance {
+    return poolInstances[poolInstances.length - 1];
+}
+
+// ─────────────────────────────────────────────────────────────────────────────────
+// Tests
+// ─────────────────────────────────────────────────────────────────────────────────
+beforeEach(() => {
+    poolInstances.length = 0;
+    jest.clearAllMocks();
+});
+
+describe("createPostgresDatabaseConnection", () => {
+    const connStr = "postgresql://user:pass@localhost:5432/mydb";
+
+    it("returns an object with db, pool, and connectionString", () => {
+        const result = createPostgresDatabaseConnection(connStr);
+
+        expect(result).toHaveProperty("db");
+        expect(result).toHaveProperty("pool");
+        expect(result).toHaveProperty("connectionString", connStr);
+    });
+
+    it("creates a Pool with the provided connectionString", () => {
+        createPostgresDatabaseConnection(connStr);
+
+        expect(Pool).toHaveBeenCalledTimes(1);
+        expect(lastPool().config.connectionString).toBe(connStr);
+    });
+
+    it("applies default pool config values", () => {
+        createPostgresDatabaseConnection(connStr);
+        const cfg = lastPool().config;
+
+        expect(cfg.max).toBe(20);
+        expect(cfg.idleTimeoutMillis).toBe(30_000);
+        expect(cfg.connectionTimeoutMillis).toBe(10_000);
+        expect(cfg.query_timeout).toBe(30_000);
+        expect(cfg.statement_timeout).toBe(30_000);
+        expect(cfg.keepAlive).toBe(true);
+        expect(cfg.keepAliveInitialDelayMillis).toBe(0);
+    });
+
+    it("merges custom poolConfig over defaults", () => {
+        createPostgresDatabaseConnection(connStr, undefined, {
+            max: 50,
+            idleTimeoutMillis: 60_000
+        });
+        const cfg = lastPool().config;
+
+        expect(cfg.max).toBe(50);
+        expect(cfg.idleTimeoutMillis).toBe(60_000);
+        // other defaults are preserved
+        expect(cfg.connectionTimeoutMillis).toBe(10_000);
+        expect(cfg.keepAlive).toBe(true);
+    });
+
+    it("registers an error handler on the pool", () => {
+        createPostgresDatabaseConnection(connStr);
+        const pool = lastPool();
+
+        expect(pool.on).toHaveBeenCalledWith("error", expect.any(Function));
+        expect(pool.handlers["error"]).toHaveLength(1);
+    });
+
+    it("error handler logs unexpected pool errors", () => {
+        createPostgresDatabaseConnection(connStr);
+        const handler = lastPool().handlers["error"][0];
+
+        handler(new Error("something broke"));
+
+        expect(logger.error).toHaveBeenCalledWith(
+            "[pg-pool] Unexpected pool error",
+            expect.objectContaining({ detail: "something broke" })
+        );
+    });
+
+    it("error handler logs additional warning for ETIMEDOUT errors", () => {
+        createPostgresDatabaseConnection(connStr);
+        const handler = lastPool().handlers["error"][0];
+
+        handler(new Error("connect ETIMEDOUT 1.2.3.4:5432"));
+
+        expect(logger.error).toHaveBeenCalled();
+        expect(logger.warn).toHaveBeenCalledWith(
+            "[pg-pool] Connection timeout detected — pool will auto-retry"
+        );
+    });
+
+    it("calls drizzle with the pool when no schema is provided", () => {
+        createPostgresDatabaseConnection(connStr);
+
+        expect(mockDrizzle).toHaveBeenCalledWith(lastPool());
+    });
+
+    it("calls drizzle with pool and schema when schema is provided", () => {
+        const schema = { users: {} };
+        createPostgresDatabaseConnection(connStr, schema);
+
+        expect(mockDrizzle).toHaveBeenCalledWith(lastPool(), { schema });
+    });
+
+    it("passes schema as Record<string, unknown>", () => {
+        const schema: Record<string, unknown> = { orders: {}, products: {} };
+        createPostgresDatabaseConnection(connStr, schema);
+
+        expect(mockDrizzle).toHaveBeenCalledWith(lastPool(), { schema });
+    });
+});
+
+describe("createDirectDatabaseConnection", () => {
+    const connStr = "postgresql://user:pass@localhost:5432/direct_db";
+
+    it("returns an object with db, pool, and connectionString", () => {
+        const result = createDirectDatabaseConnection(connStr);
+
+        expect(result).toHaveProperty("db");
+        expect(result).toHaveProperty("pool");
+        expect(result).toHaveProperty("connectionString", connStr);
+    });
+
+    it("uses a smaller default max of 5 for the direct pool", () => {
+        createDirectDatabaseConnection(connStr);
+        const cfg = lastPool().config;
+
+        expect(cfg.max).toBe(5);
+    });
+
+    it("allows overriding the default max on the direct pool", () => {
+        createDirectDatabaseConnection(connStr, undefined, { max: 3 });
+        const cfg = lastPool().config;
+
+        expect(cfg.max).toBe(3);
+    });
+
+    it("registers an error handler on the pool", () => {
+        createDirectDatabaseConnection(connStr);
+        const pool = lastPool();
+
+        expect(pool.on).toHaveBeenCalledWith("error", expect.any(Function));
+        expect(pool.handlers["error"]).toHaveLength(1);
+    });
+
+    it("error handler logs with [pg-direct-pool] prefix", () => {
+        createDirectDatabaseConnection(connStr);
+        const handler = lastPool().handlers["error"][0];
+
+        handler(new Error("direct pool error"));
+
+        expect(logger.error).toHaveBeenCalledWith(
+            "[pg-direct-pool] Unexpected pool error",
+            expect.objectContaining({ detail: "direct pool error" })
+        );
+    });
+
+    it("calls drizzle without schema when none is given", () => {
+        createDirectDatabaseConnection(connStr);
+
+        expect(mockDrizzle).toHaveBeenCalledWith(lastPool());
+    });
+
+    it("calls drizzle with schema when given", () => {
+        const schema = { sessions: {} };
+        createDirectDatabaseConnection(connStr, schema);
+
+        expect(mockDrizzle).toHaveBeenCalledWith(lastPool(), { schema });
+    });
+});
+
+describe("createReadReplicaConnection", () => {
+    const connStr = "postgresql://readonly:pass@replica:5432/replica_db";
+
+    it("returns an object with db, pool, and connectionString", () => {
+        const result = createReadReplicaConnection(connStr);
+
+        expect(result).toHaveProperty("db");
+        expect(result).toHaveProperty("pool");
+        expect(result).toHaveProperty("connectionString", connStr);
+    });
+
+    it("uses a default max of 10 for the replica pool", () => {
+        createReadReplicaConnection(connStr);
+        const cfg = lastPool().config;
+
+        expect(cfg.max).toBe(10);
+    });
+
+    it("allows overriding the default max on the replica pool", () => {
+        createReadReplicaConnection(connStr, undefined, { max: 25 });
+
+        expect(lastPool().config.max).toBe(25);
+    });
+
+    it("registers an error handler on the pool", () => {
+        createReadReplicaConnection(connStr);
+        const pool = lastPool();
+
+        expect(pool.on).toHaveBeenCalledWith("error", expect.any(Function));
+        expect(pool.handlers["error"]).toHaveLength(1);
+    });
+
+    it("error handler logs with [pg-replica-pool] prefix", () => {
+        createReadReplicaConnection(connStr);
+        const handler = lastPool().handlers["error"][0];
+
+        handler(new Error("replica error"));
+
+        expect(logger.error).toHaveBeenCalledWith(
+            "[pg-replica-pool] Unexpected pool error",
+            expect.objectContaining({ detail: "replica error" })
+        );
+    });
+
+    it("inherits remaining default pool settings", () => {
+        createReadReplicaConnection(connStr);
+        const cfg = lastPool().config;
+
+        expect(cfg.idleTimeoutMillis).toBe(30_000);
+        expect(cfg.connectionTimeoutMillis).toBe(10_000);
+        expect(cfg.keepAlive).toBe(true);
+        expect(cfg.keepAliveInitialDelayMillis).toBe(0);
+    });
+
+    it("calls drizzle without schema when none is given", () => {
+        createReadReplicaConnection(connStr);
+
+        expect(mockDrizzle).toHaveBeenCalledWith(lastPool());
+    });
+
+    it("calls drizzle with schema when given", () => {
+        const schema = { analytics: {} };
+        createReadReplicaConnection(connStr, schema);
+
+        expect(mockDrizzle).toHaveBeenCalledWith(lastPool(), { schema });
+    });
+});

package/test/databasePoolManager.test.ts

@@ -0,0 +1,289 @@
+import { DatabasePoolManager } from "../src/databasePoolManager";
+
+// ── Mock pg.Pool ──────────────────────────────────────────────────────────────
+// Each `new Pool(...)` call returns a fresh mock with `.end()` and `.on()`.
+const createMockPool = () => ({
+    end: jest.fn().mockResolvedValue(undefined),
+    on: jest.fn()
+});
+
+let mockPoolInstances: ReturnType<typeof createMockPool>[] = [];
+
+jest.mock("pg", () => ({
+    Pool: jest.fn().mockImplementation(() => {
+        const pool = createMockPool();
+        mockPoolInstances.push(pool);
+        return pool;
+    })
+}));
+
+// ── Mock drizzle ──────────────────────────────────────────────────────────────
+jest.mock("drizzle-orm/node-postgres", () => ({
+    drizzle: jest.fn().mockImplementation(() => ({
+        __drizzleMock: true
+    }))
+}));
+
+// ── Mock logger ───────────────────────────────────────────────────────────────
+jest.mock("@rebasepro/server-core", () => ({
+    logger: {
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn()
+    }
+}));
+
+const VALID_CONNECTION_STRING = "postgresql://user:pass@localhost:5432/mydb";
+
+describe("DatabasePoolManager", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockPoolInstances = [];
+    });
+
+    // ── Constructor ────────────────────────────────────────────────────────
+    describe("constructor", () => {
+        it("should extract the default database name from the connection string", () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            expect(manager.defaultDatabaseName).toBe("mydb");
+        });
+
+        it("should handle connection strings with paths containing multiple segments", () => {
+            const manager = new DatabasePoolManager(
+                "postgresql://user:pass@localhost:5432/production_db"
+            );
+            expect(manager.defaultDatabaseName).toBe("production_db");
+        });
+
+        it("should throw on an invalid connection string", () => {
+            expect(() => new DatabasePoolManager("not-a-url")).toThrow(
+                /Invalid adminConnectionString/
+            );
+        });
+    });
+
+    // ── getPool – caching ──────────────────────────────────────────────────
+    describe("getPool", () => {
+        it("should return the same pool instance for the same database name", () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+
+            const pool1 = manager.getPool("testdb");
+            const pool2 = manager.getPool("testdb");
+
+            expect(pool1).toBe(pool2);
+            // Only one Pool should have been constructed
+            expect(mockPoolInstances).toHaveLength(1);
+        });
+
+        it("should create separate pool instances for different database names", () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+
+            const poolA = manager.getPool("db_alpha");
+            const poolB = manager.getPool("db_beta");
+
+            expect(poolA).not.toBe(poolB);
+            expect(mockPoolInstances).toHaveLength(2);
+        });
+
+        it("should register an error handler on newly created pools", () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            manager.getPool("errdb");
+
+            const pool = mockPoolInstances[0];
+            expect(pool.on).toHaveBeenCalledWith("error", expect.any(Function));
+        });
+
+        it("should build the connection string using the requested database name", () => {
+            const { Pool: PoolCtor } = jest.requireMock("pg") as {
+                Pool: jest.Mock;
+            };
+
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            manager.getPool("custom_db");
+
+            const configArg = PoolCtor.mock.calls[0][0] as {
+                connectionString: string;
+            };
+            expect(configArg.connectionString).toContain("/custom_db");
+        });
+    });
+
+    // ── hasPool ────────────────────────────────────────────────────────────
+    describe("hasPool", () => {
+        it("should return false when no pool exists for the given name", () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            expect(manager.hasPool("nonexistent")).toBe(false);
+        });
+
+        it("should return true after a pool has been created", () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            manager.getPool("exists");
+            expect(manager.hasPool("exists")).toBe(true);
+        });
+    });
+
+    // ── getDrizzle ─────────────────────────────────────────────────────────
+    describe("getDrizzle", () => {
+        it("should return a drizzle instance for a given database name", () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            const db = manager.getDrizzle("appdb");
+
+            expect(db).toBeDefined();
+            expect((db as unknown as { __drizzleMock: boolean }).__drizzleMock).toBe(true);
+        });
+
+        it("should cache and reuse the drizzle instance for the same database name", () => {
+            const { drizzle } = jest.requireMock("drizzle-orm/node-postgres") as {
+                drizzle: jest.Mock;
+            };
+
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            const db1 = manager.getDrizzle("cached");
+            const db2 = manager.getDrizzle("cached");
+
+            expect(db1).toBe(db2);
+            // drizzle() should only have been called once for this database
+            expect(drizzle).toHaveBeenCalledTimes(1);
+        });
+
+        it("should create different drizzle instances for different databases", () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            const dbA = manager.getDrizzle("first");
+            const dbB = manager.getDrizzle("second");
+
+            expect(dbA).not.toBe(dbB);
+        });
+    });
+
+    // ── disconnectDatabase ─────────────────────────────────────────────────
+    describe("disconnectDatabase", () => {
+        it("should call pool.end() and remove the pool from cache", async () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            manager.getPool("dropme");
+
+            expect(manager.hasPool("dropme")).toBe(true);
+            const pool = mockPoolInstances[0];
+
+            await manager.disconnectDatabase("dropme");
+
+            expect(pool.end).toHaveBeenCalledTimes(1);
+            expect(manager.hasPool("dropme")).toBe(false);
+        });
+
+        it("should also clear the cached drizzle instance", async () => {
+            const { drizzle } = jest.requireMock("drizzle-orm/node-postgres") as {
+                drizzle: jest.Mock;
+            };
+
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            manager.getDrizzle("dropme");
+            drizzle.mockClear();
+
+            await manager.disconnectDatabase("dropme");
+
+            // After disconnect, getDrizzle should create a fresh instance
+            manager.getDrizzle("dropme");
+            expect(drizzle).toHaveBeenCalledTimes(1);
+        });
+
+        it("should not throw when disconnecting a non-existent database", async () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            // Should complete without error
+            await expect(
+                manager.disconnectDatabase("ghost")
+            ).resolves.toBeUndefined();
+        });
+    });
+
+    // ── shutdown ────────────────────────────────────────────────────────────
+    describe("shutdown", () => {
+        it("should call pool.end() on every cached pool", async () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            manager.getPool("a");
+            manager.getPool("b");
+            manager.getPool("c");
+
+            await manager.shutdown();
+
+            for (const pool of mockPoolInstances) {
+                expect(pool.end).toHaveBeenCalledTimes(1);
+            }
+        });
+
+        it("should clear the pool cache after shutdown", async () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            manager.getPool("x");
+            manager.getPool("y");
+
+            await manager.shutdown();
+
+            expect(manager.hasPool("x")).toBe(false);
+            expect(manager.hasPool("y")).toBe(false);
+        });
+
+        it("should clear drizzle instances after shutdown", async () => {
+            const { drizzle } = jest.requireMock("drizzle-orm/node-postgres") as {
+                drizzle: jest.Mock;
+            };
+
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            manager.getDrizzle("z");
+            drizzle.mockClear();
+
+            await manager.shutdown();
+
+            // A fresh drizzle call should be needed after shutdown
+            manager.getDrizzle("z");
+            expect(drizzle).toHaveBeenCalledTimes(1);
+        });
+
+        it("should not throw when called on a manager with no pools", async () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            await expect(manager.shutdown()).resolves.toBeUndefined();
+        });
+
+        it("should not throw when called multiple times", async () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            manager.getPool("once");
+
+            await manager.shutdown();
+            await expect(manager.shutdown()).resolves.toBeUndefined();
+        });
+
+        it("should handle a pool.end() rejection gracefully (Promise.all rejects)", async () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            manager.getPool("bad");
+
+            const pool = mockPoolInstances[0];
+            pool.end.mockRejectedValue(new Error("connection already closed"));
+
+            await expect(manager.shutdown()).rejects.toThrow(
+                "connection already closed"
+            );
+        });
+    });
+
+    // ── Pool re-creation after disconnect ──────────────────────────────────
+    describe("pool re-creation after disconnect", () => {
+        it("should create a fresh pool after disconnecting a database", async () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            const poolBefore = manager.getPool("recreate");
+
+            await manager.disconnectDatabase("recreate");
+            const poolAfter = manager.getPool("recreate");
+
+            expect(poolBefore).not.toBe(poolAfter);
+            expect(mockPoolInstances).toHaveLength(2);
+        });
+
+        it("should create fresh pools after shutdown", async () => {
+            const manager = new DatabasePoolManager(VALID_CONNECTION_STRING);
+            const poolBefore = manager.getPool("revive");
+
+            await manager.shutdown();
+            const poolAfter = manager.getPool("revive");
+
+            expect(poolBefore).not.toBe(poolAfter);
+        });
+    });
+});