@coldge.com/gitbase 1.0.2 → 1.0.3

package/dist/commands/push.js

@@ -2,11 +2,16 @@ import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';
 import readline from 'readline';
-import { getConfig, runQuery } from '../api/supabase.js';
+import { getConfig, runQuery, runTransaction, createPool, endPool } from '../api/supabase.js';
 import { extractSchema } from '../schema/extractor.js';
-import { canonicalize } from '../utils/hashing.js';
+import { canonicalize, hashString } from '../utils/hashing.js';
+import { generateTableAlter, generateEnumAlter } from '../utils/sqlDiff.js';
 import toposort from 'toposort';
-const GITBASE_DIR = '.gitbase';
+// Execution order matters: extensions before types, grants and publications last
+const SCHEMA_TYPES = [
+    'extensions', 'types', 'sequences', 'tables', 'matviews',
+    'views', 'functions', 'triggers', 'policies', 'grants', 'publications'
+];
 export async function push(argv) {
     const config = await getConfig();
     if (!config) {
@@ -28,14 +33,22 @@ export async function push(argv) {
         console.log(chalk.green('Permission verified.'));
     }
     const filterFiles = argv.files || [];
-    console.log(chalk.blue(`Pushing local files to branch '${currentBranch}' (${projectRef})...`));
-    // 1. Fetch current live state to make smart decisions
-    console.log(chalk.blue(`Checking current database state...`));
-    const liveSchema = await extractSchema(projectRef);
-    // 2. Load Local Files as the "Target Schema"
-    const localSchema = { tables: {}, functions: {}, views: {}, triggers: {}, policies: {}, types: {} };
-    const types = ['tables', 'functions', 'views', 'triggers', 'policies', 'types'];
-    for (const type of types) {
+    console.log(chalk.blue(`\nFetching current database state...`));
+    await createPool(projectRef);
+    let liveSchema;
+    try {
+        liveSchema = await extractSchema(projectRef);
+    }
+    finally {
+        // Keep pool alive — we need it for conflict detection queries via runQuery()
+        // We'll call endPool at the very end of push().
+    }
+    // --- Load Local Files as Target Schema ---
+    const localSchema = {
+        types: {}, sequences: {}, tables: {}, matviews: {},
+        views: {}, functions: {}, triggers: {}, policies: {}
+    };
+    for (const type of SCHEMA_TYPES) {
         const dir = path.join('supabase', type);
         try {
             const files = await fs.readdir(dir);
@@ -47,35 +60,141 @@ export async function push(argv) {
                 localSchema[type][name] = content;
             }
         }
-        catch (e) { }
+        catch { /* directory may not exist yet */ }
     }
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-    });
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const ask = (q) => new Promise(r => rl.question(q, r));
-    let madeDbChanges = false;
-    // 3. Execution Plan (Same logic as revert, but local files are the truth)
-    // TYPES
+    // Helper functions declared early so they can be used in both conflict detection and planning
+    const skip = (type, name) => filterFiles.length > 0 && !filterFiles.includes(`${type}/${name}.sql`);
+    const same = (a, b) => canonicalize(a) === canonicalize(b);
+    // =========================================================================
+    // CONFLICT DETECTION — compare live DB state against what was last pulled
+    // (the HEAD commit tree). If the live DB has changed since our last pull,
+    // someone else pushed to the DB and we could be overwriting their work.
+    // =========================================================================
+    const skippedObjects = new Set(); // type/name pairs to skip in plan
+    try {
+        const headHash = await fs.readFile(path.join('.gitbase', 'HEAD'), 'utf-8').catch(() => null);
+        if (headHash) {
+            const headCommitStr = await fs.readFile(path.join('.gitbase', 'objects', headHash), 'utf-8');
+            const headCommit = JSON.parse(headCommitStr);
+            const headTreeStr = await fs.readFile(path.join('.gitbase', 'objects', headCommit.tree), 'utf-8');
+            const headTree = JSON.parse(headTreeStr);
+            // headTree: relPath -> hash (e.g. "functions/foo.sql" -> "abc123")
+            // For each local change, check if the live DB version differs from HEAD
+            let conflictsFound = false;
+            for (const type of SCHEMA_TYPES) {
+                const liveObjects = liveSchema[type];
+                const localObjects = localSchema[type];
+                if (!localObjects)
+                    continue;
+                for (const [name, localSql] of Object.entries(localObjects)) {
+                    if (skip(type, name))
+                        continue;
+                    const headKey = `${type}/${name}.sql`;
+                    const headHash = headTree[headKey];
+                    if (!headHash)
+                        continue; // New object — no conflict possible
+                    const liveSql = liveObjects?.[name];
+                    if (!liveSql)
+                        continue; // Object deleted from live — not a conflict
+                    // Hash the live version the same way commit.ts does
+                    const liveHash = hashString(liveSql.trim() + '\n');
+                    // Conflict: live DB was changed by someone else since our last pull
+                    if (liveHash !== headHash && !same(localSql, liveSql)) {
+                        if (!conflictsFound) {
+                            console.log(chalk.yellow('\n⚠️  CONFLICTS DETECTED\n'));
+                            conflictsFound = true;
+                        }
+                        console.log(chalk.yellow(`  CONFLICT: ${type}/${name}.sql`));
+                        console.log(chalk.gray(`    Your version:  ${hashString(localSql).substring(0, 7)}`));
+                        console.log(chalk.gray(`    Live version:  ${liveHash.substring(0, 7)} (changed since your last pull)`));
+                        const answer = await ask(chalk.white(`    [o]verwrite live  [s]kip  [d]iff > `));
+                        const choice = answer.trim().toLowerCase();
+                        if (choice === 's') {
+                            skippedObjects.add(`${type}/${name}`);
+                            console.log(chalk.gray(`    → Skipped`));
+                        }
+                        else if (choice === 'd') {
+                            console.log(chalk.gray('\n    --- Live DB ---'));
+                            console.log(chalk.red(liveSql.substring(0, 500)));
+                            console.log(chalk.gray('\n    --- Your local ---'));
+                            console.log(chalk.green(localSql.substring(0, 500)));
+                            // Ask again after showing diff
+                            const answer2 = await ask(chalk.white('\n    [o]verwrite  [s]kip > '));
+                            if (answer2.trim().toLowerCase() === 's') {
+                                skippedObjects.add(`${type}/${name}`);
+                                console.log(chalk.gray('    → Skipped'));
+                            }
+                            else {
+                                console.log(chalk.cyan('    → Will overwrite'));
+                            }
+                        }
+                        else {
+                            console.log(chalk.cyan('    → Will overwrite'));
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch { /* HEAD not found or malformed — skip conflict check */ }
+    // Update skip function to also check conflict skips
+    const skipWithConflicts = (type, name) => skip(type, name) || skippedObjects.has(`${type}/${name}`);
+    // =========================================================================
+    // PHASE 1: PLAN — collect all SQL statements (interactively if needed)
+    // No DB writes happen in this phase.
+    // =========================================================================
+    const plan = [];
+    const timestamp = Math.floor(Date.now() / 1000);
+    // EXTENSIONS — CREATE IF NOT EXISTS only, never dropped (too destructive)
+    for (const [name, sql] of Object.entries(localSchema.extensions)) {
+        if (skipWithConflicts('extensions', name))
+            continue;
+        if (liveSchema.extensions[name] && same(sql, liveSchema.extensions[name]))
+            continue;
+        plan.push({ label: `Extension: ${name}`, sqls: [sql] });
+    }
+    // TYPES (enums, composites, domains)
     for (const [name, sql] of Object.entries(localSchema.types)) {
-        if (filterFiles.length > 0 && !filterFiles.includes(`types/${name}.sql`))
+        if (skipWithConflicts('types', name))
             continue;
-        if (liveSchema.types[name] && canonicalize(sql) === canonicalize(liveSchema.types[name]))
+        if (liveSchema.types[name] && same(sql, liveSchema.types[name]))
             continue;
-        madeDbChanges = true;
-        console.log(chalk.cyan(`Pushing Type: ${name}`));
-        await runQuery(projectRef, `DROP TYPE IF EXISTS public."${name}" CASCADE;`);
-        await runQuery(projectRef, sql);
+        // For enum types, try a safe ADD VALUE first before falling back to DROP+CREATE
+        const isEnum = /AS ENUM/i.test(sql);
+        if (isEnum && liveSchema.types[name]) {
+            const alterStmts = generateEnumAlter(name, liveSchema.types[name], sql);
+            if (alterStmts !== null) {
+                if (alterStmts.length > 0) {
+                    plan.push({ label: `Enum Type (ADD VALUE): ${name}`, sqls: alterStmts });
+                }
+                continue; // handled — skip DROP+CREATE
+            }
+            // null = values removed or reordered — must DROP+CREATE
+            console.log(chalk.yellow(`\nEnum '${name}' has removed/reordered values — full recreation required.`));
+        }
+        plan.push({
+            label: `Type: ${name}`,
+            sqls: [`DROP TYPE IF EXISTS public."${name}" CASCADE;`, sql]
+        });
+    }
+    // SEQUENCES — created with IF NOT EXISTS to preserve counter values in production
+    for (const [name, sql] of Object.entries(localSchema.sequences)) {
+        if (skip('sequences', name))
+            continue;
+        if (liveSchema.sequences[name] && same(sql, liveSchema.sequences[name]))
+            continue;
+        plan.push({ label: `Sequence: ${name}`, sqls: [sql] });
     }
-    // TABLES (Topological Sort)
+    // TABLES — topologically sorted by foreign key dependency
     const tableEdges = [];
     const tables = localSchema.tables;
     const tableNames = Object.keys(tables);
     for (const [name, sql] of Object.entries(tables)) {
-        const content = sql;
         const regex = /REFERENCES\s+(?:public\.)?(\w+)/gi;
         let match;
-        while ((match = regex.exec(content)) !== null) {
+        while ((match = regex.exec(sql)) !== null) {
             const target = match[1];
             if (target !== name && tables[target])
                 tableEdges.push([target, name]);
@@ -85,92 +204,226 @@ export async function push(argv) {
     try {
         sortedTables = toposort.array(tableNames, tableEdges);
     }
-    catch (e) {
+    catch {
         sortedTables = tableNames.sort();
     }
     for (const name of sortedTables) {
         const sql = tables[name];
-        if (filterFiles.length > 0 && !filterFiles.includes(`tables/${name}.sql`))
+        if (!sql || skip('tables', name))
             continue;
-        if (liveSchema.tables[name] && canonicalize(sql) === canonicalize(liveSchema.tables[name]))
+        if (liveSchema.tables[name] && same(sql, liveSchema.tables[name]))
             continue;
-        madeDbChanges = true;
-        console.log(chalk.yellow(`\nPushing Table: ${name}`));
         if (liveSchema.tables[name]) {
-            const answer = await ask(chalk.white(`? Table '${name}' schema changed. Keep existing as backup? (Y/n) > `));
-            if (answer.toLowerCase() !== 'n') {
-                const timestamp = Math.floor(Date.now() / 1000);
+            // Table already exists — generate ALTER statements
+            const alterStmts = generateTableAlter(name, liveSchema.tables[name], sql);
+            if (alterStmts.length === 0)
+                continue; // Diff detected but no ALTER needed (e.g. only comment change)
+            console.log(chalk.yellow(`\nTable schema changed: ${name}`));
+            console.log(chalk.gray(`  Changes that will be applied (${alterStmts.length} statement${alterStmts.length > 1 ? 's' : ''}):`));
+            for (const s of alterStmts)
+                console.log(chalk.gray(`    → ${s}`));
+            console.log();
+            const answer = await ask(chalk.white(`  Apply smart ALTER in-place (data preserved) or backup + recreate?\n`) +
+                chalk.cyan(`  [A]lter (default)  `) +
+                chalk.yellow(`[B]ackup + recreate  `) +
+                chalk.red(`[D]rop + recreate (data loss)`) +
+                chalk.white(`\n  Choice [A/b/d] > `));
+            const choice = answer.trim().toLowerCase();
+            if (choice === 'b') {
                 const backupName = `${name}_backup_${timestamp}`;
-                await runQuery(projectRef, `ALTER TABLE public."${name}" RENAME TO "${backupName}";`);
-                console.log(chalk.green('Backup successful.'));
+                console.log(chalk.gray(`  → Will rename '${name}' → '${backupName}' then CREATE fresh.`));
+                plan.push({
+                    label: `Table (backup+recreate): ${name}`,
+                    sqls: [
+                        `ALTER TABLE public."${name}" RENAME TO "${backupName}";`,
+                        sql
+                    ]
+                });
+            }
+            else if (choice === 'd') {
+                console.log(chalk.red(`  → Will DROP '${name}' and recreate (all data lost).`));
+                plan.push({
+                    label: `Table (drop+recreate): ${name}`,
+                    sqls: [`DROP TABLE IF EXISTS public."${name}" CASCADE;`, sql]
+                });
             }
             else {
-                await runQuery(projectRef, `DROP TABLE IF EXISTS public."${name}" CASCADE;`);
+                // Default: smart ALTER — optionally with a pre-transaction data snapshot
+                const snapshotAnswer = await ask(chalk.white(`  Save a data snapshot of '${name}' before altering? (y/N) > `));
+                const wantsSnapshot = snapshotAnswer.trim().toLowerCase() === 'y';
+                const backupName = `${name}_snapshot_${timestamp}`;
+                if (wantsSnapshot) {
+                    console.log(chalk.gray(`  → Will snapshot data to '${backupName}', then ALTER in-place.`));
+                }
+                else {
+                    console.log(chalk.cyan(`  → Will ALTER in-place.`));
+                }
+                plan.push({
+                    label: `Table (ALTER): ${name}`,
+                    sqls: alterStmts,
+                    // Runs BEFORE the transaction so the copy survives if ALTER rolls back
+                    preTransactionSqls: wantsSnapshot
+                        ? [`CREATE TABLE public."${backupName}" AS SELECT * FROM public."${name}";`]
+                        : undefined
+                });
             }
         }
-        await runQuery(projectRef, sql);
+        else {
+            // New table — just CREATE it (no choice needed)
+            console.log(chalk.green(`\nNew table: ${name}`));
+            plan.push({ label: `Table (CREATE): ${name}`, sqls: [sql] });
+        }
     }
-    // VIEWS
+    // MATERIALIZED VIEWS
+    for (const [name, sql] of Object.entries(localSchema.matviews)) {
+        if (skip('matviews', name))
+            continue;
+        if (liveSchema.matviews[name] && same(sql, liveSchema.matviews[name]))
+            continue;
+        plan.push({
+            label: `Materialized View: ${name}`,
+            sqls: [`DROP MATERIALIZED VIEW IF EXISTS public."${name}" CASCADE;`, sql]
+        });
+    }
+    // VIEWS — CREATE OR REPLACE, no DROP needed
     for (const [name, sql] of Object.entries(localSchema.views)) {
-        if (filterFiles.length > 0 && !filterFiles.includes(`views/${name}.sql`))
+        if (skip('views', name))
             continue;
-        if (liveSchema.views[name] && canonicalize(sql) === canonicalize(liveSchema.views[name]))
+        if (liveSchema.views[name] && same(sql, liveSchema.views[name]))
             continue;
-        madeDbChanges = true;
-        console.log(chalk.cyan(`Pushing View: ${name}`));
-        await runQuery(projectRef, `DROP VIEW IF EXISTS public."${name}" CASCADE;`);
-        await runQuery(projectRef, sql);
+        // The stored SQL already contains CREATE OR REPLACE VIEW
+        plan.push({ label: `View: ${name}`, sqls: [sql] });
     }
-    // FUNCTIONS
+    // FUNCTIONS — support CREATE OR REPLACE, no drop needed
     for (const [name, sql] of Object.entries(localSchema.functions)) {
-        if (filterFiles.length > 0 && !filterFiles.includes(`functions/${name}.sql`))
+        if (skip('functions', name))
             continue;
-        if (liveSchema.functions[name] && canonicalize(sql) === canonicalize(liveSchema.functions[name]))
+        if (liveSchema.functions[name] && same(sql, liveSchema.functions[name]))
             continue;
-        madeDbChanges = true;
-        console.log(chalk.cyan(`Pushing Function: ${name}`));
-        await runQuery(projectRef, sql);
+        plan.push({ label: `Function: ${name}`, sqls: [sql] });
     }
     // TRIGGERS
     for (const [name, sql] of Object.entries(localSchema.triggers)) {
-        if (filterFiles.length > 0 && !filterFiles.includes(`triggers/${name}.sql`))
+        if (skip('triggers', name))
             continue;
-        if (liveSchema.triggers[name] && canonicalize(sql) === canonicalize(liveSchema.triggers[name]))
+        if (liveSchema.triggers[name] && same(sql, liveSchema.triggers[name]))
             continue;
-        madeDbChanges = true;
-        console.log(chalk.cyan(`Pushing Trigger: ${name}`));
         const match = sql.match(/ON\s+(public\.)?("?\w+"?)/i);
+        const triggerSqls = [];
         if (match) {
             const tableName = match[2].replace(/"/g, '');
-            await runQuery(projectRef, `DROP TRIGGER IF EXISTS "${name}" ON public."${tableName}";`);
+            triggerSqls.push(`DROP TRIGGER IF EXISTS "${name}" ON public."${tableName}";`);
         }
-        await runQuery(projectRef, sql);
+        triggerSqls.push(sql);
+        plan.push({ label: `Trigger: ${name}`, sqls: triggerSqls });
     }
     // POLICIES
     for (const [key, sql] of Object.entries(localSchema.policies)) {
-        if (filterFiles.length > 0 && !filterFiles.includes(`policies/${key}.sql`))
+        if (skip('policies', key))
             continue;
-        if (liveSchema.policies[key] && canonicalize(sql) === canonicalize(liveSchema.policies[key]))
+        if (liveSchema.policies[key] && same(sql, liveSchema.policies[key]))
             continue;
-        madeDbChanges = true;
         const match = sql.match(/CREATE POLICY "([^"]+)"\s+ON\s+(public\.)?("?\w+"?)/i);
         if (match) {
             const policyName = match[1];
             const tableName = match[3].replace(/"/g, '');
-            console.log(chalk.cyan(`Pushing Policy: ${policyName} on ${tableName}`));
-            try {
-                await runQuery(projectRef, `ALTER TABLE public."${tableName}" ENABLE ROW LEVEL SECURITY;`);
+            plan.push({
+                label: `Policy: ${policyName} on ${tableName}`,
+                sqls: [
+                    `ALTER TABLE public."${tableName}" ENABLE ROW LEVEL SECURITY;`,
+                    `DROP POLICY IF EXISTS "${policyName}" ON public."${tableName}";`,
+                    sql
+                ]
+            });
+        }
+    }
+    // GRANTS — REVOKE ALL from known roles first, then re-GRANT from snapshot
+    // This ensures stale grants are cleaned up alongside the re-grant.
+    for (const [key, sql] of Object.entries(localSchema.grants)) {
+        if (skip('grants', key))
+            continue;
+        if (liveSchema.grants[key] && same(sql, liveSchema.grants[key]))
+            continue;
+        const grantSqls = [];
+        // Parse out object type and name from the key (e.g. "table__profiles" or "function__my_func")
+        const isTable = key.startsWith('table__');
+        const isFunc = key.startsWith('function__');
+        const objName = key.replace(/^(table|function)__/, '');
+        // Collect all unique grantees from snapshot SQL to revoke from
+        const grantees = [...new Set((sql.match(/TO (\w+)/gi) || []).map(m => m.replace(/^TO /i, '')))];
+        if (grantees.length > 0) {
+            if (isTable) {
+                grantSqls.push(`REVOKE ALL PRIVILEGES ON TABLE public."${objName}" FROM ${grantees.join(', ')};`);
             }
-            catch (e) { }
-            await runQuery(projectRef, `DROP POLICY IF EXISTS "${policyName}" ON public."${tableName}";`);
-            await runQuery(projectRef, sql);
+            else if (isFunc) {
+                grantSqls.push(`REVOKE ALL PRIVILEGES ON FUNCTION public."${objName}" FROM ${grantees.join(', ')};`);
+            }
+        }
+        // Then re-apply each GRANT statement from the snapshot
+        for (const grantStmt of sql.split('\n').filter(Boolean)) {
+            grantSqls.push(grantStmt);
         }
+        plan.push({ label: `Grants on ${key.replace('__', ': ')}`, sqls: grantSqls });
+    }
+    // PUBLICATIONS
+    for (const [name, sql] of Object.entries(localSchema.publications)) {
+        if (skip('publications', name))
+            continue;
+        if (liveSchema.publications[name] && same(sql, liveSchema.publications[name]))
+            continue;
+        plan.push({
+            label: `Publication: ${name}`,
+            sqls: [`DROP PUBLICATION IF EXISTS "${name}";`, sql]
+        });
     }
     rl.close();
-    if (!madeDbChanges) {
+    if (plan.length === 0) {
         console.log(chalk.green('\nEverything is already up to date. No push required.'));
+        return;
+    }
+    // =========================================================================
+    // PHASE 2: EXECUTE — all statements in a single atomic transaction
+    // =========================================================================
+    console.log(chalk.blue(`\nApplying ${plan.length} change(s)...`));
+    for (const step of plan) {
+        const prefix = step.preTransactionSqls?.length ? '(+data snapshot) ' : '';
+        console.log(chalk.cyan(`  → ${prefix}${step.label}`));
+    }
+    // Run any pre-transaction data snapshots first (outside the transaction so they
+    // survive even if the subsequent ALTER rolls back)
+    const preSteps = plan.filter(p => p.preTransactionSqls?.length);
+    if (preSteps.length > 0) {
+        console.log(chalk.blue(`\nCreating ${preSteps.length} data snapshot(s) (outside transaction)...`));
+        try {
+            for (const step of preSteps) {
+                for (const sql of step.preTransactionSqls) {
+                    await runQuery(projectRef, sql);
+                    console.log(chalk.gray(`  ✓ ${sql}`));
+                }
+            }
+        }
+        catch (e) {
+            console.error(chalk.red(`\n🔥 Data snapshot failed — aborting push.`));
+            console.error(chalk.red(`   Reason: ${e.message}`));
+            return;
+        }
+    }
+    const allSqls = plan.flatMap(p => p.sqls);
+    try {
+        await runTransaction(projectRef, allSqls);
+        console.log(chalk.green('\n✅ Push complete! All changes applied atomically.'));
+        if (preSteps.length > 0) {
+            console.log(chalk.gray('   Data snapshot table(s) preserved. Drop them manually when no longer needed.'));
+        }
+    }
+    catch (e) {
+        console.error(chalk.red(`\n🔥 Push failed — database unchanged (transaction rolled back).`));
+        if (preSteps.length > 0) {
+            console.error(chalk.yellow(`   Data snapshot(s) were created before the failure and are still intact.`));
+        }
+        console.error(chalk.red(`   Reason: ${e.message}`));
     }
-    else {
-        console.log(chalk.green('\nPush complete! Live database updated.'));
+    finally {
+        await endPool(projectRef);
     }
 }