@rebasepro/server-postgresql 0.6.0 → 0.7.0

package/test/data-transformer.test.ts

@@ -149,14 +149,65 @@ path: "authors" }
             of: { type: "string" } as Property
         } as unknown as Property;
 
+        const arrayOfNumbersProp: Property = {
+            type: "array",
+            of: { type: "number" } as Property
+        } as unknown as Property;
+
+        const arrayOfRelationsProp: Property = {
+            type: "array",
+            of: { type: "relation" } as Property
+        } as unknown as Property;
+
         it("should serialize array elements through their sub-property type", () => {
             expect(serializePropertyToServer(["a", "b", "c"], arrayOfStringsProp))
                 .toEqual(["a", "b", "c"]);
         });
 
-        it("should pass through non-array values", () => {
+        it("should coerce non-array values to empty array", () => {
             expect(serializePropertyToServer("not-an-array", arrayOfStringsProp))
-                .toBe("not-an-array");
+                .toEqual([]);
+        });
+
+        // --- Null safety ---
+        it("should return null for null array value", () => {
+            expect(serializePropertyToServer(null, arrayOfStringsProp)).toBeNull();
+        });
+
+        it("should return undefined for undefined array value", () => {
+            expect(serializePropertyToServer(undefined, arrayOfStringsProp)).toBeUndefined();
+        });
+
+        it("should return empty array for empty array value", () => {
+            expect(serializePropertyToServer([], arrayOfStringsProp)).toEqual([]);
+        });
+
+        it("should return null for null value with array-of-numbers property", () => {
+            expect(serializePropertyToServer(null, arrayOfNumbersProp)).toBeNull();
+        });
+
+        it("should handle array with null elements", () => {
+            const result = serializePropertyToServer([null, "a", null, "b"], arrayOfStringsProp);
+            expect(result).toEqual([null, "a", null, "b"]);
+        });
+
+        it("should handle array of relation objects with null entries", () => {
+            const value = [{ id: "1", path: "tags" }, null, { id: "2", path: "tags" }];
+            const result = serializePropertyToServer(value, arrayOfRelationsProp);
+            expect(result).toEqual(["1", null, "2"]);
+        });
+
+        it("should coerce number value to empty array for array property", () => {
+            expect(serializePropertyToServer(42, arrayOfStringsProp)).toEqual([]);
+        });
+
+        it("should coerce boolean value to empty array for array property", () => {
+            expect(serializePropertyToServer(true, arrayOfStringsProp)).toEqual([]);
+        });
+
+        it("should coerce object value to empty array for array property", () => {
+            const obj = { a: 1 };
+            expect(serializePropertyToServer(obj, arrayOfStringsProp)).toEqual([]);
         });
     });
 

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);
+        });
+    });
+});