@developer-ayushanand/dbgit 0.1.0-beta.1

package/dist/commands/rollback.d.ts

@@ -0,0 +1,6 @@
+export declare function rollbackCommand(hash: string, options: {
+    safe: boolean;
+    force: boolean;
+    dryRun: boolean;
+    softDelete: boolean;
+}): Promise<void>;

package/dist/commands/rollback.js

@@ -0,0 +1,187 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import prompts from 'prompts';
+import crypto from 'crypto';
+import boxen from 'boxen';
+import { isInitialized, getHead, loadCommit, loadSnapshot, setHead, loadConfig, saveCommit, saveSnapshot, saveBranch, loadBranch } from '../core/store.js';
+import { createPool, getConnectionConfig, query } from '../core/connector.js';
+import { captureSnapshot } from '../core/snapshot.js';
+import { diffSnapshots } from '../core/differ.js';
+import { validateSchemaNotDrifted } from '../core/validator.js';
+import { acquireLock, releaseLock } from '../core/schemaLock.js';
+import { createBackup } from '../core/backup.js';
+import { orderChanges } from '../core/dependencyGraph.js';
+import { generateForwardSQL } from '../core/generator.js';
+import { runInTransaction } from '../core/transaction.js';
+import { loadIgnoreList } from '../core/ignore.js';
+import { ChangeType } from '../types/changes.js';
+export async function rollbackCommand(hash, options) {
+    if (!isInitialized()) {
+        console.error(chalk.red("Not a DBGit repository. Run 'dbgit init' first."));
+        process.exit(1);
+    }
+    const head = getHead();
+    if (!head.commit) {
+        console.error(chalk.red("No commits to rollback from."));
+        process.exit(1);
+    }
+    const ignoreList = loadIgnoreList();
+    const config = getConnectionConfig();
+    const pool = createPool(config);
+    const dbConfig = loadConfig();
+    const isProd = dbConfig.DBGIT_MODE === 'prod';
+    try {
+        const targetCommit = loadCommit(hash);
+        const headCommit = loadCommit(head.commit);
+        const targetSnapshot = loadSnapshot(targetCommit.snapshotHash);
+        const spinner = ora('Validating schema...').start();
+        try {
+            await validateSchemaNotDrifted(pool, headCommit, ignoreList);
+        }
+        catch (e) {
+            spinner.fail(chalk.red(e.message));
+            await pool.end();
+            process.exit(1);
+        }
+        spinner.succeed('Schema validation passed.');
+        const liveSnapshot = await captureSnapshot(pool, ignoreList);
+        const changeset = diffSnapshots(liveSnapshot, targetSnapshot);
+        if (changeset.changes.length === 0) {
+            console.log(chalk.gray("ℹ Database schema is already at target state."));
+            await pool.end();
+            return;
+        }
+        if (changeset.hasDestructive) {
+            const destructiveChanges = changeset.changes.filter(c => c.isDestructive);
+            const allFks = Object.values(liveSnapshot.tables).flatMap(t => t.foreignKeys);
+            let impactReport = chalk.yellow('⚠ DESTRUCTIVE CHANGES DETECTED\n\n');
+            for (const change of destructiveChanges) {
+                let impact = '';
+                let dependencies = [];
+                if (change.type === ChangeType.DROP_TABLE) {
+                    const rows = await query(pool, `SELECT count(*) FROM "${change.table}"`);
+                    impact = `${rows[0].count} rows`;
+                    dependencies = allFks
+                        .filter(fk => fk.targetTable === change.table)
+                        .map(fk => `${fk.sourceTable}.${fk.sourceColumn}`);
+                }
+                else if (change.type === ChangeType.DROP_COLUMN) {
+                    const rows = await query(pool, `SELECT count(*) FROM "${change.table}" WHERE "${change.objectName}" IS NOT NULL`);
+                    impact = `${rows[0].count} non-null rows`;
+                    dependencies = allFks
+                        .filter(fk => fk.targetTable === change.table && fk.targetColumn === change.objectName)
+                        .map(fk => `${fk.sourceTable}.${fk.sourceColumn}`);
+                }
+                impactReport += chalk.red(`✗ ${change.type}: ${change.table}${change.objectName ? '.' + change.objectName : ''}\n`);
+                impactReport += chalk.gray(`  Impact: ${impact}\n`);
+                if (dependencies.length > 0) {
+                    impactReport += chalk.red(`  Referenced by: ${dependencies.join(', ')}\n`);
+                }
+                impactReport += '\n';
+            }
+            console.log(boxen(impactReport.trim(), { padding: 1, borderColor: 'red', title: 'Rollback Risk: HIGH' }));
+            if (isProd) {
+                if (!options.safe) {
+                    console.error(chalk.red("\nError: Production mode. Backup is mandatory for destructive operations. Use --safe."));
+                    process.exit(1);
+                }
+            }
+            else {
+                if (!options.force && !options.safe) {
+                    const response = await prompts({
+                        type: 'confirm',
+                        name: 'value',
+                        message: 'Continue with destructive rollback?',
+                        initial: false
+                    });
+                    if (!response.value) {
+                        console.log(chalk.gray('Rollback aborted.'));
+                        process.exit(1);
+                    }
+                }
+            }
+            if (options.force && !isProd) {
+                const response = await prompts({
+                    type: 'text',
+                    name: 'confirm',
+                    message: 'Type DESTROY DATA to continue:'
+                });
+                if (response.confirm !== 'DESTROY DATA') {
+                    console.log(chalk.gray('Rollback aborted.'));
+                    process.exit(1);
+                }
+            }
+            if (options.safe) {
+                const backupSpinner = ora('Creating backup...').start();
+                const backupPath = await createBackup(head.commit, config);
+                if (backupPath) {
+                    backupSpinner.succeed(`Backup created: ${backupPath}`);
+                }
+                else {
+                    backupSpinner.warn('Backup skipped or failed.');
+                }
+            }
+        }
+        const orderedChanges = orderChanges(changeset.changes, liveSnapshot);
+        let sqlStatements = generateForwardSQL({ ...changeset, changes: orderedChanges });
+        if (options.softDelete) {
+            const timestamp = Date.now();
+            sqlStatements = sqlStatements.map(sql => {
+                if (sql.startsWith('DROP TABLE')) {
+                    const tableName = sql.replace('DROP TABLE ', '').trim();
+                    return `ALTER TABLE ${tableName} RENAME TO _dbgit_deleted_${tableName.replace(/"/g, '')}_${timestamp}`;
+                }
+                if (sql.includes('DROP COLUMN')) {
+                    const match = sql.match(/ALTER TABLE (.*) DROP COLUMN (.*)/);
+                    if (match) {
+                        return `ALTER TABLE ${match[1].trim()} RENAME COLUMN ${match[2].trim()} TO _dbgit_deleted_${match[2].trim().replace(/"/g, '')}_${timestamp}`;
+                    }
+                }
+                return sql;
+            });
+        }
+        if (options.dryRun) {
+            console.log(chalk.blue('\nDry run: SQL statements that would be executed:'));
+            sqlStatements.forEach(sql => console.log(chalk.gray(sql)));
+            console.log(chalk.green('\nDry run complete. Nothing executed.'));
+            await pool.end();
+            return;
+        }
+        await acquireLock(pool);
+        const applySpinner = ora('Applying rollback...').start();
+        try {
+            await runInTransaction(pool, sqlStatements);
+            // Create a NEW commit for the rollback
+            const newCommitHash = crypto.createHash('sha256').update(Date.now().toString() + hash).digest('hex').substring(0, 7);
+            const rollbackCommit = {
+                commitHash: newCommitHash,
+                snapshotHash: targetCommit.snapshotHash,
+                parent: head.commit,
+                timestamp: new Date().toISOString(),
+                message: `rollback: restore schema state from ${hash.substring(0, 7)}`,
+                branch: head.branch,
+                schemaHash: targetCommit.schemaHash,
+                type: 'rollback',
+                targetCommit: hash
+            };
+            saveSnapshot(targetCommit.snapshotHash, targetSnapshot); // Ensure snapshot is saved for the new commit
+            saveCommit(rollbackCommit);
+            const newHead = { ...head, commit: newCommitHash };
+            setHead(newHead);
+            if (head.branch) {
+                const branch = loadBranch(head.branch);
+                branch.headCommit = newCommitHash;
+                saveBranch(branch);
+            }
+            applySpinner.succeed(chalk.green(`Rolled back to ${hash.substring(0, 7)}. New commit ${newCommitHash} created.`));
+        }
+        finally {
+            await releaseLock(pool);
+        }
+        await pool.end();
+    }
+    catch (e) {
+        console.error(chalk.red(`Rollback failed: ${e.message}`));
+        process.exit(1);
+    }
+}

package/dist/core/backup.d.ts

@@ -0,0 +1,5 @@
+import { ConnectionConfig } from './connector.js';
+export declare function createBackup(hash: string, config: ConnectionConfig): Promise<string>;
+export declare function listBackups(): string[];
+export declare function backupExists(hash: string): boolean;
+export declare function getRestoreCommand(hash: string, config: ConnectionConfig): string;

package/dist/core/backup.js

@@ -0,0 +1,40 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import { getBackupsDir } from './store.js';
+export async function createBackup(hash, config) {
+    const backupDir = path.join(getBackupsDir(), hash);
+    if (!fs.existsSync(backupDir)) {
+        fs.mkdirSync(backupDir, { recursive: true });
+    }
+    const backupFile = path.join(backupDir, 'backup.sql');
+    const env = {
+        ...process.env,
+        PGPASSWORD: config.password
+    };
+    const command = `pg_dump -h ${config.host} -p ${config.port} -U ${config.user} -d ${config.database} -f "${backupFile}"`;
+    try {
+        execSync(command, { env, stdio: 'pipe' });
+        return backupFile;
+    }
+    catch (error) {
+        if (error.message.includes('pg_dump: not found') || error.message.includes('command not found')) {
+            console.warn("pg_dump not found. Install PostgreSQL client tools and ensure pg_dump is in your PATH. Skipping backup.");
+            return '';
+        }
+        throw error;
+    }
+}
+export function listBackups() {
+    const backupsDir = getBackupsDir();
+    if (!fs.existsSync(backupsDir))
+        return [];
+    return fs.readdirSync(backupsDir);
+}
+export function backupExists(hash) {
+    return fs.existsSync(path.join(getBackupsDir(), hash, 'backup.sql'));
+}
+export function getRestoreCommand(hash, config) {
+    const backupFile = path.join(getBackupsDir(), hash, 'backup.sql');
+    return `psql -h ${config.host} -p ${config.port} -U ${config.user} -d ${config.database} -f "${backupFile}"`;
+}

package/dist/core/connector.d.ts

@@ -0,0 +1,13 @@
+import pg from 'pg';
+export interface ConnectionConfig {
+    host?: string;
+    port?: number;
+    database?: string;
+    user?: string;
+    password?: string;
+    ssl?: boolean;
+    connectionString?: string;
+}
+export declare function getConnectionConfig(): ConnectionConfig;
+export declare function createPool(config: ConnectionConfig): pg.Pool;
+export declare function query<T>(pool: pg.Pool, sql: string, params?: unknown[]): Promise<T[]>;

package/dist/core/connector.js

@@ -0,0 +1,39 @@
+import pg from 'pg';
+const { Pool } = pg;
+import { loadConfig } from './store.js';
+export function getConnectionConfig() {
+    const storedConfig = loadConfig();
+    // 1. DATABASE_URL
+    if (process.env.DATABASE_URL) {
+        return { connectionString: process.env.DATABASE_URL };
+    }
+    // 2. DBGIT_DATABASE_URL
+    if (process.env.DBGIT_DATABASE_URL) {
+        return { connectionString: process.env.DBGIT_DATABASE_URL };
+    }
+    // 3. .dbgit/config databaseUrl (if we support it there in the future, for now it might be in individual fields)
+    if (storedConfig.databaseUrl) {
+        return { connectionString: storedConfig.databaseUrl };
+    }
+    // 4. Legacy individual variables (Env first, then config)
+    const host = process.env.DBGIT_HOST || storedConfig.DBGIT_HOST || 'localhost';
+    const port = parseInt(process.env.DBGIT_PORT || storedConfig.DBGIT_PORT || '5432', 10);
+    const database = process.env.DBGIT_DATABASE || storedConfig.DBGIT_DATABASE || '';
+    const user = process.env.DBGIT_USER || storedConfig.DBGIT_USER || '';
+    const password = process.env.DBGIT_PASSWORD || storedConfig.DBGIT_PASSWORD;
+    const ssl = (process.env.DBGIT_SSL === 'true') || (storedConfig.DBGIT_SSL === 'true') || false;
+    return { host, port, database, user, password, ssl };
+}
+export function createPool(config) {
+    if (config.connectionString) {
+        return new Pool({ connectionString: config.connectionString });
+    }
+    if (!config.database || !config.user) {
+        throw new Error('Database name and user are required. Set DATABASE_URL or individual DBGIT_* env vars.');
+    }
+    return new Pool(config);
+}
+export async function query(pool, sql, params) {
+    const res = await pool.query(sql, params);
+    return res.rows;
+}

package/dist/core/dependencyGraph.d.ts

@@ -0,0 +1,5 @@
+import { ForeignKey, SchemaSnapshot } from '../types/schema.js';
+import { Change } from '../types/changes.js';
+export declare function orderForDeletion(tables: string[], foreignKeys: ForeignKey[]): string[];
+export declare function orderForCreation(tables: string[], foreignKeys: ForeignKey[]): string[];
+export declare function orderChanges(changes: Change[], snapshot: SchemaSnapshot): Change[];

package/dist/core/dependencyGraph.js

@@ -0,0 +1,87 @@
+import { ChangeType } from '../types/changes.js';
+export function orderForDeletion(tables, foreignKeys) {
+    // Kahn's algorithm for topological sort
+    // For deletion, we want to delete tables that are NOT referenced by others first.
+    // Dependencies: targetTable -> sourceTable (target must exist for source to exist)
+    // For deletion: sourceTable must be deleted before targetTable if there is an FK from source to target.
+    const adj = new Map();
+    const inDegree = new Map();
+    tables.forEach(t => {
+        adj.set(t, []);
+        inDegree.set(t, 0);
+    });
+    foreignKeys.forEach(fk => {
+        if (adj.has(fk.sourceTable) && adj.has(fk.targetTable)) {
+            adj.get(fk.sourceTable).push(fk.targetTable);
+            inDegree.set(fk.targetTable, (inDegree.get(fk.targetTable) || 0) + 1);
+        }
+    });
+    const queue = [];
+    inDegree.forEach((degree, table) => {
+        if (degree === 0)
+            queue.push(table);
+    });
+    const result = [];
+    while (queue.length > 0) {
+        const u = queue.shift();
+        result.push(u);
+        adj.get(u)?.forEach(v => {
+            inDegree.set(v, inDegree.get(v) - 1);
+            if (inDegree.get(v) === 0)
+                queue.push(v);
+        });
+    }
+    // Any tables not in result are part of a cycle (shouldn't happen with FKs normally)
+    const remaining = tables.filter(t => !result.includes(t));
+    return [...result, ...remaining];
+}
+export function orderForCreation(tables, foreignKeys) {
+    return orderForDeletion(tables, foreignKeys).reverse();
+}
+export function orderChanges(changes, snapshot) {
+    // Order:
+    // 1. DROP_FOREIGN_KEY
+    // 2. DROP_CONSTRAINT
+    // 3. DROP_INDEX
+    // 4. DROP_COLUMN
+    // 5. DROP_TABLE (topologically ordered)
+    // 6. MODIFY_COLUMN
+    // 7. ADD_TABLE (topologically ordered)
+    // 8. ADD_COLUMN
+    // 9. ADD_INDEX
+    // 10. ADD_CONSTRAINT
+    // 11. ADD_FOREIGN_KEY
+    const dropFks = changes.filter(c => c.type === ChangeType.DROP_FOREIGN_KEY);
+    const dropConstraints = changes.filter(c => c.type === ChangeType.DROP_CONSTRAINT);
+    const dropIndexes = changes.filter(c => c.type === ChangeType.DROP_INDEX);
+    const dropColumns = changes.filter(c => c.type === ChangeType.DROP_COLUMN);
+    const dropTables = changes.filter(c => c.type === ChangeType.DROP_TABLE);
+    const modifyColumns = changes.filter(c => c.type === ChangeType.MODIFY_COLUMN);
+    const addTables = changes.filter(c => c.type === ChangeType.ADD_TABLE);
+    const addColumns = changes.filter(c => c.type === ChangeType.ADD_COLUMN);
+    const addIndexes = changes.filter(c => c.type === ChangeType.ADD_INDEX);
+    const addConstraints = changes.filter(c => c.type === ChangeType.ADD_CONSTRAINT);
+    const addFks = changes.filter(c => c.type === ChangeType.ADD_FOREIGN_KEY);
+    // Topologically sort dropTables
+    const allFks = Object.values(snapshot.tables).flatMap(t => t.foreignKeys);
+    const dropTableNames = dropTables.map(c => c.table);
+    const sortedDropTableNames = orderForDeletion(dropTableNames, allFks);
+    const sortedDropTables = sortedDropTableNames.map(name => dropTables.find(c => c.table === name));
+    // Topologically sort addTables
+    const addTableNames = addTables.map(c => c.table);
+    const sortedAddTableNames = orderForCreation(addTableNames, allFks);
+    const sortedAddTables = sortedAddTableNames.map(name => addTables.find(c => c.table === name));
+    return [
+        ...dropFks,
+        ...dropConstraints,
+        ...dropIndexes,
+        ...dropColumns,
+        ...sortedDropTables,
+        ...modifyColumns,
+        ...sortedAddTables,
+        ...addColumns,
+        ...addIndexes,
+        ...addConstraints,
+        ...addFks
+    ];
+}

package/dist/core/differ.d.ts

@@ -0,0 +1,3 @@
+import { SchemaSnapshot } from '../types/schema.js';
+import { ChangeSet } from '../types/changes.js';
+export declare function diffSnapshots(from: SchemaSnapshot, to: SchemaSnapshot): ChangeSet;

package/dist/core/differ.js

@@ -0,0 +1,218 @@
+import { ChangeType } from '../types/changes.js';
+export function diffSnapshots(from, to) {
+    const changes = [];
+    const fromTables = Object.keys(from.tables);
+    const toTables = Object.keys(to.tables);
+    // Tables to drop
+    for (const tableName of fromTables) {
+        if (!to.tables[tableName]) {
+            changes.push({
+                type: ChangeType.DROP_TABLE,
+                table: tableName,
+                before: from.tables[tableName],
+                isDestructive: true
+            });
+        }
+    }
+    // Tables to add or modify
+    for (const tableName of toTables) {
+        const fromTable = from.tables[tableName];
+        const toTable = to.tables[tableName];
+        if (!fromTable) {
+            changes.push({
+                type: ChangeType.ADD_TABLE,
+                table: tableName,
+                after: toTable,
+                isDestructive: false
+            });
+            // All columns, indexes etc in this table are part of ADD_TABLE
+            continue;
+        }
+        // Diff columns
+        diffColumns(fromTable, toTable, changes);
+        // Diff indexes
+        diffIndexes(fromTable, toTable, changes);
+        // Diff constraints
+        diffConstraints(fromTable, toTable, changes);
+        // Diff foreign keys
+        diffForeignKeys(fromTable, toTable, changes);
+    }
+    return {
+        changes,
+        hasDestructive: changes.some(c => c.isDestructive)
+    };
+}
+function diffColumns(from, to, changes) {
+    const fromCols = new Map(from.columns.map(c => [c.name, c]));
+    const toCols = new Map(to.columns.map(c => [c.name, c]));
+    for (const [name, col] of fromCols) {
+        if (!toCols.has(name)) {
+            changes.push({
+                type: ChangeType.DROP_COLUMN,
+                table: from.name,
+                objectName: name,
+                before: col,
+                isDestructive: true
+            });
+        }
+    }
+    for (const [name, col] of toCols) {
+        const fromCol = fromCols.get(name);
+        if (!fromCol) {
+            changes.push({
+                type: ChangeType.ADD_COLUMN,
+                table: to.name,
+                objectName: name,
+                after: col,
+                isDestructive: false
+            });
+        }
+        else if (fromCol.type !== col.type || fromCol.nullable !== col.nullable || fromCol.default !== col.default) {
+            changes.push({
+                type: ChangeType.MODIFY_COLUMN,
+                table: to.name,
+                objectName: name,
+                before: fromCol,
+                after: col,
+                isDestructive: false // Usually not destructive, but can be
+            });
+        }
+    }
+}
+function diffIndexes(from, to, changes) {
+    const fromIdx = new Map(from.indexes.map(i => [i.name, i]));
+    const toIdx = new Map(to.indexes.map(i => [i.name, i]));
+    for (const [name, idx] of fromIdx) {
+        if (!toIdx.has(name)) {
+            changes.push({
+                type: ChangeType.DROP_INDEX,
+                table: from.name,
+                objectName: name,
+                before: idx,
+                isDestructive: false
+            });
+        }
+    }
+    for (const [name, idx] of toIdx) {
+        const fromIdxObj = fromIdx.get(name);
+        if (!fromIdxObj) {
+            changes.push({
+                type: ChangeType.ADD_INDEX,
+                table: to.name,
+                objectName: name,
+                after: idx,
+                isDestructive: false
+            });
+        }
+        else if (JSON.stringify(fromIdxObj) !== JSON.stringify(idx)) {
+            changes.push({
+                type: ChangeType.DROP_INDEX,
+                table: from.name,
+                objectName: name,
+                before: fromIdxObj,
+                isDestructive: false
+            });
+            changes.push({
+                type: ChangeType.ADD_INDEX,
+                table: to.name,
+                objectName: name,
+                after: idx,
+                isDestructive: false
+            });
+        }
+    }
+}
+function diffConstraints(from, to, changes) {
+    const fromCons = new Map(from.constraints.map(c => [c.name, c]));
+    const toCons = new Map(to.constraints.map(c => [c.name, c]));
+    for (const [name, con] of fromCons) {
+        if (!toCons.has(name)) {
+            changes.push({
+                type: ChangeType.DROP_CONSTRAINT,
+                table: from.name,
+                objectName: name,
+                before: con,
+                beforeTable: from,
+                isDestructive: false
+            });
+        }
+    }
+    for (const [name, con] of toCons) {
+        const fromCon = fromCons.get(name);
+        if (!fromCon) {
+            changes.push({
+                type: ChangeType.ADD_CONSTRAINT,
+                table: to.name,
+                objectName: name,
+                after: con,
+                afterTable: to,
+                isDestructive: false
+            });
+        }
+        else if (JSON.stringify(fromCon) !== JSON.stringify(con)) {
+            changes.push({
+                type: ChangeType.DROP_CONSTRAINT,
+                table: from.name,
+                objectName: name,
+                before: fromCon,
+                beforeTable: from,
+                isDestructive: false
+            });
+            changes.push({
+                type: ChangeType.ADD_CONSTRAINT,
+                table: to.name,
+                objectName: name,
+                after: con,
+                afterTable: to,
+                isDestructive: false
+            });
+        }
+    }
+}
+function diffForeignKeys(from, to, changes) {
+    const fromFks = new Map(from.foreignKeys.map(f => [f.name, f]));
+    const toFks = new Map(to.foreignKeys.map(f => [f.name, f]));
+    for (const [name, fk] of fromFks) {
+        if (!toFks.has(name)) {
+            changes.push({
+                type: ChangeType.DROP_FOREIGN_KEY,
+                table: from.name,
+                objectName: name,
+                before: fk,
+                beforeTable: from,
+                isDestructive: true
+            });
+        }
+    }
+    for (const [name, fk] of toFks) {
+        const fromFk = fromFks.get(name);
+        if (!fromFk) {
+            changes.push({
+                type: ChangeType.ADD_FOREIGN_KEY,
+                table: to.name,
+                objectName: name,
+                after: fk,
+                afterTable: to,
+                isDestructive: false
+            });
+        }
+        else if (JSON.stringify(fromFk) !== JSON.stringify(fk)) {
+            changes.push({
+                type: ChangeType.DROP_FOREIGN_KEY,
+                table: from.name,
+                objectName: name,
+                before: fromFk,
+                beforeTable: from,
+                isDestructive: true
+            });
+            changes.push({
+                type: ChangeType.ADD_FOREIGN_KEY,
+                table: to.name,
+                objectName: name,
+                after: fk,
+                afterTable: to,
+                isDestructive: false
+            });
+        }
+    }
+}

package/dist/core/generator.d.ts

@@ -0,0 +1,3 @@
+import { ChangeSet } from '../types/changes.js';
+export declare function generateForwardSQL(changeset: ChangeSet): string[];
+export declare function generateInverseSQL(changeset: ChangeSet): string[];