@rebasepro/server-postgresql 0.0.1-canary.eae7889 → 0.1.0

package/src/schema/introspect-db.ts

@@ -0,0 +1,254 @@
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import pg from "pg";
+import arg from "arg";
+import * as dotenv from "dotenv";
+import readline from "readline";
+
+import {
+    TableRow,
+    TableColumn,
+    EnumValue,
+    PrimaryKeyRow,
+    ForeignKeyRow,
+    buildTablesMap,
+    buildEnumMap,
+    identifyJoinTables,
+    generateCollectionFile,
+    generateIndexContent,
+    mergeIndexContent,
+    safeHostFromUrl,
+} from "./introspect-db-logic";
+
+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 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";
+
+    if (!fs.existsSync(outDir)) {
+        fs.mkdirSync(outDir, { recursive: true });
+    }
+
+    // Load env
+    const envPaths = [
+        process.env.DOTENV_CONFIG_PATH,
+        path.resolve(process.cwd(), ".env"),
+        path.resolve(process.cwd(), "../.env"),
+        path.resolve(process.cwd(), "../../.env")
+    ].filter(Boolean) as string[];
+
+    for (const p of envPaths) {
+        if (fs.existsSync(p)) {
+            dotenv.config({ path: p });
+            break;
+        }
+    }
+
+    const databaseUrl = process.env.DATABASE_URL || process.env.ADMIN_CONNECTION_STRING;
+    if (!databaseUrl) {
+        console.error(chalk.red("✗ DATABASE_URL is not set. Make sure your .env file is configured."));
+        process.exit(1);
+    }
+
+    const client = new pg.Client({ connectionString: databaseUrl });
+
+    try {
+        await client.connect();
+    } catch (err) {
+        console.error(chalk.red(`✗ Failed to connect to database: ${err instanceof Error ? err.message : String(err)}`));
+        console.error(chalk.gray("  Check your DATABASE_URL and ensure the database is reachable."));
+        process.exit(1);
+    }
+
+    // Log the host portion safely — handle URLs without "@"
+    const hostPart = safeHostFromUrl(databaseUrl);
+    console.log(chalk.gray(`Connected to database: ${hostPart}`));
+    console.log(chalk.gray(`Introspecting schema '${pgSchema}'...`));
+
+    try {
+        // 1. Get Tables
+        const { rows: tables } = await client.query<TableRow>(`
+            SELECT table_name
+            FROM information_schema.tables
+            WHERE table_schema = $1 AND table_type = 'BASE TABLE'
+              AND table_name NOT LIKE 'drizzle_%'
+              AND table_name NOT LIKE 'rebase_%'
+            ORDER BY table_name
+        `, [pgSchema]);
+
+        // 2. Get Columns
+        const { rows: columns } = await client.query<TableColumn>(`
+            SELECT table_name, column_name, data_type, udt_name, is_nullable, column_default
+            FROM information_schema.columns
+            WHERE table_schema = $1
+        `, [pgSchema]);
+
+        // 2b. Get Enum Types and their values
+        const { rows: enumValues } = await client.query<EnumValue>(`
+            SELECT t.typname AS enum_name,
+                   e.enumlabel AS enum_value,
+                   e.enumsortorder AS sort_order
+            FROM pg_type t
+            JOIN pg_enum e ON t.oid = e.enumtypid
+            JOIN pg_namespace n ON t.typnamespace = n.oid
+            WHERE n.nspname = $1
+            ORDER BY t.typname, e.enumsortorder
+        `, [pgSchema]);
+
+        // Build a map: enum_name -> ordered list of values
+        const enumMap = buildEnumMap(enumValues);
+
+        // 3. Get Primary Keys
+        const { rows: pks } = await client.query<PrimaryKeyRow>(`
+            SELECT t.relname as table_name, a.attname as column_name
+            FROM   pg_index i
+            JOIN   pg_attribute a ON a.attrelid = i.indrelid
+                                AND a.attnum = ANY(i.indkey)
+            JOIN   pg_class t ON t.oid = i.indrelid
+            JOIN   pg_namespace n ON n.oid = t.relnamespace
+            WHERE  i.indisprimary AND n.nspname = $1
+        `, [pgSchema]);
+
+        // 4. Get Foreign Keys
+        const { rows: fks } = await client.query<ForeignKeyRow>(`
+            SELECT
+                tc.table_name, 
+                kcu.column_name, 
+                ccu.table_name AS foreign_table_name,
+                ccu.column_name AS foreign_column_name 
+            FROM 
+                information_schema.table_constraints AS tc 
+                JOIN information_schema.key_column_usage AS kcu
+                  ON tc.constraint_name = kcu.constraint_name
+                  AND tc.table_schema = kcu.table_schema
+                JOIN information_schema.constraint_column_usage AS ccu
+                  ON ccu.constraint_name = tc.constraint_name
+                  AND ccu.table_schema = tc.table_schema
+            WHERE tc.constraint_type = 'FOREIGN KEY' AND tc.table_schema = $1
+        `, [pgSchema]);
+
+        const tablesMap = buildTablesMap(tables, columns, pks, fks);
+        const joinTables = identifyJoinTables(tablesMap);
+
+        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[] = [];
+
+        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)
+        if (generatedFiles.length > 0) {
+            const indexPath = path.join(outDir, "index.ts");
+
+            if (fs.existsSync(indexPath) && !force) {
+                // Merge: read existing index, add new exports that don't already exist
+                const existing = fs.readFileSync(indexPath, "utf-8");
+                const merged = mergeIndexContent(existing, generatedFiles);
+                fs.writeFileSync(indexPath, merged, "utf-8");
+            } else {
+                const indexContent = generateIndexContent(generatedFiles);
+                fs.writeFileSync(indexPath, indexContent, "utf-8");
+            }
+            console.log(chalk.green(`  ✓ ${indexPath}`));
+        }
+
+        console.log("");
+        if (skippedFiles.length > 0) {
+            console.log(chalk.yellow(`⚠ Skipped ${skippedFiles.length} existing file(s): ${skippedFiles.join(", ")}`));
+            console.log(chalk.gray(`  Use --force to overwrite existing files.`));
+            console.log("");
+        }
+        console.log(chalk.bold.green(`✓ Introspected ${tablesMap.size} tables — generated ${generatedFiles.length} collection(s).`));
+        console.log(chalk.gray(`  Review the generated files in ${outDir} and customize properties as needed.`));
+        console.log("");
+
+    } catch (e) {
+        console.error(chalk.red(`✗ Error introspecting database: ${e instanceof Error ? e.message : String(e)}`));
+        process.exit(1);
+    } finally {
+        await client.end();
+    }
+}
+
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

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

@@ -111,7 +111,7 @@ export class EntityPersistService {
                             targetColumnName = relation.localKey;
                         } else if (relation.foreignKeyOnTarget) {
                             targetColumnName = relation.foreignKeyOnTarget;
-                        } else if (relation.joinPath && relation.joinPath.length > 0) {
+                        } else if (relation.joinPath && relation.joinPath.length === 1) {
                             const targetTableName = getTableName(targetCollection);
                             const relevantJoinStep = relation.joinPath.find(joinStep => joinStep.table === targetTableName);
 
@@ -123,6 +123,12 @@ export class EntityPersistService {
                                 const targetColumnNames = DrizzleConditionBuilder.getColumnNamesFromColumns(relation.joinPath[0].on.to);
                                 targetColumnName = targetColumnNames[0];
                             }
+                        } else if (relation.joinPath && relation.joinPath.length > 1) {
+                            // For multi-hop relations (like many-to-many through a junction table),
+                            // there is no direct foreign key on the target table pointing to the parent.
+                            // The relationship is managed via the junction table.
+                            // We shouldn't inject the parent ID directly into the target entity payload.
+                            break;
                         } else {
                             throw new Error(`Relation '${relationKey}' lacks configuration for path-based saving.`);
                         }
@@ -292,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(". "));
+                }
             }
         }
 
-        // Fall through: re-throw original
-        if (error instanceof Error) return error;
-        return new Error(String(error));
+        // 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;
+    }
+
+    /**
+     * 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)