@rebasepro/server-postgresql 0.0.1-canary.09e5ec5

package/src/schema/introspect-db.ts

@@ -0,0 +1,211 @@
+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 {
+    TableRow,
+    TableColumn,
+    EnumValue,
+    PrimaryKeyRow,
+    ForeignKeyRow,
+    buildTablesMap,
+    buildEnumMap,
+    identifyJoinTables,
+    generateCollectionFile,
+    generateIndexContent,
+    mergeIndexContent,
+    safeHostFromUrl,
+} from "./introspect-db-logic";
+
+async function main() {
+    const args = arg(
+        {
+            "--output": String,
+            "--force": Boolean,
+            "--schema": String,
+            "-o": "--output",
+            "-f": "--force",
+        },
+        { permissive: true }
+    );
+
+    const outDir = args["--output"] || path.resolve(process.cwd(), "config", "collections");
+    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).`));
+
+        // 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}`));
+        }
+
+        // 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/schema/test-schema.ts

@@ -0,0 +1,11 @@
+import { pgTable, text, pgPolicy } from "drizzle-orm/pg-core";
+import { sql } from "drizzle-orm";
+
+export const testTable = pgTable("test", {
+  id: text("id").primaryKey()
+}, (t) => [
+  pgPolicy("renamed_policy", { as: "permissive",
+to: "public",
+for: "select",
+using: sql`true` })
+]);

package/src/services/BranchService.ts

@@ -0,0 +1,237 @@
+/**
+ * BranchService
+ *
+ * Manages database branching by creating/deleting PostgreSQL databases
+ * using `CREATE DATABASE ... TEMPLATE`. Branch metadata is stored in the
+ * `rebase.branches` table in the default (main) database, following the
+ * same `rebase` schema convention used by entity_history, auth, etc.
+ */
+
+import { sql } from "drizzle-orm";
+import { BranchInfo } from "@rebasepro/types";
+import { DrizzleClient } from "../interfaces";
+import { DatabasePoolManager } from "../databasePoolManager";
+
+/** Internal prefix applied to branch database names to avoid collisions. */
+const BRANCH_DB_PREFIX = "rb_";
+
+/** Fully-qualified metadata table in the rebase schema. */
+const BRANCHES_TABLE = "rebase.branches";
+
+/**
+ * Sanitize a user-provided branch name to a safe PostgreSQL identifier.
+ * Only allows alphanumeric characters and underscores.
+ */
+function sanitizeBranchName(name: string): string {
+    return name.replace(/[^a-zA-Z0-9_]/g, "");
+}
+
+/**
+ * Convert a user-facing branch name to the actual PostgreSQL database name.
+ */
+function toBranchDbName(name: string): string {
+    const sanitized = sanitizeBranchName(name);
+    if (!sanitized) throw new Error("Branch name must contain at least one alphanumeric character.");
+    return `${BRANCH_DB_PREFIX}${sanitized}`;
+}
+
+export class BranchService {
+    constructor(
+        private db: DrizzleClient,
+        private poolManager: DatabasePoolManager
+    ) {}
+
+    /**
+     * Ensure the `rebase.branches` metadata table exists in the default database.
+     * Idempotent — safe to call on every startup.
+     */
+    async ensureBranchMetadataTable(): Promise<void> {
+        // Create the rebase schema (idempotent — may already exist from auth/history init)
+        await this.db.execute(sql`CREATE SCHEMA IF NOT EXISTS rebase`);
+
+        await this.db.execute(sql.raw(`
+            CREATE TABLE IF NOT EXISTS ${BRANCHES_TABLE} (
+                name         TEXT PRIMARY KEY,
+                db_name      TEXT NOT NULL UNIQUE,
+                parent_db    TEXT NOT NULL,
+                created_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+                metadata     JSONB DEFAULT '{}'
+            );
+        `));
+    }
+
+    /**
+     * Create a new branch database by templating the source database.
+     *
+     * Uses `CREATE DATABASE ... TEMPLATE` for an instant, full-fidelity copy
+     * of both schema and data.
+     *
+     * @param name   User-facing branch name (e.g., "feature_auth")
+     * @param options.source  Source database to clone; defaults to the main database.
+     */
+    async createBranch(name: string, options?: { source?: string }): Promise<BranchInfo> {
+        const dbName = toBranchDbName(name);
+        const sanitizedName = sanitizeBranchName(name);
+        const sourceDb = options?.source || this.poolManager.defaultDatabaseName;
+
+        // Check if branch already exists
+        const existing = await this.db.execute(
+            sql`SELECT name FROM rebase.branches WHERE name = ${sanitizedName} OR db_name = ${dbName}`
+        );
+        if ((existing.rows as unknown[]).length > 0) {
+            throw new Error(`Branch "${sanitizedName}" already exists.`);
+        }
+
+        // Disconnect any idle pools to the source DB so TEMPLATE works.
+        // CREATE DATABASE ... TEMPLATE requires no other connections to the template.
+        await this.poolManager.disconnectDatabase(sourceDb);
+
+        // Create the database using the source as a template.
+        // Note: Identifiers must be double-quoted, not parameterized.
+        const safeDbName = dbName.replace(/"/g, '""');
+        const safeSourceDb = sourceDb.replace(/"/g, '""');
+        try {
+            await this.db.execute(
+                sql.raw(`CREATE DATABASE "${safeDbName}" TEMPLATE "${safeSourceDb}"`)
+            );
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes("already exists")) {
+                throw new Error(`Database "${dbName}" already exists on the server. Choose a different branch name.`);
+            }
+            // If template fails due to active connections, provide a helpful error
+            if (msg.includes("being accessed by other users")) {
+                throw new Error(
+                    `Cannot create branch: the source database "${sourceDb}" has active connections. ` +
+                    "Close other clients or connections and try again."
+                );
+            }
+            throw err;
+        }
+
+        // Record metadata in the default database
+        const now = new Date();
+        await this.db.execute(
+            sql`INSERT INTO rebase.branches (name, db_name, parent_db, created_at) 
+                VALUES (${sanitizedName}, ${dbName}, ${sourceDb}, ${now.toISOString()})`
+        );
+
+        return {
+            name: sanitizedName,
+            parentDatabase: sourceDb,
+            createdAt: now
+        };
+    }
+
+    /**
+     * Delete a branch database and remove its metadata.
+     * Cannot delete the main/default database.
+     */
+    async deleteBranch(name: string): Promise<void> {
+        const sanitizedName = sanitizeBranchName(name);
+        const dbName = toBranchDbName(name);
+
+        // Safety: never delete the default database
+        if (dbName === this.poolManager.defaultDatabaseName) {
+            throw new Error("Cannot delete the main database.");
+        }
+
+        // Verify the branch exists in our metadata
+        const existing = await this.db.execute(
+            sql`SELECT db_name FROM rebase.branches WHERE name = ${sanitizedName}`
+        );
+        if ((existing.rows as unknown[]).length === 0) {
+            throw new Error(`Branch "${sanitizedName}" not found.`);
+        }
+
+        // Disconnect any pools to this branch before dropping
+        await this.poolManager.disconnectDatabase(dbName);
+
+        // Drop the database
+        const safeDbName = dbName.replace(/"/g, '""');
+        try {
+            await this.db.execute(sql.raw(`DROP DATABASE "${safeDbName}"`));
+        } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes("being accessed by other users")) {
+                throw new Error(
+                    `Cannot delete branch "${sanitizedName}": the database has active connections. ` +
+                    "Close other clients and try again."
+                );
+            }
+            throw err;
+        }
+
+        // Remove metadata
+        await this.db.execute(
+            sql`DELETE FROM rebase.branches WHERE name = ${sanitizedName}`
+        );
+    }
+
+    /**
+     * List all branches recorded in the metadata table.
+     * Optionally fetches database sizes from pg_database.
+     */
+    async listBranches(): Promise<BranchInfo[]> {
+        const result = await this.db.execute(sql.raw(`
+            SELECT 
+                b.name,
+                b.parent_db,
+                b.created_at,
+                pg_database_size(b.db_name) as size_bytes
+            FROM ${BRANCHES_TABLE} b
+            JOIN pg_database d ON d.datname = b.db_name
+            ORDER BY b.created_at DESC
+        `));
+
+        return (result.rows as Record<string, unknown>[]).map((row) => ({
+            name: row.name as string,
+            parentDatabase: row.parent_db as string,
+            createdAt: new Date(row.created_at as string),
+            sizeBytes: row.size_bytes != null ? Number(row.size_bytes) : undefined
+        }));
+    }
+
+    /**
+     * Get info about a specific branch.
+     */
+    async getBranchInfo(name: string): Promise<BranchInfo | undefined> {
+        const sanitizedName = sanitizeBranchName(name);
+
+        const result = await this.db.execute(sql`
+            SELECT 
+                b.name,
+                b.parent_db,
+                b.created_at
+            FROM rebase.branches b
+            WHERE b.name = ${sanitizedName}
+        `);
+
+        const rows = result.rows as Record<string, unknown>[];
+        if (rows.length === 0) return undefined;
+
+        const row = rows[0];
+
+        // Attempt to get size — may fail if the DB was externally dropped
+        let sizeBytes: number | undefined;
+        try {
+            const dbName = toBranchDbName(sanitizedName);
+            const sizeResult = await this.db.execute(
+                sql`SELECT pg_database_size(${dbName}) as size_bytes`
+            );
+            const sizeRows = sizeResult.rows as Record<string, unknown>[];
+            if (sizeRows.length > 0 && sizeRows[0].size_bytes != null) {
+                sizeBytes = Number(sizeRows[0].size_bytes);
+            }
+        } catch {
+            // Database might not exist anymore
+        }
+
+        return {
+            name: row.name as string,
+            parentDatabase: row.parent_db as string,
+            createdAt: new Date(row.created_at as string),
+            sizeBytes
+        };
+    }
+}