@coldge.com/gitbase 1.0.2 → 1.0.3

package/dist/commands/revert.js

@@ -3,7 +3,10 @@ import path from 'path';
 import chalk from 'chalk';
 import readline from 'readline';
 import { readCommit, readTree, readObject } from '../storage/git.js';
-import { runQuery } from '../api/supabase.js';
+import { runQuery, runTransaction } from '../api/supabase.js';
+import { extractSchema } from '../schema/extractor.js';
+import { canonicalize, hashString } from '../utils/hashing.js';
+import { generateTableAlter, generateEnumAlter } from '../utils/sqlDiff.js';
 import toposort from 'toposort';
 const GITBASE_DIR = '.gitbase';
 const CONFIG_FILE = path.join(GITBASE_DIR, 'config');
@@ -13,7 +16,7 @@ export async function revert(argv) {
         await fs.access(CONFIG_FILE);
     }
     catch {
-        console.error(chalk.red('Not initialized.'));
+        console.error(chalk.red('Not initialized. Run `gitb init` first.'));
         return;
     }
     const config = JSON.parse(await fs.readFile(CONFIG_FILE, 'utf-8'));
@@ -51,169 +54,294 @@ export async function revert(argv) {
         console.error(chalk.red(`Commit ${commitHash} not found.`));
         return;
     }
-    console.log(chalk.blue(`Reverting to commit ${commitHash} (${commit.message})...`));
-    // 3. Fetch current live state to make smart decisions
-    console.log(chalk.blue(`Checking current database state...`));
-    const { extractSchema } = await import('../schema/extractor.js');
+    console.log(chalk.blue(`\nReverting to commit ${commitHash.substring(0, 7)} ("${commit.message}")...`));
+    console.log(chalk.blue(`Fetching current database state...`));
     const liveSchema = await extractSchema(projectRef);
-    // 4. Load Tree & Parse
+    // 3. Load stored schema from the target commit tree
     const tree = await readTree(commit.tree);
-    const schema = { tables: {}, functions: {}, views: {}, triggers: {}, policies: {}, types: {} };
+    const schema = {
+        types: {}, sequences: {}, tables: {}, matviews: {},
+        views: {}, functions: {}, triggers: {}, policies: {}
+    };
     const filterFiles = argv.files || [];
     for (const [relPath, hash] of Object.entries(tree)) {
         if (filterFiles.length > 0 && !filterFiles.includes(relPath))
             continue;
         const parts = relPath.split('/');
-        // relPath corresponds to file structure, e.g., "tables/users.sql"
         const type = parts[0];
         const name = path.basename(relPath, '.sql');
         const content = await readObject(hash);
-        if (schema[type]) {
+        if (schema[type] !== undefined) {
             schema[type][name] = content;
         }
     }
-    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));
-    // 4. Execution Plan
-    const { canonicalize } = await import('../utils/hashing.js');
-    let madeDbChanges = false;
-    // TYPES
+    const same = (a, b) => canonicalize(a) === canonicalize(b);
+    // =========================================================================
+    // PHASE 1: PLAN — determine all SQL changes, ask backup questions up front
+    // No DB writes happen in this phase.
+    // =========================================================================
+    const plan = [];
+    const timestamp = Math.floor(Date.now() / 1000);
+    // EXTENSIONS — safe to add, never drop
+    for (const [name, sql] of Object.entries(schema.extensions)) {
+        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(schema.types)) {
-        if (liveSchema.types[name] && canonicalize(sql) === canonicalize(liveSchema.types[name])) {
+        if (liveSchema.types[name] && same(sql, liveSchema.types[name]))
             continue;
+        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;
+            }
+            console.log(chalk.yellow(`\nEnum '${name}' has removed/reordered values — full recreation required.`));
         }
-        madeDbChanges = true;
-        console.log(chalk.cyan(`Restoring Type: ${name}`));
-        await runQuery(projectRef, `DROP TYPE IF EXISTS public."${name}" CASCADE;`);
-        await runQuery(projectRef, sql);
+        plan.push({
+            label: `Type: ${name}`,
+            sqls: [`DROP TYPE IF EXISTS public."${name}" CASCADE;`, sql]
+        });
     }
-    // TABLES (Topological Sort)
+    // SEQUENCES — IF NOT EXISTS to preserve sequence counter values
+    for (const [name, sql] of Object.entries(schema.sequences)) {
+        if (liveSchema.sequences[name] && same(sql, liveSchema.sequences[name]))
+            continue;
+        plan.push({ label: `Sequence: ${name}`, sqls: [sql] });
+    }
+    // TABLES — topological sort respecting FK dependencies
     const tableEdges = [];
     const tables = schema.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]); // target -> name
-            }
+            if (target !== name && tables[target])
+                tableEdges.push([target, name]);
         }
     }
     let sortedTables = tableNames;
     try {
         sortedTables = toposort.array(tableNames, tableEdges);
     }
-    catch (e) {
-        console.warn(chalk.yellow('Circular dependency detected in tables. Falling back to alphabetical order.'));
+    catch {
+        console.warn(chalk.yellow('Circular dependency detected — falling back to alphabetical order.'));
         sortedTables = tableNames.sort();
     }
     for (const name of sortedTables) {
         const sql = tables[name];
         if (!sql)
             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(`\nRestoring Table: ${name}`));
         if (liveSchema.tables[name]) {
-            const answer = await ask(chalk.white(`? Keep existing '${name}' table as backup? (Y/n) > `));
-            if (answer.toLowerCase() !== 'n') {
-                const timestamp = Math.floor(Date.now() / 1000);
+            // Table exists in live DB — generate ALTER statements
+            const alterStmts = generateTableAlter(name, liveSchema.tables[name], sql);
+            if (alterStmts.length === 0)
+                continue;
+            console.log(chalk.yellow(`\nTable schema differs: ${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}`;
-                console.log(chalk.gray(`Backing up to ${backupName}...`));
-                try {
-                    await runQuery(projectRef, `ALTER TABLE public."${name}" RENAME TO "${backupName}";`);
-                    console.log(chalk.green('Backup successful.'));
-                }
-                catch (e) {
-                    console.log(chalk.red(`Backup failed: ${e.message}`));
-                }
+                console.log(chalk.gray(`  → Will rename '${name}' → '${backupName}' then restore from snapshot.`));
+                plan.push({
+                    label: `Table (backup+restore): ${name}`,
+                    sqls: [
+                        `ALTER TABLE public."${name}" RENAME TO "${backupName}";`,
+                        sql
+                    ]
+                });
+            }
+            else if (choice === 'd') {
+                console.log(chalk.red(`  → Will DROP '${name}' and restore from snapshot (current data lost).`));
+                plan.push({
+                    label: `Table (drop+restore): ${name}`,
+                    sqls: [`DROP TABLE IF EXISTS public."${name}" CASCADE;`, sql]
+                });
             }
             else {
-                console.log(chalk.red(`Dropping table ${name}...`));
-                await runQuery(projectRef, `DROP TABLE IF EXISTS public."${name}" CASCADE;`);
+                // Default: smart ALTER — optionally with 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 snapshotName = `${name}_snapshot_${timestamp}`;
+                if (wantsSnapshot) {
+                    console.log(chalk.gray(`  → Will snapshot data to '${snapshotName}', then ALTER in-place.`));
+                }
+                else {
+                    console.log(chalk.cyan(`  → Will ALTER in-place.`));
+                }
+                plan.push({
+                    label: `Table (ALTER): ${name}`,
+                    sqls: alterStmts,
+                    preTransactionSqls: wantsSnapshot
+                        ? [`CREATE TABLE public."${snapshotName}" AS SELECT * FROM public."${name}";`]
+                        : undefined
+                });
             }
         }
         else {
-            console.log(chalk.gray(`Table '${name}' does not exist in live database. Skipping backup.`));
-        }
-        console.log(chalk.cyan(`Creating table ${name}...`));
-        try {
-            await runQuery(projectRef, sql);
-        }
-        catch (e) {
-            console.error(chalk.red(`Failed to create table: ${e.message}`));
+            // Table missing from live DB — restore from snapshot
+            console.log(chalk.green(`\nRestoring missing table: ${name}`));
+            plan.push({ label: `Table (RESTORE): ${name}`, sqls: [sql] });
         }
     }
-    // VIEWS
+    // MATERIALIZED VIEWS
+    for (const [name, sql] of Object.entries(schema.matviews)) {
+        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(schema.views)) {
-        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(`Restoring View: ${name}`));
-        await runQuery(projectRef, `DROP VIEW IF EXISTS public."${name}" CASCADE;`);
-        await runQuery(projectRef, sql);
+        plan.push({ label: `View: ${name}`, sqls: [sql] });
     }
-    // FUNCTIONS
+    // FUNCTIONS — CREATE OR REPLACE, no drop needed
     for (const [name, sql] of Object.entries(schema.functions)) {
-        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(`Restoring Function: ${name}`));
-        await runQuery(projectRef, sql);
+        plan.push({ label: `Function: ${name}`, sqls: [sql] });
     }
     // TRIGGERS
     for (const [name, sql] of Object.entries(schema.triggers)) {
-        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(`Restoring 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(schema.policies)) {
-        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(`Restoring Policy: ${policyName} on ${tableName}`));
-            // Auto-enable RLS just in case the table creation didn't include it (for backwards compatibility with older commits)
+            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 then re-GRANT
+    for (const [key, sql] of Object.entries(schema.grants)) {
+        if (liveSchema.grants[key] && same(sql, liveSchema.grants[key]))
+            continue;
+        const grantSqls = [];
+        const isTable = key.startsWith('table__');
+        const isFunc = key.startsWith('function__');
+        const objName = key.replace(/^(table|function)__/, '');
+        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(', ')};`);
+            }
+            else if (isFunc) {
+                grantSqls.push(`REVOKE ALL PRIVILEGES ON FUNCTION public."${objName}" FROM ${grantees.join(', ')};`);
+            }
+        }
+        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(schema.publications)) {
+        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 (plan.length === 0) {
+        console.log(chalk.green('\nNo database changes required. Live DB already matches this commit.'));
+    }
+    else {
+        // =====================================================================
+        // 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}`));
+        }
+        // Pre-transaction data snapshots — run 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)...`));
             try {
-                await runQuery(projectRef, `ALTER TABLE public."${tableName}" ENABLE ROW LEVEL SECURITY;`);
+                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 revert.`));
+                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✅ Database reset complete!'));
+            if (preSteps.length > 0) {
+                console.log(chalk.gray('   Data snapshot table(s) preserved. Drop them manually when no longer needed.'));
             }
-            catch (e) { }
-            await runQuery(projectRef, `DROP POLICY IF EXISTS "${policyName}" ON public."${tableName}";`);
-            await runQuery(projectRef, sql);
+        }
+        catch (e) {
+            console.error(chalk.red(`\n🔥 Revert 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}`));
+            return;
         }
     }
-    // 5. Update local working tree
-    // Clear existing supabase directory safely
+    // 5. Update local working tree to match the commit
     if (filterFiles.length === 0) {
         try {
             await fs.rm('supabase', { recursive: true, force: true });
         }
-        catch (e) { }
+        catch { }
     }
-    // Recreate files from tree
     for (const [relPath, hash] of Object.entries(tree)) {
         if (filterFiles.length > 0 && !filterFiles.includes(relPath))
             continue;
@@ -222,12 +350,36 @@ export async function revert(argv) {
         const content = await readObject(hash);
         await fs.writeFile(fullPath, content, 'utf-8');
     }
-    rl.close();
-    if (!madeDbChanges) {
-        console.log(chalk.green('\nNo database changes were required. The live database already matches this commit.'));
-    }
-    else {
-        console.log(chalk.green('\nDatabase reset complete!'));
+    console.log(chalk.gray('Local files synchronized with reverted state.'));
+    // 3.3 — Create a new commit recording this revert in history
+    // (mirrors git revert: creates a new commit rather than moving HEAD back)
+    if (filterFiles.length === 0) {
+        try {
+            const revertedHash = commitHash ?? 'HEAD';
+            const config = JSON.parse(await fs.readFile(CONFIG_FILE, 'utf-8'));
+            const currentHead = await fs.readFile(path.join(GITBASE_DIR, 'HEAD'), 'utf-8').catch(() => null);
+            // Re-use the reverted commit's tree directly
+            const revertedCommit = await readCommit(Array.isArray(revertedHash) ? revertedHash : commitHash);
+            const revertCommitObj = {
+                tree: revertedCommit.tree,
+                parent: currentHead,
+                message: `Revert to ${(commitHash ?? '').substring(0, 7)}`,
+                timestamp: new Date().toISOString(),
+                author: process.env.USERNAME || process.env.USER || 'unknown'
+            };
+            const revertCommitJson = JSON.stringify(revertCommitObj, null, 2);
+            const revertCommitHash = hashString(revertCommitJson);
+            await fs.mkdir(path.join(GITBASE_DIR, 'objects'), { recursive: true });
+            await fs.writeFile(path.join(GITBASE_DIR, 'objects', revertCommitHash), revertCommitJson, 'utf-8');
+            await fs.writeFile(path.join(GITBASE_DIR, 'HEAD'), revertCommitHash, 'utf-8');
+            if (config.branches && config.currentBranch) {
+                config.branches[config.currentBranch].head = revertCommitHash;
+                await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
+            }
+            console.log(chalk.green(`[${revertCommitHash.substring(0, 7)}] Revert to ${(commitHash ?? '').substring(0, 7)}`));
+        }
+        catch (e) {
+            console.warn(chalk.yellow(`Warning: could not create revert commit: ${e.message}`));
+        }
     }
-    console.log(chalk.gray('Local files have been synchronized.'));
 }

package/dist/commands/snapshot.js

@@ -0,0 +1,49 @@
+import chalk from 'chalk';
+import { pull } from './pull.js';
+import { commit } from './commit.js';
+export async function snapshot(argv) {
+    const intervalMinutes = argv.interval;
+    const intervalMs = intervalMinutes * 60 * 1000;
+    console.log(chalk.blue(`Starting GitBase snapshot daemon...`));
+    console.log(chalk.cyan(`Interval: Every ${intervalMinutes} minutes`));
+    console.log(chalk.gray(`Press Ctrl+C to exit.\n`));
+    // Force pull to require a manual run once if we want, or just auto-run immediately
+    await runSnapshotCycle();
+    setInterval(async () => {
+        await runSnapshotCycle();
+    }, intervalMs);
+}
+async function runSnapshotCycle() {
+    console.log(chalk.gray(`[${new Date().toISOString()}] Checking for database changes...`));
+    try {
+        // Run a silent status check (returns true if changes exist)
+        const hasChanges = await checkStatusSilent();
+        if (hasChanges) {
+            console.log(chalk.yellow(`  Changes detected in live database.`));
+            // 1. Pull changes
+            console.log(chalk.blue(`  Pulling changes...`));
+            await pull({ _: [], $0: '' }); // Simulate argv
+            // 2. Commit changes
+            const message = `Auto-snapshot: ${new Date().toISOString()}`;
+            console.log(chalk.blue(`  Committing: "${message}"`));
+            await commit({ message, _: [], $0: '' });
+            console.log(chalk.green(`  ✅ Snapshot complete.`));
+        }
+        else {
+            console.log(chalk.gray(`  No changes. Sleeping.`));
+        }
+    }
+    catch (e) {
+        console.error(chalk.red(`  ❌ Snapshot failed: ${e.message}`));
+    }
+}
+/**
+ * A modified version of status that returns a boolean instead of printing to stdout,
+ * so we can run it quietly.
+ */
+async function checkStatusSilent() {
+    const { getStatus } = await import('./status.js');
+    const changes = await getStatus(false);
+    // changes is an array like [{ type: 'modified', ... }]
+    return changes ? changes.length > 0 : false;
+}