@rebasepro/server-postgresql 0.0.1-canary.892f711 → 0.0.1-canary.a6becfb

package/src/services/EntityPersistService.ts

@@ -298,51 +298,127 @@ export class EntityPersistService {
 
         if (pgError) {
             const detail = pgError.detail as string | undefined;
+            const hint = pgError.hint as string | undefined;
             const constraint = pgError.constraint as string | undefined;
             const column = pgError.column as string | undefined;
             const table = pgError.table as string | undefined;
+            const dataType = pgError.dataType as string | undefined;
+            const pgMessage = pgError.message || "Unknown database error";
+
+            const suffix = hint ? ` Hint: ${hint}` : "";
+            const tableRef = table ?? collectionSlug;
 
             switch (pgError.code) {
                 case "23503": // foreign_key_violation
                     return new Error(
                         detail
-                            ? `Foreign key constraint violated: ${detail}`
-                            : `Cannot save: a foreign key constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".`
+                            ? `Foreign key constraint violated: ${detail}${suffix}`
+                            : `Cannot save: a foreign key constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".${suffix}`
                     );
                 case "23505": // unique_violation
                     return new Error(
                         detail
-                            ? `Duplicate value: ${detail}`
-                            : `Cannot save: a unique constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".`
+                            ? `Duplicate value: ${detail}${suffix}`
+                            : `Cannot save: a unique constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".${suffix}`
                     );
                 case "23502": // not_null_violation
                     return new Error(
-                        `Missing required field: "${column ?? "unknown"}" in "${table ?? collectionSlug}" cannot be empty.`
+                        `Missing required field: "${column ?? "unknown"}" in "${tableRef}" cannot be empty.${suffix}`
                     );
                 case "23514": // check_violation
                     return new Error(
-                        `Validation failed: a check constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".`
+                        `Validation failed: a check constraint${constraint ? ` (${constraint})` : ""} was violated in "${collectionSlug}".${suffix}`
+                    );
+                case "22P02": // invalid_text_representation (e.g. invalid UUID, wrong enum value)
+                    return new Error(
+                        `Invalid data format in "${collectionSlug}": ${pgMessage}${suffix}`
+                    );
+                case "22001": // string_data_right_truncation (value too long)
+                    return new Error(
+                        `Value too long for column "${column ?? "unknown"}" in "${tableRef}": ${pgMessage}${suffix}`
+                    );
+                case "22003": // numeric_value_out_of_range
+                    return new Error(
+                        `Numeric value out of range for column "${column ?? "unknown"}" in "${tableRef}": ${pgMessage}${suffix}`
                     );
+                case "42703": // undefined_column
+                    return new Error(
+                        `Unknown column in "${tableRef}": ${pgMessage}. Check if your schema is up to date (run migrations).${suffix}`
+                    );
+                case "42P01": // undefined_table
+                    return new Error(
+                        `Table not found for "${collectionSlug}": ${pgMessage}. Check if your schema is up to date (run migrations).${suffix}`
+                    );
+                default: {
+                    // Unhandled PG code — still surface the actual database message
+                    const parts = [`Database error in "${collectionSlug}" [${pgError.code}]: ${pgMessage}`];
+                    if (detail) parts.push(`Detail: ${detail}`);
+                    if (column) parts.push(`Column: ${column}`);
+                    if (dataType) parts.push(`Data type: ${dataType}`);
+                    if (constraint) parts.push(`Constraint: ${constraint}`);
+                    if (hint) parts.push(`Hint: ${hint}`);
+                    return new Error(parts.join(". "));
+                }
+            }
+        }
+
+        // No PG error found — try to extract a useful message from the
+        // Drizzle wrapper instead of leaking the raw SQL query + params.
+        const causeMessage = this.extractCauseMessage(error);
+        if (causeMessage) {
+            return new Error(`Database error in "${collectionSlug}": ${causeMessage}`);
+        }
+
+        // Last resort: use the original error message but strip the SQL query
+        if (error instanceof Error) {
+            const cleaned = this.stripSqlFromMessage(error.message, collectionSlug);
+            return new Error(cleaned);
+        }
+        return new Error(`Database error in "${collectionSlug}": ${String(error)}`);
+    }
+
+    /**
+     * Walk the error cause chain and return the deepest meaningful message.
+     */
+    private extractCauseMessage(error: unknown): string | null {
+        if (!error || typeof error !== "object") return null;
+        const err = error as Error & { cause?: unknown };
+
+        if (err.cause && typeof err.cause === "object") {
+            const deeper = this.extractCauseMessage(err.cause);
+            if (deeper) return deeper;
+            // The cause itself has a message
+            if (err.cause instanceof Error && err.cause.message) {
+                return err.cause.message;
             }
         }
+        return null;
+    }
 
-        // Fall through: re-throw original
-        if (error instanceof Error) return error;
-        return new Error(String(error));
+    /**
+     * Strip the raw SQL query from a Drizzle "Failed query: ..." message,
+     * keeping only the error description.
+     */
+    private stripSqlFromMessage(message: string, collectionSlug: string): string {
+        // Drizzle format: "Failed query: <SQL>\nparams: <params>"
+        if (message.startsWith("Failed query:")) {
+            return `Failed to save entity in "${collectionSlug}". Check server logs for details.`;
+        }
+        return message;
     }
 
     /**
      * Extract the underlying PostgreSQL error from a Drizzle wrapper.
      * Drizzle wraps PG errors in a `cause` property.
      */
-    private extractPgError(error: unknown): (Error & { code?: string; detail?: unknown; constraint?: unknown; column?: unknown; table?: unknown }) | null {
+    private extractPgError(error: unknown): (Error & { code?: string; detail?: unknown; hint?: unknown; constraint?: unknown; column?: unknown; table?: unknown; dataType?: unknown }) | null {
         if (!error || typeof error !== "object") return null;
 
         const err = error as Error & { code?: string; cause?: unknown; detail?: unknown };
 
         // Check if the error itself has a PG error code
-        if (err.code && /^[0-9]{5}$/.test(err.code)) {
-            return err as Error & { code: string; detail?: unknown; constraint?: unknown; column?: unknown; table?: unknown };
+        if (err.code && /^[0-9A-Z]{5}$/.test(err.code)) {
+            return err as Error & { code: string; detail?: unknown; hint?: unknown; constraint?: unknown; column?: unknown; table?: unknown; dataType?: unknown };
         }
 
         // Check the cause chain (Drizzle wraps PG errors)

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

@@ -1199,4 +1199,132 @@ describe("generateDrizzleSchema columnName support", () => {
         expect(result).toContain('"service_provider_140a"');
         expect(result).toContain('"insurance_id_140a"');
     });
+
+    describe("generateDrizzleSchema autoValue date properties", () => {
+
+        it("should add .default(sql`now()`) for on_create autoValue", async () => {
+            const collections: EntityCollection[] = [
+                {
+                    slug: "articles",
+                    table: "articles",
+                    name: "Articles",
+                    properties: {
+                        title: { type: "string" },
+                        created_at: {
+                            type: "date",
+                            autoValue: "on_create"
+                        }
+                    }
+                }
+            ];
+
+            const result = await generateSchema(collections, true);
+
+            // on_create should produce .default(sql`now()`)
+            expect(result).toContain(".default(sql`now()`)");
+            // No $onUpdate or triggers — on_update logic lives in the backend driver
+            expect(result).not.toContain(".$onUpdate");
+            expect(result).not.toContain("CREATE OR REPLACE TRIGGER");
+            expect(result).not.toContain("CREATE OR REPLACE FUNCTION");
+        });
+
+        it("should add .default(sql`now()`) for on_update autoValue (INSERT default only)", async () => {
+            const collections: EntityCollection[] = [
+                {
+                    slug: "articles",
+                    table: "articles",
+                    name: "Articles",
+                    properties: {
+                        title: { type: "string" },
+                        updated_at: {
+                            type: "date",
+                            autoValue: "on_update"
+                        }
+                    }
+                }
+            ];
+
+            const result = await generateSchema(collections, true);
+
+            // on_update should produce .default(sql`now()`) for initial INSERT value
+            expect(result).toContain(".default(sql`now()`)");
+            // No $onUpdate or triggers — update logic is handled by the backend driver
+            expect(result).not.toContain(".$onUpdate");
+            expect(result).not.toContain("CREATE OR REPLACE TRIGGER");
+        });
+
+        it("should not modify date columns without autoValue", async () => {
+            const collections: EntityCollection[] = [
+                {
+                    slug: "events",
+                    table: "events",
+                    name: "Events",
+                    properties: {
+                        name: { type: "string" },
+                        event_date: { type: "date" }
+                    }
+                }
+            ];
+
+            const result = await generateSchema(collections, true);
+
+            // A plain date should NOT have any autoValue-related modifiers
+            expect(result).not.toContain(".default(sql`now()`)");
+            expect(result).not.toContain(".$onUpdate");
+        });
+
+        it("should handle both on_create and on_update in the same collection", async () => {
+            const collections: EntityCollection[] = [
+                {
+                    slug: "posts",
+                    table: "posts",
+                    name: "Posts",
+                    properties: {
+                        title: { type: "string" },
+                        created_at: {
+                            type: "date",
+                            autoValue: "on_create"
+                        },
+                        updated_at: {
+                            type: "date",
+                            autoValue: "on_update"
+                        }
+                    }
+                }
+            ];
+
+            const result = await generateSchema(collections, true);
+
+            // Both should get .default(sql`now()`) for INSERT defaults
+            expect(result).toMatch(/created_at:.*\.default\(sql`now\(\)`\)/);
+            expect(result).toMatch(/updated_at:.*\.default\(sql`now\(\)`\)/);
+            // No $onUpdate or triggers
+            expect(result).not.toContain(".$onUpdate");
+            expect(result).not.toContain("CREATE OR REPLACE TRIGGER");
+        });
+
+        it("should handle on_create with date columnType", async () => {
+            const collections: EntityCollection[] = [
+                {
+                    slug: "logs",
+                    table: "logs",
+                    name: "Logs",
+                    properties: {
+                        message: { type: "string" },
+                        log_date: {
+                            type: "date",
+                            columnType: "date",
+                            autoValue: "on_create"
+                        }
+                    }
+                }
+            ];
+
+            const result = await generateSchema(collections, true);
+
+            // Should use date() column with the default
+            expect(result).toContain("date(\"log_date\"");
+            expect(result).toContain(".default(sql`now()`)");
+        });
+    });
 });

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

@@ -148,27 +148,27 @@ describe("generateCollectionFile", () => {
     });
 
     describe("enum support", () => {
-        it("generates enumValues for USER-DEFINED columns with matching enum", () => {
+        it("generates enum for USER-DEFINED columns with matching enum", () => {
             const enumMap = new Map([["order_status", ["pending", "shipped", "delivered"]]]);
             const meta = makeSimpleTable("orders", [
                 mkCol("orders", "id", { data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
                 mkCol("orders", "status", { data_type: "USER-DEFINED", udt_name: "order_status" }),
             ]);
             const result = generateCollectionFile("orders", meta, [], new Set(), new Map([["orders", meta]]), enumMap);
-            expect(result).toContain('enumValues:');
+            expect(result).toContain('enum:');
             expect(result).toContain('{ id: "pending", label: "Pending" }');
             expect(result).toContain('{ id: "shipped", label: "Shipped" }');
             expect(result).toContain('{ id: "delivered", label: "Delivered" }');
             expect(result).toContain('type: "string"');
         });
 
-        it("does NOT add enumValues for USER-DEFINED without matching enum", () => {
+        it("does NOT add enum for USER-DEFINED without matching enum", () => {
             const meta = makeSimpleTable("things", [
                 mkCol("things", "id", { data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
                 mkCol("things", "geom", { data_type: "USER-DEFINED", udt_name: "geometry" }),
             ]);
             const result = generateCollectionFile("things", meta, [], new Set(), new Map([["things", meta]]), new Map());
-            expect(result).not.toContain("enumValues");
+            expect(result).not.toContain("enum");
         });
 
         it("humanizes enum value labels with underscores", () => {
@@ -264,7 +264,7 @@ describe("generateCollectionFile", () => {
             ]);
             const result = generateCollectionFile("t", meta, [], new Set(), new Map([["t", meta]]), enumMap);
             expect(result).not.toContain("storagePath");
-            expect(result).toContain("enumValues");
+            expect(result).toContain("enum:");
         });
     });