@rebasepro/server-postgresql 0.0.1-canary.4d4fb3e → 0.0.1-canary.ca2cb6e

package/src/cli.ts

@@ -34,6 +34,8 @@ export async function runPluginCommand(args: string[]) {
         await dbCommand(subcommand, args);
     } else if (domain === "schema") {
         await schemaCommand(subcommand, args);
+    } else if (domain === "doctor") {
+        await doctorPluginCommand(args);
     } else {
         console.error(chalk.red(`Unknown domain command: ${domain}`));
         process.exit(1);
@@ -62,11 +64,32 @@ async function dbCommand(subcommand: string, rawArgs: string[]): Promise<void> {
         console.log(chalk.gray("  Step 2/2: Generating SQL migration files..."));
         console.log("");
         await runDrizzleKit("generate", rawArgs);
+        await fixMigrationStatementOrder();
         console.log("");
         console.log(`  You can now run ${chalk.bold.green("rebase db migrate")} to apply the migrations to your database.`);
         console.log("");
     } else {
-        await runDrizzleKit(subcommand, rawArgs);
+        console.log("");
+        console.log(chalk.bold(`  🗄️  Rebase DB ${subcommand.charAt(0).toUpperCase() + subcommand.slice(1)}`));
+        console.log("");
+
+        if (subcommand === "push") {
+            console.log(chalk.gray("  Step 1/2: Generating Drizzle schema from collections..."));
+            console.log("");
+            await schemaCommand("generate", rawArgs);
+            console.log("");
+            console.log(chalk.gray("  Step 2/2: Pushing schema to database..."));
+            console.log("");
+            await runDrizzleKit("push", rawArgs);
+        } else if (subcommand === "migrate") {
+            await runDrizzleKit("migrate", rawArgs);
+        } else {
+            await runDrizzleKit(subcommand, rawArgs);
+        }
+
+        console.log("");
+        console.log(chalk.green(`  ✓ rebase db ${subcommand} completed successfully.`));
+        console.log("");
     }
 }
 
@@ -103,7 +126,8 @@ async function branchCommand(rawArgs: string[]): Promise<void> {
     const { drizzle } = await import("drizzle-orm/node-postgres");
     const { Pool } = await import("pg");
 
-    const pool = new Pool({ connectionString: databaseUrl, max: 3 });
+    const pool = new Pool({ connectionString: databaseUrl,
+max: 3 });
     const db = drizzle(pool);
     const poolManager = new DatabasePoolManager(databaseUrl);
     const branchService = new BranchService(db, poolManager);
@@ -255,6 +279,102 @@ function timeAgo(date: Date): string {
     return `${days}d ago`;
 }
 
+/**
+ * Post-process generated migration files to fix statement ordering issues.
+ *
+ * Drizzle-kit can emit DROP POLICY statements *after* ALTER TABLE ... ALTER COLUMN
+ * for the same table. Postgres rejects this with:
+ *   "cannot alter type of a column used in a policy definition"
+ *
+ * This scans the drizzle output directory for the most recently modified .sql file
+ * and reorders statements so that DROP POLICY on a table always precedes any
+ * ALTER TABLE on that same table.
+ */
+async function fixMigrationStatementOrder(): Promise<void> {
+    const drizzleDir = path.join(process.cwd(), "drizzle");
+    if (!fs.existsSync(drizzleDir)) return;
+
+    // Find the most recently modified .sql file
+    const sqlFiles = fs.readdirSync(drizzleDir)
+        .filter(f => f.endsWith(".sql"))
+        .map(f => ({
+            name: f,
+            mtime: fs.statSync(path.join(drizzleDir, f)).mtimeMs
+        }))
+        .sort((a, b) => b.mtime - a.mtime);
+
+    if (sqlFiles.length === 0) return;
+
+    const latestFile = path.join(drizzleDir, sqlFiles[0].name);
+    const content = fs.readFileSync(latestFile, "utf-8");
+    const DELIMITER = "--> statement-breakpoint";
+    const parts = content.split(DELIMITER);
+
+    // Parse each statement to detect DROP POLICY and ALTER TABLE targets
+    const dropPolicyRe = /DROP\s+POLICY\s+.+?\s+ON\s+"([^"]+)"/i;
+    const alterTableRe = /ALTER\s+TABLE\s+"([^"]+)"\s+ALTER\s+COLUMN/i;
+
+    // Collect indices of DROP POLICY statements and what tables they target
+    const dropPolicyIndices = new Map<string, number[]>(); // table -> indices
+    const alterColumnIndices = new Map<string, number>(); // table -> first ALTER index
+
+    for (let i = 0; i < parts.length; i++) {
+        const stmt = parts[i].trim();
+        const dropMatch = stmt.match(dropPolicyRe);
+        if (dropMatch) {
+            const table = dropMatch[1];
+            if (!dropPolicyIndices.has(table)) dropPolicyIndices.set(table, []);
+            dropPolicyIndices.get(table)!.push(i);
+        }
+        const alterMatch = stmt.match(alterTableRe);
+        if (alterMatch) {
+            const table = alterMatch[1];
+            if (!alterColumnIndices.has(table)) alterColumnIndices.set(table, i);
+        }
+    }
+
+    // Check if any DROP POLICY comes after an ALTER COLUMN on the same table
+    let needsReorder = false;
+    for (const [table, dropIndices] of dropPolicyIndices) {
+        const firstAlter = alterColumnIndices.get(table);
+        if (firstAlter !== undefined) {
+            for (const dropIdx of dropIndices) {
+                if (dropIdx > firstAlter) {
+                    needsReorder = true;
+                    break;
+                }
+            }
+        }
+        if (needsReorder) break;
+    }
+
+    if (!needsReorder) return;
+
+    // Reorder: move DROP POLICY statements for affected tables before their ALTER TABLE
+    // Strategy: stable sort — DROP POLICY on table X gets priority over ALTER on table X
+    const stmtEntries = parts.map((stmt, idx) => ({ stmt,
+idx }));
+
+    stmtEntries.sort((a, b) => {
+        const aDropMatch = a.stmt.trim().match(dropPolicyRe);
+        const bAlterMatch = b.stmt.trim().match(alterTableRe);
+        const bDropMatch = b.stmt.trim().match(dropPolicyRe);
+        const aAlterMatch = a.stmt.trim().match(alterTableRe);
+
+        // If a is DROP POLICY on table X and b is ALTER on table X, a goes first
+        if (aDropMatch && bAlterMatch && aDropMatch[1] === bAlterMatch[1]) return -1;
+        // If b is DROP POLICY on table X and a is ALTER on table X, b goes first
+        if (bDropMatch && aAlterMatch && bDropMatch[1] === aAlterMatch[1]) return 1;
+        // Otherwise preserve original order
+        return a.idx - b.idx;
+    });
+
+    const reordered = stmtEntries.map(e => e.stmt).join(DELIMITER);
+    fs.writeFileSync(latestFile, reordered, "utf-8");
+
+    console.log(chalk.yellow(`  ⚠ Reordered migration statements in ${sqlFiles[0].name} (DROP POLICY before ALTER COLUMN)`));
+}
+
 async function runDrizzleKit(action: string, _rawArgs: string[]): Promise<void> {
     const drizzleKitBin = resolveLocalBin("drizzle-kit");
     if (!drizzleKitBin) {
@@ -263,14 +383,87 @@ async function runDrizzleKit(action: string, _rawArgs: string[]): Promise<void>
         process.exit(1);
     }
 
+    const env = { ...process.env as Record<string, string> };
     try {
-        await execa(drizzleKitBin, [action], {
-            cwd: process.cwd(),
-            stdio: "inherit",
-            env: { ...process.env as Record<string, string> },
-        });
+        const dotenv = await import("dotenv");
+        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)) {
+                const parsed = dotenv.config({ path: p });
+                if (parsed.parsed) {
+                    Object.assign(env, parsed.parsed);
+                    break;
+                }
+            }
+        }
+    } catch {
+        // dotenv may not be available — fall through
+    }
+
+    const interactive = ["generate", "push"].includes(action);
+
+    try {
+        if (interactive) {
+            await execa(drizzleKitBin, [action], {
+                cwd: process.cwd(),
+                stdio: "inherit",
+                env
+            });
+        } else {
+            const child = execa(drizzleKitBin, [action], {
+                cwd: process.cwd(),
+                env,
+                reject: false
+            });
+
+            // Natively stream output while still capturing it for error parsing
+            child.stdout?.pipe(process.stdout);
+            child.stderr?.pipe(process.stderr);
+
+            const result = await child;
+
+            // eslint-disable-next-line no-control-regex
+            const stripAnsi = (s: string) => s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\[?[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏⣷⣯⣟⡿⢿⣻⣽]+\]\s*/g, "");
+            const stdout = stripAnsi(result.stdout || "").trim();
+            const stderr = stripAnsi(result.stderr || "").trim();
+
+            if (result.exitCode !== 0) {
+                console.error(chalk.red(`\n✗ drizzle-kit ${action} failed.\n`));
+                const errorOutput = stderr || stdout;
+                if (errorOutput) {
+                    const lines = errorOutput.split("\n").filter((l: string) => l.trim());
+                    for (const line of lines) {
+                        if (line.toLowerCase().includes("error") || line.includes("cannot") || line.includes("already exists") || line.includes("does not exist") || line.includes("violates") || line.includes("permission denied")) {
+                            console.error(chalk.red(`  ${line.trim()}`));
+                        }
+                    }
+                }
+                console.error("");
+                process.exit(1);
+            }
+        }
     } catch (err: unknown) {
-        console.error(chalk.red(`✗ Failed to run drizzle-kit ${action}: ${err instanceof Error ? err.message : String(err)}`));
+        const msg = err instanceof Error ? err.message : String(err);
+        // eslint-disable-next-line no-control-regex
+        const stripAnsi = (s: string) => s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\[?[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏⣷⣯⣟⡿⢿⣻⣽]+\]\s*/g, "");
+        const cleaned = stripAnsi(msg).trim();
+        console.error(chalk.red(`\n✗ drizzle-kit ${action} failed.\n`));
+        const lines = cleaned.split("\n").filter((l: string) => l.trim());
+        for (const line of lines) {
+            if (line.toLowerCase().includes("error") || line.includes("cannot") || line.includes("already exists") || line.includes("does not exist") || line.includes("violates")) {
+                console.error(chalk.red(`  ${line.trim()}`));
+            }
+        }
+        if (lines.length === 0) {
+            console.error(chalk.gray(`  ${cleaned}`));
+        }
+        console.error("");
         process.exit(1);
     }
 }
@@ -284,11 +477,11 @@ async function schemaCommand(subcommand: string, rawArgs: string[]): Promise<voi
                 "--watch": Boolean,
                 "-c": "--collections",
                 "-o": "--output",
-                "-w": "--watch",
+                "-w": "--watch"
             },
             {
                 argv: rawArgs.slice(2), // db generate ... or schema generate ...
-                permissive: true,
+                permissive: true
             }
         );
 
@@ -299,7 +492,7 @@ async function schemaCommand(subcommand: string, rawArgs: string[]): Promise<voi
             console.error(chalk.red(`✗ Could not find generate-drizzle-schema.ts at ${generatorScript}`));
             process.exit(1);
         }
-        
+
         const tsxBin = resolveLocalBin("tsx");
         if (!tsxBin) {
             console.error(chalk.red("✗ Could not find tsx binary."));
@@ -313,12 +506,12 @@ async function schemaCommand(subcommand: string, rawArgs: string[]): Promise<voi
         console.log("");
         console.log(chalk.bold("  🔧 Rebase Schema Generator"));
         console.log("");
-        
+
         const cmdParts = [
             tsxBin,
             generatorScript,
             `--collections=${collectionsPath}`,
-            `--output=${outputPath}`,
+            `--output=${outputPath}`
         ];
         if (watch) {
             cmdParts.push("--watch");
@@ -328,20 +521,70 @@ async function schemaCommand(subcommand: string, rawArgs: string[]): Promise<voi
             await execa(cmdParts[0], cmdParts.slice(1), {
                 cwd: process.cwd(),
                 stdio: "inherit",
-                env: { ...process.env as Record<string, string> },
+                env: { ...process.env as Record<string, string> }
             });
         } catch (err: unknown) {
             console.error(chalk.red(`✗ Failed to run schema generator: ${err instanceof Error ? err.message : String(err)}`));
             process.exit(1);
         }
     } else {
-        console.error(chalk.red(`Unknown schema command.`));
+        console.error(chalk.red("Unknown schema command."));
+        process.exit(1);
+    }
+}
+
+async function doctorPluginCommand(rawArgs: string[]): Promise<void> {
+    const parsedArgs = arg(
+        {
+            "--collections": String,
+            "--schema": String,
+            "-c": "--collections",
+            "-s": "--schema"
+        },
+        {
+            argv: rawArgs.slice(1), // skip "doctor"
+            permissive: true
+        }
+    );
+
+    const doctorScript = path.join(__dirname, "schema", "doctor-cli.ts");
+    if (!fs.existsSync(doctorScript)) {
+        console.error(chalk.red(`✗ Could not find doctor.ts at ${doctorScript}`));
+        process.exit(1);
+    }
+
+    const tsxBin = resolveLocalBin("tsx");
+    if (!tsxBin) {
+        console.error(chalk.red("✗ Could not find tsx binary."));
+        process.exit(1);
+    }
+
+    const collectionsPath = parsedArgs["--collections"] || path.join("..", "shared", "collections");
+    const schemaPath = parsedArgs["--schema"] || path.join("src", "schema.generated.ts");
+
+    const cmdParts = [
+        tsxBin,
+        doctorScript,
+        `--collections=${collectionsPath}`,
+        `--schema=${schemaPath}`
+    ];
+
+    try {
+        await execa(cmdParts[0], cmdParts.slice(1), {
+            cwd: process.cwd(),
+            stdio: "inherit",
+            env: { ...process.env as Record<string, string> }
+        });
+    } catch {
         process.exit(1);
     }
 }
 
+
 // Entry point when called directly
-if (import.meta.url === `file://${process.argv[1]}`) {
+import fsSync from "fs";
+const argv1Real = process.argv[1] ? fsSync.realpathSync(process.argv[1]) : "";
+if (import.meta.url === `file://${argv1Real}`) {
     // Drop node and script path
     runPluginCommand(process.argv.slice(2)).catch(() => process.exit(1));
 }

package/src/collections/PostgresCollectionRegistry.ts

@@ -1,5 +1,5 @@
 import { CollectionRegistry } from "@rebasepro/common";
-import type { EntityCollection } from "@rebasepro/types";
+import { type CollectionWithRelations, type EntityCollection, type Relation, getDataSourceCapabilities } from "@rebasepro/types";
 import { PgEnum, PgTable } from "drizzle-orm/pg-core";
 import { Relations } from "drizzle-orm";
 import { CollectionRegistryInterface } from "../interfaces";
@@ -8,7 +8,7 @@ import { getTableName } from "@rebasepro/common";
 /**
  * PostgreSQL-specific collection registry.
  * Extends the base CollectionRegistry with support for Drizzle ORM tables, enums, and relations.
- * 
+ *
  * Satisfies CollectionRegistryInterface through inheritance from CollectionRegistry.
  */
 export class PostgresCollectionRegistry extends CollectionRegistry implements CollectionRegistryInterface {
@@ -35,7 +35,7 @@ export class PostgresCollectionRegistry extends CollectionRegistry implements Co
     /**
      * Finds collections assigned to a specific driver that do not have a registered table.
      */
-    getCollectionsWithoutTables(driverId: string = "(default)"): EntityCollection[] {
+    getCollectionsWithoutTables(driverId = "(default)"): EntityCollection[] {
         const collections = this.getCollections().filter(
             c => c.driver === driverId || (!c.driver && driverId === "(default)")
         );
@@ -87,9 +87,9 @@ export class PostgresCollectionRegistry extends CollectionRegistry implements Co
      * defined in the schema.
      */
     getRelationKeysForCollection(collectionPath: string): string[] {
-        const collection = this.getCollectionByPath(collectionPath) as import("@rebasepro/types").PostgresCollection<Record<string, unknown>, import("@rebasepro/types").User>;
-        if (!collection?.relations) return [];
-        return collection.relations.map(r => r.relationName || r.localKey || "").filter(Boolean);
+        const collection = this.getCollectionByPath(collectionPath);
+        if (!collection || !getDataSourceCapabilities(collection.driver).supportsRelations || !(collection as CollectionWithRelations).relations) return [];
+        return (collection as CollectionWithRelations).relations!.map((r: Relation) => r.relationName || r.localKey || "").filter(Boolean);
     }
 
 }

package/src/connection.ts

@@ -1,62 +1,84 @@
-import { Pool } from "pg";
+import { Pool, PoolConfig } from "pg";
 import { drizzle } from "drizzle-orm/node-postgres";
 
-export function createPostgresDatabaseConnection(connectionString: string, schema?: Record<string, unknown>) {
-    const pool = new Pool({
+/**
+ * Configuration for the Postgres connection pool.
+ *
+ * Sensible defaults are provided for production Cloud Run / single-instance
+ * deployments. Override via environment variables or explicit config.
+ */
+export interface PostgresPoolConfig {
+    /** Maximum number of connections in the pool (default: 20) */
+    max?: number;
+    /** Close idle connections after this many ms (default: 30 000) */
+    idleTimeoutMillis?: number;
+    /** Abort connection attempts after this many ms (default: 10 000) */
+    connectionTimeoutMillis?: number;
+    /** Per-query timeout in ms (default: 30 000) */
+    queryTimeout?: number;
+    /** Per-statement timeout in ms (default: 30 000) */
+    statementTimeout?: number;
+    /** Enable TCP keep-alive (default: true) */
+    keepAlive?: boolean;
+}
+
+const DEFAULT_POOL: Required<PostgresPoolConfig> = {
+    max: 20,
+    idleTimeoutMillis: 30_000,
+    connectionTimeoutMillis: 10_000,
+    queryTimeout: 30_000,
+    statementTimeout: 30_000,
+    keepAlive: true
+};
+
+/**
+ * Create a Drizzle-backed Postgres connection with a production-grade
+ * connection pool.
+ *
+ * @param connectionString  Postgres connection URL
+ * @param schema            Optional Drizzle schema for the relational API
+ * @param poolConfig        Optional pool tuning (merged over defaults)
+ *
+ * @returns `{ db, pool, connectionString }` — the `pool` is exposed so
+ *          callers can register shutdown hooks (`pool.end()`) or monitor
+ *          pool metrics.
+ */
+export function createPostgresDatabaseConnection(
+    connectionString: string,
+    schema?: Record<string, unknown>,
+    poolConfig?: PostgresPoolConfig
+) {
+    const opts = { ...DEFAULT_POOL,
+...poolConfig };
+
+    const pgPoolConfig: PoolConfig = {
         connectionString,
-        // Connection pool settings for resilience
-        max: 20, // Maximum number of connections in the pool
-        idleTimeoutMillis: 30000, // Close idle connections after 30 seconds
-        connectionTimeoutMillis: 10000, // Timeout for new connections
-        // Retry configuration
-        query_timeout: 30000, // Query timeout
-        statement_timeout: 30000, // Statement timeout
-        // Keep connections alive
-        keepAlive: true,
+        max: opts.max,
+        idleTimeoutMillis: opts.idleTimeoutMillis,
+        connectionTimeoutMillis: opts.connectionTimeoutMillis,
+        query_timeout: opts.queryTimeout,
+        statement_timeout: opts.statementTimeout,
+        keepAlive: opts.keepAlive,
         keepAliveInitialDelayMillis: 0
-    });
+    };
 
-    // Handle connection errors and implement reconnection logic
-    pool.on("error", (err) => {
-        console.error("Database connection error:", err);
+    const pool = new Pool(pgPoolConfig);
 
-        // Handle specific timeout errors
+    // ── Pool event logging ────────────────────────────────────────────────
+    // Uses console.* because the structured logger lives in server-core
+    // (a separate package). The caller can replace these with the structured
+    // logger if desired via pool.on() after creation.
+    pool.on("error", (err) => {
+        console.error("[pg-pool] Unexpected pool error:", err.message);
         if (err.message.includes("ETIMEDOUT")) {
-            console.warn("Connection timeout detected, pool will automatically retry...");
+            console.warn("[pg-pool] Connection timeout detected — pool will auto-retry");
         }
     });
 
-    // Handle successful connections
-    pool.on("connect", (client) => {
-        console.debug("Database client connected");
-
-        // Set up client-level error handling
-        client.on("error", (err) => {
-            console.error("Database client error:", err);
-        });
-    });
-
-    // Handle client removal from pool
-    pool.on("remove", (client) => {
-        console.debug("Database client removed from pool");
-    });
-
     // Create drizzle instance — pass schema when available to enable db.query relational API
     const db = schema ? drizzle(pool, { schema }) : drizzle(pool);
 
-    // Graceful shutdown handler
-    process.on("SIGINT", async () => {
-        console.log("SIGINT: Closing database pool...");
-        await pool.end();
-        process.exit(0);
-    });
-
-    process.on("SIGTERM", async () => {
-        console.log("SIGTERM: Closing database pool...");
-        await pool.end();
-        process.exit(0);
-    });
-
-    return { db, connectionString };
+    return { db,
+pool,
+connectionString };
 }
-