@rebasepro/server-postgresql 0.4.0 → 0.6.0

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

@@ -2,7 +2,7 @@ import {
     singularize, humanize, toCollectionVarName, getIconForTable,
     mapPgType, buildEnumMap, buildTablesMap, identifyJoinTables,
     generateIndexContent, mergeIndexContent, safeHostFromUrl,
-    EnumValue, TableRow, TableColumn, PrimaryKeyRow, ForeignKeyRow,
+    EnumValue, TableRow, TableColumn, PrimaryKeyRow, ForeignKeyRow
 } from "../src/schema/introspect-db-logic";
 
 // ═══════════════════════════════════════════════════════════════════════
@@ -148,7 +148,7 @@ describe("getIconForTable", () => {
         ["notifications", "Mail"], ["messages", "Mail"], ["emails", "Mail"],
         ["audit_log", "Activity"], ["events", "Activity"],
         ["subscriptions", "CreditCard"], ["plans", "CreditCard"], ["billing", "CreditCard"],
-        ["comments", "MessageCircle"], ["reviews", "MessageCircle"], ["feedback", "MessageCircle"],
+        ["comments", "MessageCircle"], ["reviews", "MessageCircle"], ["feedback", "MessageCircle"]
     ];
 
     it.each(cases)("returns %s -> %s", (table, icon) => {
@@ -219,10 +219,18 @@ describe("mapPgType", () => {
 describe("buildEnumMap", () => {
     it("groups enum values by name in order", () => {
         const vals: EnumValue[] = [
-            { enum_name: "status", enum_value: "active", sort_order: 1 },
-            { enum_name: "status", enum_value: "inactive", sort_order: 2 },
-            { enum_name: "role", enum_value: "admin", sort_order: 1 },
-            { enum_name: "role", enum_value: "user", sort_order: 2 },
+            { enum_name: "status",
+enum_value: "active",
+sort_order: 1 },
+            { enum_name: "status",
+enum_value: "inactive",
+sort_order: 2 },
+            { enum_name: "role",
+enum_value: "admin",
+sort_order: 1 },
+            { enum_name: "role",
+enum_value: "user",
+sort_order: 2 }
         ];
         const map = buildEnumMap(vals);
         expect(map.get("status")).toEqual(["active", "inactive"]);
@@ -232,7 +240,9 @@ describe("buildEnumMap", () => {
         expect(buildEnumMap([]).size).toBe(0);
     });
     it("handles single-value enums", () => {
-        const map = buildEnumMap([{ enum_name: "flag", enum_value: "yes", sort_order: 1 }]);
+        const map = buildEnumMap([{ enum_name: "flag",
+enum_value: "yes",
+sort_order: 1 }]);
         expect(map.get("flag")).toEqual(["yes"]);
     });
 });
@@ -244,16 +254,36 @@ describe("buildTablesMap", () => {
     it("groups columns, pks and fks by table", () => {
         const tables: TableRow[] = [{ table_name: "users" }, { table_name: "posts" }];
         const cols: TableColumn[] = [
-            { table_name: "users", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO", column_default: null },
-            { table_name: "posts", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO", column_default: null },
-            { table_name: "posts", column_name: "user_id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO", column_default: null },
+            { table_name: "users",
+column_name: "id",
+data_type: "uuid",
+udt_name: "uuid",
+is_nullable: "NO",
+column_default: null },
+            { table_name: "posts",
+column_name: "id",
+data_type: "uuid",
+udt_name: "uuid",
+is_nullable: "NO",
+column_default: null },
+            { table_name: "posts",
+column_name: "user_id",
+data_type: "uuid",
+udt_name: "uuid",
+is_nullable: "NO",
+column_default: null }
         ];
         const pks: PrimaryKeyRow[] = [
-            { table_name: "users", column_name: "id" },
-            { table_name: "posts", column_name: "id" },
+            { table_name: "users",
+column_name: "id" },
+            { table_name: "posts",
+column_name: "id" }
         ];
         const fks: ForeignKeyRow[] = [
-            { table_name: "posts", column_name: "user_id", foreign_table_name: "users", foreign_column_name: "id" },
+            { table_name: "posts",
+column_name: "user_id",
+foreign_table_name: "users",
+foreign_column_name: "id" }
         ];
         const map = buildTablesMap(tables, cols, pks, fks);
         expect(map.size).toBe(2);
@@ -268,8 +298,12 @@ describe("buildTablesMap", () => {
 // ═══════════════════════════════════════════════════════════════════════
 describe("identifyJoinTables", () => {
     const mkCol = (table: string, col: string): TableColumn => ({
-        table_name: table, column_name: col, data_type: "uuid",
-        udt_name: "uuid", is_nullable: "NO", column_default: null,
+        table_name: table,
+column_name: col,
+data_type: "uuid",
+        udt_name: "uuid",
+is_nullable: "NO",
+column_default: null
     });
 
     it("detects a pure junction table with exactly 2 FKs", () => {
@@ -279,10 +313,16 @@ describe("identifyJoinTables", () => {
                 columns: [mkCol("posts_to_tags", "post_id"), mkCol("posts_to_tags", "tag_id")],
                 pks: [],
                 fks: [
-                    { table_name: "posts_to_tags", column_name: "post_id", foreign_table_name: "posts", foreign_column_name: "id" },
-                    { table_name: "posts_to_tags", column_name: "tag_id", foreign_table_name: "tags", foreign_column_name: "id" },
-                ],
-            }],
+                    { table_name: "posts_to_tags",
+column_name: "post_id",
+foreign_table_name: "posts",
+foreign_column_name: "id" },
+                    { table_name: "posts_to_tags",
+column_name: "tag_id",
+foreign_table_name: "tags",
+foreign_column_name: "id" }
+                ]
+            }]
         ]);
         expect(identifyJoinTables(tablesMap)).toEqual(new Set(["posts_to_tags"]));
     });
@@ -295,14 +335,20 @@ describe("identifyJoinTables", () => {
                     mkCol("posts_tags", "id"),
                     mkCol("posts_tags", "post_id"),
                     mkCol("posts_tags", "tag_id"),
-                    mkCol("posts_tags", "created_at"),
+                    mkCol("posts_tags", "created_at")
                 ],
                 pks: ["id"],
                 fks: [
-                    { table_name: "posts_tags", column_name: "post_id", foreign_table_name: "posts", foreign_column_name: "id" },
-                    { table_name: "posts_tags", column_name: "tag_id", foreign_table_name: "tags", foreign_column_name: "id" },
-                ],
-            }],
+                    { table_name: "posts_tags",
+column_name: "post_id",
+foreign_table_name: "posts",
+foreign_column_name: "id" },
+                    { table_name: "posts_tags",
+column_name: "tag_id",
+foreign_table_name: "tags",
+foreign_column_name: "id" }
+                ]
+            }]
         ]);
         expect(identifyJoinTables(tablesMap).has("posts_tags")).toBe(true);
     });
@@ -314,14 +360,20 @@ describe("identifyJoinTables", () => {
                 columns: [
                     mkCol("enrollments", "student_id"),
                     mkCol("enrollments", "course_id"),
-                    mkCol("enrollments", "grade"), // extra column
+                    mkCol("enrollments", "grade") // extra column
                 ],
                 pks: [],
                 fks: [
-                    { table_name: "enrollments", column_name: "student_id", foreign_table_name: "students", foreign_column_name: "id" },
-                    { table_name: "enrollments", column_name: "course_id", foreign_table_name: "courses", foreign_column_name: "id" },
-                ],
-            }],
+                    { table_name: "enrollments",
+column_name: "student_id",
+foreign_table_name: "students",
+foreign_column_name: "id" },
+                    { table_name: "enrollments",
+column_name: "course_id",
+foreign_table_name: "courses",
+foreign_column_name: "id" }
+                ]
+            }]
         ]);
         expect(identifyJoinTables(tablesMap).size).toBe(0);
     });
@@ -333,9 +385,12 @@ describe("identifyJoinTables", () => {
                 columns: [mkCol("posts", "id"), mkCol("posts", "user_id")],
                 pks: ["id"],
                 fks: [
-                    { table_name: "posts", column_name: "user_id", foreign_table_name: "users", foreign_column_name: "id" },
-                ],
-            }],
+                    { table_name: "posts",
+column_name: "user_id",
+foreign_table_name: "users",
+foreign_column_name: "id" }
+                ]
+            }]
         ]);
         expect(identifyJoinTables(tablesMap).size).toBe(0);
     });
@@ -356,9 +411,9 @@ describe("generateIndexContent", () => {
     it("generates import statements and collections array", () => {
         const result = generateIndexContent(["users"]);
         expect(result).toContain('import usersCollection from "./users";');
-        expect(result).toContain('export const collections = [');
-        expect(result).toContain('    usersCollection,');
-        expect(result).toContain('];');
+        expect(result).toContain("export const collections = [");
+        expect(result).toContain("    usersCollection,");
+        expect(result).toContain("];");
     });
 });
 
@@ -371,8 +426,8 @@ describe("mergeIndexContent", () => {
         const result = mergeIndexContent(existing, ["users", "posts"]);
         expect(result.match(/import usersCollection from ".\/users";/g)!.length).toBe(1);
         expect(result).toContain('import postsCollection from "./posts";');
-        expect(result).toContain('usersCollection,');
-        expect(result).toContain('postsCollection,');
+        expect(result).toContain("usersCollection,");
+        expect(result).toContain("postsCollection,");
     });
 
     it("returns existing content trimmed + newline when no new files", () => {

package/test/mocks/chalk.cjs

@@ -0,0 +1,7 @@
+const mockChalk = new Proxy((x) => x, {
+  get: (target, prop) => {
+    if (prop === "default") return mockChalk;
+    return mockChalk;
+  }
+});
+module.exports = mockChalk;

package/test/pg-error-utils.test.ts

@@ -0,0 +1,221 @@
+import { describe, it, expect } from "@jest/globals";
+import { extractPgError, extractCauseMessage, pgErrorToFriendlyMessage, sanitizeErrorForClient } from "../src/utils/pg-error-utils";
+
+// Suppress logger output during tests
+jest.mock("@rebasepro/server-core", () => ({
+    logger: {
+        error: jest.fn(),
+        warn: jest.fn(),
+        info: jest.fn(),
+        debug: jest.fn()
+    }
+}));
+
+describe("pg-error-utils", () => {
+
+    describe("extractPgError", () => {
+        it("returns null for non-object values", () => {
+            expect(extractPgError(null)).toBeNull();
+            expect(extractPgError(undefined)).toBeNull();
+            expect(extractPgError("string error")).toBeNull();
+            expect(extractPgError(42)).toBeNull();
+        });
+
+        it("returns null for plain Error without PG code", () => {
+            expect(extractPgError(new Error("some error"))).toBeNull();
+        });
+
+        it("extracts PG error directly when error has a 5-char alphanumeric code", () => {
+            const pgError = Object.assign(new Error("relation \"clients\" does not exist"), {
+                code: "42P01",
+                table: "clients"
+            });
+            const result = extractPgError(pgError);
+            expect(result).toBe(pgError);
+            expect(result?.code).toBe("42P01");
+        });
+
+        it("extracts PG error from Drizzle cause chain", () => {
+            const pgError = Object.assign(new Error("relation \"clients\" does not exist"), {
+                code: "42P01",
+                table: "clients"
+            });
+            const drizzleError = new Error("Failed query: select ...");
+            (drizzleError as any).cause = pgError;
+
+            const result = extractPgError(drizzleError);
+            expect(result).toBe(pgError);
+            expect(result?.code).toBe("42P01");
+        });
+
+        it("extracts PG error from deeply nested cause chain", () => {
+            const pgError = Object.assign(new Error("column \"foo\" does not exist"), {
+                code: "42703",
+                column: "foo"
+            });
+            const mid = new Error("mid-level wrapper");
+            (mid as any).cause = pgError;
+            const outer = new Error("Failed query: select ...");
+            (outer as any).cause = mid;
+
+            const result = extractPgError(outer);
+            expect(result).toBe(pgError);
+        });
+
+        it("ignores non-PG error codes (not 5-char alphanumeric)", () => {
+            const error = Object.assign(new Error("some error"), { code: "ERR_SOMETHING" });
+            expect(extractPgError(error)).toBeNull();
+        });
+
+        it("handles non-Error objects with cause chain", () => {
+            const pgError = Object.assign(new Error("relation does not exist"), {
+                code: "42P01"
+            });
+            const wrapper = { cause: pgError };
+            expect(extractPgError(wrapper)).toBe(pgError);
+        });
+    });
+
+    describe("extractCauseMessage", () => {
+        it("returns null for non-Error values", () => {
+            expect(extractCauseMessage(null)).toBeNull();
+            expect(extractCauseMessage("string")).toBeNull();
+            expect(extractCauseMessage({})).toBeNull();
+        });
+
+        it("returns null for Error without cause", () => {
+            expect(extractCauseMessage(new Error("top level"))).toBeNull();
+        });
+
+        it("extracts cause message from single-level cause", () => {
+            const inner = new Error("inner message");
+            const outer = new Error("outer");
+            (outer as any).cause = inner;
+            expect(extractCauseMessage(outer)).toBe("inner message");
+        });
+
+        it("extracts deepest cause message", () => {
+            const deepest = new Error("deepest");
+            const mid = new Error("mid");
+            (mid as any).cause = deepest;
+            const outer = new Error("outer");
+            (outer as any).cause = mid;
+            expect(extractCauseMessage(outer)).toBe("deepest");
+        });
+    });
+
+    describe("pgErrorToFriendlyMessage", () => {
+        it("maps 42P01 (undefined_table) to a friendly message", () => {
+            const pgError = Object.assign(new Error("relation \"clients\" does not exist"), {
+                code: "42P01",
+                table: "clients"
+            });
+            const result = pgErrorToFriendlyMessage(pgError as any, "clients");
+            expect(result.code).toBe("42P01");
+            expect(result.message).toContain("Table not found");
+            expect(result.message).toContain("run migrations");
+        });
+
+        it("maps 42703 (undefined_column) to a friendly message", () => {
+            const pgError = Object.assign(new Error("column \"foo\" of relation \"clients\" does not exist"), {
+                code: "42703",
+                column: "foo",
+                table: "clients"
+            });
+            const result = pgErrorToFriendlyMessage(pgError as any, "clients");
+            expect(result.code).toBe("42703");
+            expect(result.message).toContain("Unknown column");
+            expect(result.message).toContain("run migrations");
+        });
+
+        it("maps 23505 (unique_violation) with detail", () => {
+            const pgError = Object.assign(new Error("duplicate key value"), {
+                code: "23505",
+                detail: "Key (email)=(test@test.com) already exists.",
+                constraint: "clients_email_unique"
+            });
+            const result = pgErrorToFriendlyMessage(pgError as any, "clients");
+            expect(result.code).toBe("23505");
+            expect(result.message).toContain("Duplicate value");
+            expect(result.message).toContain("already exists");
+        });
+
+        it("maps 42501 (insufficient_privilege) to permission denied", () => {
+            const pgError = Object.assign(new Error("permission denied for table clients"), {
+                code: "42501",
+                table: "clients"
+            });
+            const result = pgErrorToFriendlyMessage(pgError as any, "clients");
+            expect(result.code).toBe("42501");
+            expect(result.message).toContain("Permission denied");
+            expect(result.message).toContain("RLS policies");
+        });
+
+        it("includes hint when present", () => {
+            const pgError = Object.assign(new Error("relation does not exist"), {
+                code: "42P01",
+                hint: "Perhaps you meant \"client\"?"
+            });
+            const result = pgErrorToFriendlyMessage(pgError as any, "clients");
+            expect(result.message).toContain("Hint: Perhaps you meant");
+        });
+
+        it("handles unknown PG codes with full diagnostic info", () => {
+            const pgError = Object.assign(new Error("something unusual"), {
+                code: "XX000",
+                detail: "internal detail",
+                column: "col",
+                constraint: "some_constraint"
+            });
+            const result = pgErrorToFriendlyMessage(pgError as any, "my_collection");
+            expect(result.code).toBe("XX000");
+            expect(result.message).toContain("[XX000]");
+            expect(result.message).toContain("something unusual");
+            expect(result.message).toContain("internal detail");
+        });
+    });
+
+    describe("sanitizeErrorForClient", () => {
+        it("sanitizes a Drizzle-wrapped PG error", () => {
+            const pgError = Object.assign(new Error("relation \"clients\" does not exist"), {
+                code: "42P01"
+            });
+            const drizzleError = new Error(
+                'Failed query: select "id", "name" from "clients" where "clients"."id" = $1 limit $2\nparams: some-uuid,1'
+            );
+            (drizzleError as any).cause = pgError;
+
+            const result = sanitizeErrorForClient(drizzleError, "clients");
+            expect(result.code).toBe("42P01");
+            expect(result.message).toContain("Table not found");
+            // Must NOT contain the raw SQL
+            expect(result.message).not.toContain("select");
+            expect(result.message).not.toContain("params:");
+        });
+
+        it("returns generic message when no PG error is found", () => {
+            const error = new Error("something went wrong");
+            const result = sanitizeErrorForClient(error, "clients");
+            expect(result.message).toContain("clients");
+            expect(result.code).toBeUndefined();
+        });
+
+        it("uses cause message when available and no PG error", () => {
+            const inner = new Error("connection refused");
+            const outer = new Error("outer wrapper");
+            (outer as any).cause = inner;
+            const result = sanitizeErrorForClient(outer, "clients");
+            expect(result.message).toContain("connection refused");
+        });
+
+        it("never leaks SQL in the returned message", () => {
+            const error = new Error(
+                'Failed query: select "id", "name", "email" from "clients" where "clients"."id" = $1'
+            );
+            const result = sanitizeErrorForClient(error, "clients");
+            expect(result.message).not.toContain("select");
+            expect(result.message).not.toContain("Failed query");
+            expect(result.message).toContain("Check server logs");
+        });
+    });
+});

package/test/postgresDataDriver.test.ts

@@ -36,7 +36,8 @@ describe("PostgresBackendDriver", () => {
     beforeEach(() => {
         jest.clearAllMocks();
         const mockRegistry = {
-            getCollectionByPath: jest.fn().mockReturnValue({ slug: "test_coll", properties: {} }),
+            getCollectionByPath: jest.fn().mockReturnValue({ slug: "test_coll",
+properties: {} }),
             getCollections: jest.fn().mockReturnValue([]),
             getTable: jest.fn().mockReturnValue({})
         } as any;
@@ -683,7 +684,9 @@ status: "new" });
             } as any;
 
             jest.spyOn(delegate.entityService, "fetchCollection").mockResolvedValueOnce([
-                { id: "e1", path: "test_coll", values: {} } as any
+                { id: "e1",
+path: "test_coll",
+values: {} } as any
             ]);
 
             await delegate.fetchCollection({
@@ -712,7 +715,9 @@ status: "new" });
             } as any;
 
             jest.spyOn(delegate.entityService, "fetchEntity").mockResolvedValueOnce(
-                { id: "e1", path: "test_coll", values: {} } as any
+                { id: "e1",
+path: "test_coll",
+values: {} } as any
             );
 
             await delegate.fetchEntity({
@@ -744,7 +749,9 @@ status: "new" });
 
             jest.spyOn(delegate.entityService, "fetchEntity").mockResolvedValue(undefined);
             jest.spyOn(delegate.entityService, "saveEntity").mockResolvedValueOnce(
-                { id: "e1", path: "test_coll", values: { name: "test" } } as any
+                { id: "e1",
+path: "test_coll",
+values: { name: "test" } } as any
             );
 
             await delegate.saveEntity({
@@ -780,7 +787,9 @@ status: "new" });
             jest.spyOn(delegate.entityService, "deleteEntity").mockResolvedValueOnce();
 
             await delegate.deleteEntity({
-                entity: { id: "e1", path: "test_coll", values: {} } as any,
+                entity: { id: "e1",
+path: "test_coll",
+values: {} } as any,
                 collection: mockCollectionWithCallback
             });