@rebasepro/server-postgresql 0.1.2 → 0.2.1

package/test/data-transformer.test.ts

@@ -172,4 +172,47 @@ path: "authors" }
             expect(serializePropertyToServer(false, boolProp)).toBe(false);
         });
     });
+
+    // ── Vector property ──
+    describe("vector property", () => {
+        const vectorProp: Property = { type: "vector", dimensions: 3 } as Property;
+
+        it("should serialize a Vector instance to a flat array", () => {
+            const vectorVal = { __type: "Vector", value: [1.5, -2.0, 3.14] };
+            expect(serializePropertyToServer(vectorVal, vectorProp)).toEqual([1.5, -2.0, 3.14]);
+        });
+
+        it("should serialize a raw number array to a flat array", () => {
+            expect(serializePropertyToServer([0.5, 0.6, 0.7], vectorProp)).toEqual([0.5, 0.6, 0.7]);
+        });
+
+        it("should return null for null values", () => {
+            expect(serializePropertyToServer(null, vectorProp)).toBeNull();
+        });
+
+        it("should return undefined for undefined values", () => {
+            expect(serializePropertyToServer(undefined, vectorProp)).toBeUndefined();
+        });
+    });
+
+    // ── Binary property ──
+    describe("binary property", () => {
+        const binaryProp: Property = { type: "binary" } as Property;
+
+        it("should serialize a base64 data URL to a Buffer", () => {
+            const base64Data = "data:application/octet-stream;base64,aGVsbG8=";
+            const result = serializePropertyToServer(base64Data, binaryProp);
+            expect(Buffer.isBuffer(result)).toBe(true);
+            expect((result as Buffer).toString("utf8")).toBe("hello");
+        });
+
+        it("should pass through a Buffer as-is", () => {
+            const buffer = Buffer.from("world");
+            expect(serializePropertyToServer(buffer, binaryProp)).toBe(buffer);
+        });
+
+        it("should return null for null values", () => {
+            expect(serializePropertyToServer(null, binaryProp)).toBeNull();
+        });
+    });
 });

package/test/generate-drizzle-schema.test.ts

@@ -116,6 +116,8 @@ relationName: "tags" }
         expect(cleanResult).toContain("tag_id: varchar(\"tag_id\").notNull().references(() => tags.id, { onDelete: \"cascade\" })");
         expect(cleanResult).toContain("(table) => ({ pk: primaryKey({ columns: [table.post_id, table.tag_id] }) })");
         expect(cleanResult).toContain("export const postsRelations = drizzleRelations(posts, ({ one, many }) => ({ \"tags\": many(postsToTags, { relationName: \"tags\" }) }));");
+        const expectedJunctionRelations = "export const postsToTagsRelations = drizzleRelations(postsToTags, ({ one, many }) => ({ \"post_id\": one(posts, { fields: [postsToTags.post_id], references: [posts.id], relationName: \"tags\" }), \"tag_id\": one(tags, { fields: [postsToTags.tag_id], references: [tags.id], relationName: \"posts_to_tags_tag_id\" }) }));";
+        expect(cleanResult).toContain(cleanSchema(expectedJunctionRelations));
     });
 
     describe("generateDrizzleSchema Column Types", () => {
@@ -391,7 +393,7 @@ ownerField: "user_id" }
             expect(result).toContain("pgPolicy");
             expect(result).toContain('as: "permissive"');
             expect(result).toContain('for: "all"');
-            expect(result).toContain("${table.user_id} = auth.uid()");
+            expect(result).toContain("user_id = auth.uid()");
             // 'all' needs both using and withCheck
             expect(result).toContain("using:");
             expect(result).toContain("withCheck:");
@@ -565,7 +567,7 @@ using: "{is_locked} = false" }
 
             const result = await generateSchema(collections);
             expect(result).toContain('as: "restrictive"');
-            expect(result).toContain("${table.is_locked} = false");
+            expect(result).toContain("is_locked = false");
         });
 
         it("should generate raw SQL using clause with column references", async () => {
@@ -584,7 +586,7 @@ using: "{published_at} > now() - interval '30 days'" }
             }];
 
             const result = await generateSchema(collections);
-            expect(result).toContain("${table.published_at} > now() - interval '30 days'");
+            expect(result).toContain("published_at > now() - interval '30 days'");
         });
 
         it("should generate raw SQL withCheck clause", async () => {
@@ -609,8 +611,8 @@ using: "{published_at} > now() - interval '30 days'" }
             const result = await generateSchema(collections);
             expect(result).toContain("using:");
             expect(result).toContain("withCheck:");
-            expect(result).toContain("${table.user_id} = auth.uid()");
-            expect(result).toContain("${table.status} != 'archived'");
+            expect(result).toContain("user_id = auth.uid()");
+            expect(result).toContain("status != 'archived'");
         });
 
         it("should use custom policy names when provided", async () => {

package/test/introspect-db-utils.test.ts

@@ -200,10 +200,13 @@ describe("mapPgType", () => {
         expect(mapPgType("_text")).toBe("array");
     });
     it("maps string-like types to string", () => {
-        for (const t of ["text", "varchar", "character varying", "char", "character", "uuid", "bytea", "inet", "cidr", "macaddr", "macaddr8", "interval"]) {
+        for (const t of ["text", "varchar", "character varying", "char", "character", "uuid", "inet", "cidr", "macaddr", "macaddr8", "interval"]) {
             expect(mapPgType(t)).toBe("string");
         }
     });
+    it("maps bytea to binary", () => {
+        expect(mapPgType("bytea")).toBe("binary");
+    });
     it("defaults unknown types to string", () => {
         expect(mapPgType("tsvector")).toBe("string");
         expect(mapPgType("xml")).toBe("string");

package/test/postgresDataDriver.test.ts

@@ -644,5 +644,22 @@ 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();
+        });
+    });
 });
 

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