@rebasepro/server-postgresql 0.0.1-canary.f81da60 → 0.1.2

package/src/schema/introspect-db.ts

@@ -4,6 +4,7 @@ import path from "path";
 import pg from "pg";
 import arg from "arg";
 import * as dotenv from "dotenv";
+import readline from "readline";
 
 import {
     TableRow,
@@ -24,15 +25,24 @@ async function main() {
     const args = arg(
         {
             "--output": String,
+            "--collections": String,
             "--force": Boolean,
             "--schema": String,
+            "--data-inference": Boolean,
             "-o": "--output",
+            "-c": "--collections",
             "-f": "--force",
         },
         { permissive: true }
     );
 
-    const outDir = args["--output"] || path.resolve(process.cwd(), "config", "collections");
+    const cwd = process.cwd();
+    const isBackendDir = path.basename(cwd) === "backend";
+    const defaultOutDir = isBackendDir 
+        ? path.resolve(cwd, "..", "config", "collections") 
+        : path.resolve(cwd, "config", "collections");
+
+    const outDir = args["--output"] || args["--collections"] || defaultOutDir;
     const force = args["--force"] || false;
     const pgSchema = args["--schema"] || "public";
 
@@ -143,32 +153,65 @@ async function main() {
 
         console.log(chalk.blue(`Found ${tablesMap.size} tables (including ${joinTables.size} detected join tables).`));
 
+        let runDataInference = false;
+        if (args["--data-inference"] !== undefined) {
+            runDataInference = args["--data-inference"];
+        } else {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            const answer = await new Promise<string>((resolve) => rl.question(chalk.yellow("? Do you want to run comprehensive data inference on sampled rows to auto-detect types, formats, constraints, and UI configurations? (y/N) "), resolve));
+            runDataInference = answer.trim().toLowerCase() === 'y';
+            rl.close();
+        }
+
+        if (runDataInference) {
+            console.log(chalk.gray(`Sampling database rows for data inference...`));
+        }
+
         // Generate Collections
         const generatedFiles: string[] = [];
         const skippedFiles: string[] = [];
 
-        for (const [tableName, meta] of tablesMap.entries()) {
-            if (joinTables.has(tableName)) continue; // We don't generate base collections for pure join tables
-
-            // ── File overwrite protection ──────────────────────────────
-            const filePath = path.join(outDir, `${tableName}.ts`);
-            if (fs.existsSync(filePath) && !force) {
-                skippedFiles.push(tableName);
-                continue;
-            }
-
-            const fileContent = generateCollectionFile(
-                tableName,
-                meta,
-                fks,
-                joinTables,
-                tablesMap,
-                enumMap,
-            );
-
-            fs.writeFileSync(filePath, fileContent, "utf-8");
-            generatedFiles.push(tableName);
-            console.log(chalk.green(`  ✓ ${filePath}`));
+        const tablesToProcess = Array.from(tablesMap.entries()).filter(([tableName]) => !joinTables.has(tableName));
+        
+        const BATCH_SIZE = 10;
+        for (let i = 0; i < tablesToProcess.length; i += BATCH_SIZE) {
+            const batch = tablesToProcess.slice(i, i + BATCH_SIZE);
+            
+            await Promise.all(batch.map(async ([tableName, meta]) => {
+                // ── File overwrite protection ──────────────────────────────
+                const filePath = path.join(outDir, `${tableName}.ts`);
+                if (fs.existsSync(filePath) && !force) {
+                    skippedFiles.push(tableName);
+                    return;
+                }
+
+                let sampleData: Record<string, unknown>[] | undefined = undefined;
+                if (runDataInference) {
+                    try {
+                        const { rows } = await client.query(`SELECT * FROM "${pgSchema}"."${tableName}" LIMIT 100`);
+                        sampleData = rows;
+                    } catch (err) {
+                        console.error(chalk.yellow(`⚠ Failed to sample data for table ${tableName}: ${err instanceof Error ? err.message : String(err)}`));
+                    }
+                }
+
+                const fileContent = generateCollectionFile(
+                    tableName,
+                    meta,
+                    fks,
+                    joinTables,
+                    tablesMap,
+                    enumMap,
+                    sampleData,
+                );
+
+                fs.writeFileSync(filePath, fileContent, "utf-8");
+                generatedFiles.push(tableName);
+                console.log(chalk.green(`  ✓ ${filePath}`));
+            }));
         }
 
         // Generate index.ts (sorted alphabetically for deterministic output)

package/src/services/EntityFetchService.ts

@@ -617,6 +617,10 @@ export class EntityFetchService {
 
                 return entity;
             } catch (e) {
+                if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
+                    console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+                    console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+                }
                 console.warn(`[EntityFetchService] db.query.findFirst failed for ${collectionPath}, falling back to db.select:`, e);
             }
         }
@@ -733,6 +737,10 @@ export class EntityFetchService {
 
                 return entities;
             } catch (e) {
+                if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
+                    console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+                    console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+                }
                 console.warn(`[EntityFetchService] db.query.findMany failed for ${collectionPath}, falling back to db.select:`, e);
             }
         }
@@ -1195,6 +1203,10 @@ export class EntityFetchService {
 
                 return restRows;
             } catch (e) {
+                if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
+                    console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+                    console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+                }
                 console.warn(`[fetchCollectionForRest] db.query.findMany failed for ${collectionPath}, falling back:`, e);
             }
         }
@@ -1305,6 +1317,10 @@ export class EntityFetchService {
 
                 return restRow;
             } catch (e) {
+                if (e instanceof Error && e.message.includes("not enough information to infer relation")) {
+                    console.error(`[EntityFetchService] Relation inference error for collection '${collectionPath}': ${e.message}`);
+                    console.error(`Hint: This usually means a relation in your drizzle schema is missing a reciprocal 'one()' or 'many()' definition. Run 'rebase schema generate' to fix this.`);
+                }
                 console.warn(`[fetchEntityForRest] db.query.findFirst failed for ${collectionPath}, falling back:`, e);
             }
         }

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

@@ -1033,3 +1033,298 @@ isId: true }
         expect(cleanResult).toContain("user_name: varchar(\"user_name\").primaryKey()");
     });
 });
+
+// ── columnName tests ────────────────────────────────────────────────────
+describe("generateDrizzleSchema columnName support", () => {
+    const cleanSchema = (schema: string) => {
+        return schema
+            .replace(/\/\/.*$/gm, "")
+            .replace(/\/\*[\s\S]*?\*\//g, "")
+            .replace(/\n{2,}/g, "\n")
+            .replace(/\s+/g, " ")
+            .trim();
+    };
+
+    it("should use explicit columnName as the SQL column name instead of deriving from the property key", async () => {
+        const collections: EntityCollection[] = [{
+            slug: "billing",
+            table: "company_billing_config",
+            name: "Billing",
+            properties: {
+                employee_number_140a: {
+                    type: "string",
+                    name: "Employee Number 140a",
+                    columnName: "employee_number_140a",
+                },
+                contract_number_140a: {
+                    type: "string",
+                    name: "Contract Number 140a",
+                    columnName: "contract_number_140a",
+                },
+            },
+        }];
+
+        const result = await generateSchema(collections);
+        const cleanResult = cleanSchema(result);
+
+        // Must use the exact columnName, NOT toSnakeCase(propKey) which would produce "employee_number_140_a"
+        expect(cleanResult).toContain('employee_number_140a: varchar("employee_number_140a")');
+        expect(cleanResult).toContain('contract_number_140a: varchar("contract_number_140a")');
+
+        // Must NOT contain the broken snake_case version
+        expect(cleanResult).not.toContain("employee_number_140_a");
+        expect(cleanResult).not.toContain("contract_number_140_a");
+    });
+
+    it("should fall back to toSnakeCase when columnName is not set (manually-authored collections)", async () => {
+        const collections: EntityCollection[] = [{
+            slug: "products",
+            table: "products",
+            name: "Products",
+            properties: {
+                productName: {
+                    type: "string",
+                    name: "Product Name",
+                    // No columnName — should derive from key
+                },
+            },
+        }];
+
+        const result = await generateSchema(collections);
+        const cleanResult = cleanSchema(result);
+
+        // JS key stays camelCase, SQL column name gets snake_cased
+        expect(cleanResult).toContain('productName: varchar("product_name")');
+    });
+
+    it("should handle mixed properties — some with columnName, some without", async () => {
+        const collections: EntityCollection[] = [{
+            slug: "config",
+            table: "app_config",
+            name: "Config",
+            properties: {
+                // Introspected: has explicit columnName
+                fee_number_140a: {
+                    type: "string",
+                    name: "Fee Number",
+                    columnName: "fee_number_140a",
+                },
+                // Manually added: no columnName
+                displayName: {
+                    type: "string",
+                    name: "Display Name",
+                },
+            },
+        }];
+
+        const result = await generateSchema(collections);
+        const cleanResult = cleanSchema(result);
+
+        // Introspected prop uses exact columnName
+        expect(cleanResult).toContain('fee_number_140a: varchar("fee_number_140a")');
+        // Manual prop: JS key stays camelCase, SQL column gets snake_cased
+        expect(cleanResult).toContain('displayName: varchar("display_name")');
+    });
+
+    it("should use columnName for all property types, not just strings", async () => {
+        const collections: EntityCollection[] = [{
+            slug: "metrics",
+            table: "metrics",
+            name: "Metrics",
+            properties: {
+                count_v2: {
+                    type: "number",
+                    name: "Count V2",
+                    columnName: "count_v2",
+                },
+                is_active_v2: {
+                    type: "boolean",
+                    name: "Is Active V2",
+                    columnName: "is_active_v2",
+                },
+                created_at_v2: {
+                    type: "date",
+                    name: "Created At V2",
+                    columnName: "created_at_v2",
+                },
+                metadata_v2: {
+                    type: "map",
+                    name: "Metadata V2",
+                    columnName: "metadata_v2",
+                },
+            },
+        }];
+
+        const result = await generateSchema(collections);
+        const cleanResult = cleanSchema(result);
+
+        expect(cleanResult).toContain('count_v2: numeric("count_v2")');
+        expect(cleanResult).toContain('is_active_v2: boolean("is_active_v2")');
+        expect(cleanResult).toContain('created_at_v2: timestamp("created_at_v2"');
+        expect(cleanResult).toContain('metadata_v2: jsonb("metadata_v2")');
+    });
+
+    it("should reproduce and prevent the medmot bug: digit+letter column names", async () => {
+        // This is the exact scenario from the medmot project that caused the production failure
+        const collections: EntityCollection[] = [{
+            slug: "company_billing_config",
+            table: "company_billing_config",
+            name: "Company Billing Config",
+            properties: {
+                employee_number_140a: { type: "string", name: "Employee Number", columnName: "employee_number_140a" },
+                contract_number_140a: { type: "string", name: "Contract Number", columnName: "contract_number_140a" },
+                amount: { type: "number", name: "Amount" },
+                id: { type: "number", name: "ID", isId: "increment" },
+                service_provider_140a: { type: "string", name: "Service Provider", columnName: "service_provider_140a" },
+                internal_area_code_140a: { type: "string", name: "Internal Area Code", columnName: "internal_area_code_140a" },
+                fee_number_140a: { type: "string", name: "Fee Number", columnName: "fee_number_140a" },
+                receiver_market_participant_140a: { type: "string", name: "Receiver Market Participant", columnName: "receiver_market_participant_140a" },
+                employee_value_number_140a: { type: "string", name: "Employee Value Number", columnName: "employee_value_number_140a" },
+                sender_market_participant_140a: { type: "string", name: "Sender Market Participant", columnName: "sender_market_participant_140a" },
+                processing_indicator_140a: { type: "string", name: "Processing Indicator", columnName: "processing_indicator_140a" },
+                insurance_id_140a: { type: "string", name: "Insurance ID", columnName: "insurance_id_140a" },
+                company_id: { type: "number", name: "Company ID" },
+            },
+        }];
+
+        const result = await generateSchema(collections);
+
+        // Every _140a column must stay _140a, not become _140_a
+        const brokenPattern = /_140_a/;
+        expect(result).not.toMatch(brokenPattern);
+
+        // Spot-check a few exact columns
+        expect(result).toContain('"employee_number_140a"');
+        expect(result).toContain('"contract_number_140a"');
+        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()`)");
+        });
+    });
+});