@rebasepro/server-postgresql 0.1.2 → 0.2.3

package/test/postgresDataDriver.test.ts

@@ -35,7 +35,12 @@ describe("PostgresBackendDriver", () => {
 
     beforeEach(() => {
         jest.clearAllMocks();
-        delegate = new PostgresBackendDriver(mockDb, mockRealtimeService);
+        const mockRegistry = {
+            getCollectionByPath: jest.fn().mockReturnValue({ slug: "test_coll", properties: {} }),
+            getCollections: jest.fn().mockReturnValue([]),
+            getTable: jest.fn().mockReturnValue({})
+        } as any;
+        delegate = new PostgresBackendDriver(mockDb, mockRealtimeService, mockRegistry);
     });
 
     it("should initialize correctly", () => {
@@ -644,5 +649,146 @@ status: "new" });
             expect(mockRealtimeService.notifyEntityUpdate).toHaveBeenNthCalledWith(2, "call-2", "2", {}, undefined);
         });
     });
+
+    describe("PostgresBackendDriver Admin operations", () => {
+        it("fetchAvailableRoles should query roles filtered by current user membership", async () => {
+            const executeSqlSpy = jest.spyOn(delegate, "executeSql").mockResolvedValueOnce([
+                { rolname: "demo" },
+                { rolname: "cloudsqlsuperuser" }
+            ]);
+
+            const result = await delegate.fetchAvailableRoles();
+
+            expect(executeSqlSpy).toHaveBeenCalledWith(
+                "SELECT rolname FROM pg_roles WHERE pg_has_role(current_user, rolname, 'member') ORDER BY rolname;"
+            );
+            expect(result).toEqual(["demo", "cloudsqlsuperuser"]);
+            executeSqlSpy.mockRestore();
+        });
+    });
+
+    describe("storageSource in Callbacks", () => {
+        it("should inject storageSource: client.storage into contextForCallback in fetchCollection", async () => {
+            const mockStorage = { key: "mockStorage" };
+            delegate.client = {
+                storage: mockStorage
+            } as any;
+
+            const afterReadSpy = jest.fn().mockImplementation(async ({ entity }) => entity);
+            const mockCollectionWithCallback = {
+                slug: "test_coll",
+                callbacks: {
+                    afterRead: afterReadSpy
+                }
+            } as any;
+
+            jest.spyOn(delegate.entityService, "fetchCollection").mockResolvedValueOnce([
+                { id: "e1", path: "test_coll", values: {} } as any
+            ]);
+
+            await delegate.fetchCollection({
+                path: "test_coll",
+                collection: mockCollectionWithCallback
+            });
+
+            expect(afterReadSpy).toHaveBeenCalled();
+            const callArgs = afterReadSpy.mock.calls[0][0];
+            expect(callArgs.context).toBeDefined();
+            expect(callArgs.context.storageSource).toBe(mockStorage);
+        });
+
+        it("should inject storageSource in fetchEntity", async () => {
+            const mockStorage = { key: "mockStorage" };
+            delegate.client = {
+                storage: mockStorage
+            } as any;
+
+            const afterReadSpy = jest.fn().mockImplementation(async ({ entity }) => entity);
+            const mockCollectionWithCallback = {
+                slug: "test_coll",
+                callbacks: {
+                    afterRead: afterReadSpy
+                }
+            } as any;
+
+            jest.spyOn(delegate.entityService, "fetchEntity").mockResolvedValueOnce(
+                { id: "e1", path: "test_coll", values: {} } as any
+            );
+
+            await delegate.fetchEntity({
+                path: "test_coll",
+                entityId: "e1",
+                collection: mockCollectionWithCallback
+            });
+
+            expect(afterReadSpy).toHaveBeenCalled();
+            const callArgs = afterReadSpy.mock.calls[0][0];
+            expect(callArgs.context.storageSource).toBe(mockStorage);
+        });
+
+        it("should inject storageSource in saveEntity beforeSave and afterSave", async () => {
+            const mockStorage = { key: "mockStorage" };
+            delegate.client = {
+                storage: mockStorage
+            } as any;
+
+            const beforeSaveSpy = jest.fn().mockImplementation(async ({ values }) => values);
+            const afterSaveSpy = jest.fn();
+            const mockCollectionWithCallback = {
+                slug: "test_coll",
+                callbacks: {
+                    beforeSave: beforeSaveSpy,
+                    afterSave: afterSaveSpy
+                }
+            } as any;
+
+            jest.spyOn(delegate.entityService, "fetchEntity").mockResolvedValue(undefined);
+            jest.spyOn(delegate.entityService, "saveEntity").mockResolvedValueOnce(
+                { id: "e1", path: "test_coll", values: { name: "test" } } as any
+            );
+
+            await delegate.saveEntity({
+                path: "test_coll",
+                entityId: "e1",
+                values: { name: "test" },
+                collection: mockCollectionWithCallback,
+                status: "existing"
+            });
+
+            expect(beforeSaveSpy).toHaveBeenCalled();
+            expect(beforeSaveSpy.mock.calls[0][0].context.storageSource).toBe(mockStorage);
+            expect(afterSaveSpy).toHaveBeenCalled();
+            expect(afterSaveSpy.mock.calls[0][0].context.storageSource).toBe(mockStorage);
+        });
+
+        it("should inject storageSource in deleteEntity beforeDelete and afterDelete", async () => {
+            const mockStorage = { key: "mockStorage" };
+            delegate.client = {
+                storage: mockStorage
+            } as any;
+
+            const beforeDeleteSpy = jest.fn().mockImplementation(async () => true);
+            const afterDeleteSpy = jest.fn();
+            const mockCollectionWithCallback = {
+                slug: "test_coll",
+                callbacks: {
+                    beforeDelete: beforeDeleteSpy,
+                    afterDelete: afterDeleteSpy
+                }
+            } as any;
+
+            jest.spyOn(delegate.entityService, "deleteEntity").mockResolvedValueOnce();
+
+            await delegate.deleteEntity({
+                entity: { id: "e1", path: "test_coll", values: {} } as any,
+                collection: mockCollectionWithCallback
+            });
+
+            expect(beforeDeleteSpy).toHaveBeenCalled();
+            expect(beforeDeleteSpy.mock.calls[0][0].context.storageSource).toBe(mockStorage);
+            expect(afterDeleteSpy).toHaveBeenCalled();
+            expect(afterDeleteSpy.mock.calls[0][0].context.storageSource).toBe(mockStorage);
+        });
+    });
 });
 

package/test/realtimeService.test.ts

@@ -3,12 +3,13 @@ import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { PostgresCollectionRegistry } from "../src/collections/PostgresCollectionRegistry";
 import { EntityCollection } from "@rebasepro/types";
 
+const mockFetchCollection = jest.fn().mockResolvedValue([{ id: 1, path: "posts", values: { title: "Refetched Title" } }]);
+const mockFetchEntity = jest.fn().mockResolvedValue({ id: 1, path: "posts", values: { title: "Refetched Entity Title" } });
+
 jest.mock("../src/services/entityService", () => ({
     EntityService: jest.fn().mockImplementation(() => ({
-        fetchCollection: jest.fn().mockResolvedValue([{ id: 1,
-_rebase_invalidated: false }]),
-        fetchEntity: jest.fn().mockResolvedValue({ id: 1,
-_rebase_invalidated: false }),
+        fetchCollection: mockFetchCollection,
+        fetchEntity: mockFetchEntity,
         searchEntities: jest.fn().mockResolvedValue([])
     }))
 }));
@@ -134,7 +135,7 @@ values: { _rebase_invalidated: true } } as any;
             await Promise.resolve();
 
             // It should fetch the collection with auth
-            expect(mockDriver.fetchCollection).toHaveBeenCalled();
+            expect(mockFetchCollection).toHaveBeenCalled();
 
             // It should send the refetched data
             expect(ws.send).toHaveBeenCalled();
@@ -207,8 +208,7 @@ values: { _rebase_invalidated: true } } as any;
             await Promise.resolve();
 
             // It should fetch the single entity
-            expect(mockDriver.fetchEntity).toHaveBeenCalledWith(expect.objectContaining({ path: "posts",
-entityId: "1" }));
+            expect(mockFetchEntity).toHaveBeenCalledWith("posts", "1", undefined);
 
             // It should send entity update
             expect(ws.send).toHaveBeenCalled();

package/test/websocket.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, jest, beforeEach } from "@jest/globals";
+import { WebSocket, WebSocketServer } from "ws";
+import { Server } from "http";
+
+let mockWssInstance: any = null;
+
+jest.mock("ws", () => {
+    return {
+        WebSocketServer: jest.fn().mockImplementation(() => {
+            const instance = {
+                on: jest.fn()
+            };
+            mockWssInstance = instance;
+            return instance;
+        }),
+        WebSocket: jest.fn()
+    };
+});
+
+jest.mock("@rebasepro/server-core", () => {
+    return {
+        extractUserFromToken: jest.fn().mockReturnValue({
+            userId: "admin-user",
+            roles: ["admin"]
+        })
+    };
+});
+
+import { createPostgresWebSocket } from "../src/websocket";
+import { RealtimeService } from "../src/services/realtimeService";
+import { PostgresBackendDriver } from "../src/PostgresBackendDriver";
+
+describe("WebSocket Server SQL error handling", () => {
+    let mockServer: Server;
+    let mockRealtimeService: RealtimeService;
+    let mockDriver: PostgresBackendDriver;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockWssInstance = null;
+
+        mockServer = {} as Server;
+        mockRealtimeService = {
+            addClient: jest.fn(),
+            registerDataDriverSubscription: jest.fn()
+        } as unknown as RealtimeService;
+
+        // Mock PostgresBackendDriver admin capabilities
+        mockDriver = {
+            key: "postgres",
+            initialised: true,
+            admin: {
+                executeSql: jest.fn()
+            }
+        } as unknown as PostgresBackendDriver;
+
+        // Trigger the wss initialization with requireAuth: true
+        createPostgresWebSocket(mockServer, mockRealtimeService, mockDriver, { requireAuth: true });
+    });
+
+    it("should handle EXECUTE_SQL errors cleanly and return ERROR message without throwing", async () => {
+        expect(mockWssInstance).toBeDefined();
+        expect(mockWssInstance.on).toHaveBeenCalledWith("connection", expect.any(Function));
+        
+        const connectionCallback = mockWssInstance.on.mock.calls.find(
+            (call: any[]) => call[0] === "connection"
+        )[1];
+
+        // Simulate client connection
+        const mockWs = {
+            on: jest.fn(),
+            send: jest.fn()
+        } as unknown as any;
+
+        connectionCallback(mockWs);
+
+        // Retrieve the message callback
+        expect(mockWs.on).toHaveBeenCalledWith("message", expect.any(Function));
+        const messageCallback = mockWs.on.mock.calls.find(
+            (call: any[]) => call[0] === "message"
+        )[1];
+
+        // 1. Authenticate first as an admin
+        await messageCallback(
+            Buffer.from(
+                JSON.stringify({
+                    type: "AUTHENTICATE",
+                    requestId: "auth-req",
+                    payload: {
+                        token: "mock-admin-token"
+                    }
+                })
+            )
+        );
+
+        expect(mockWs.send).toHaveBeenCalled();
+        const authResponse = JSON.parse(mockWs.send.mock.calls[0][0]);
+        expect(authResponse.type).toBe("AUTH_SUCCESS");
+
+        // Clear mock send calls before executing SQL
+        mockWs.send.mockClear();
+
+        // Mock executeSql to throw a permission denied error
+        (mockDriver.admin.executeSql as jest.Mock).mockRejectedValueOnce(
+            new Error("permission denied for table orders")
+        );
+
+        // 2. Simulate receiving EXECUTE_SQL message
+        await messageCallback(
+            Buffer.from(
+                JSON.stringify({
+                    type: "EXECUTE_SQL",
+                    requestId: "req-1",
+                    payload: {
+                        sql: "SELECT * FROM orders",
+                        options: { role: "demo" }
+                    }
+                })
+            )
+        );
+
+        // Verify executeSql was called
+        expect(mockDriver.admin.executeSql).toHaveBeenCalledWith("SELECT * FROM orders", { role: "demo" });
+
+        // Verify the client received a clean ERROR payload rather than crashing the socket
+        expect(mockWs.send).toHaveBeenCalled();
+        const sentMessage = JSON.parse(mockWs.send.mock.calls[0][0]);
+        expect(sentMessage).toEqual({
+            type: "ERROR",
+            requestId: "req-1",
+            payload: {
+                error: {
+                    message: "permission denied for table orders",
+                    code: "SQL_ERROR"
+                }
+            }
+        });
+    });
+});