relq 1.0.0

package/dist/cjs/cli/utils/git-utils.cjs

@@ -0,0 +1,404 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = void 0;
+exports.error = error;
+exports.fatal = fatal;
+exports.warning = warning;
+exports.hint = hint;
+exports.success = success;
+exports.info = info;
+exports.getWorkingTreeStatus = getWorkingTreeStatus;
+exports.requireRepository = requireRepository;
+exports.requireCleanWorkingTree = requireCleanWorkingTree;
+exports.printDirtyWorkingTreeError = printDirtyWorkingTreeError;
+exports.detectConflicts = detectConflicts;
+exports.printConflictError = printConflictError;
+exports.checkUncommittedChanges = checkUncommittedChanges;
+exports.printMergeStrategyHelp = printMergeStrategyHelp;
+exports.validatePostgresSQL = validatePostgresSQL;
+exports.readSQLFile = readSQLFile;
+exports.createSpinner = createSpinner;
+exports.confirm = confirm;
+exports.select = select;
+exports.formatBytes = formatBytes;
+exports.formatDuration = formatDuration;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const repo_manager_1 = require("./repo-manager.cjs");
+const isColorSupported = process.stdout.isTTY && !process.env.NO_COLOR;
+exports.colors = {
+    red: (s) => isColorSupported ? `\x1b[31m${s}\x1b[0m` : s,
+    green: (s) => isColorSupported ? `\x1b[32m${s}\x1b[0m` : s,
+    yellow: (s) => isColorSupported ? `\x1b[33m${s}\x1b[0m` : s,
+    blue: (s) => isColorSupported ? `\x1b[34m${s}\x1b[0m` : s,
+    magenta: (s) => isColorSupported ? `\x1b[35m${s}\x1b[0m` : s,
+    cyan: (s) => isColorSupported ? `\x1b[36m${s}\x1b[0m` : s,
+    white: (s) => isColorSupported ? `\x1b[37m${s}\x1b[0m` : s,
+    gray: (s) => isColorSupported ? `\x1b[90m${s}\x1b[0m` : s,
+    bold: (s) => isColorSupported ? `\x1b[1m${s}\x1b[0m` : s,
+    dim: (s) => isColorSupported ? `\x1b[2m${s}\x1b[0m` : s,
+};
+function error(message) {
+    console.error(`${exports.colors.red('error:')} ${message}`);
+}
+function fatal(message) {
+    console.error(`${exports.colors.red('fatal:')} ${message}`);
+    process.exit(128);
+}
+function warning(message) {
+    console.error(`${exports.colors.yellow('warning:')} ${message}`);
+}
+function hint(message) {
+    console.log(`${exports.colors.yellow('hint:')} ${message}`);
+}
+function success(message) {
+    console.log(`${exports.colors.green('✓')} ${message}`);
+}
+function info(message) {
+    console.log(message);
+}
+function getWorkingTreeStatus(projectRoot = process.cwd()) {
+    const initialized = (0, repo_manager_1.isInitialized)(projectRoot);
+    const head = initialized ? (0, repo_manager_1.getHead)(projectRoot) : null;
+    const headCommit = head ? (0, repo_manager_1.loadCommit)(head, projectRoot) : null;
+    const staged = initialized ? (0, repo_manager_1.getStagedChanges)(projectRoot) : [];
+    const unstaged = initialized ? (0, repo_manager_1.getUnstagedChanges)(projectRoot) : [];
+    return {
+        isInitialized: initialized,
+        hasHead: !!head,
+        headHash: head,
+        headMessage: headCommit?.message || null,
+        stagedChanges: staged,
+        unstagedChanges: unstaged,
+        isClean: staged.length === 0 && unstaged.length === 0,
+        hasUncommittedChanges: staged.length > 0,
+        hasUnstagedChanges: unstaged.length > 0,
+    };
+}
+function requireRepository(projectRoot = process.cwd()) {
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        fatal('not a relq repository (or any of the parent directories): .relq');
+    }
+}
+function requireCleanWorkingTree(projectRoot = process.cwd(), operation = 'operation') {
+    const status = getWorkingTreeStatus(projectRoot);
+    if (status.isClean) {
+        return { clean: true };
+    }
+    const lines = [];
+    if (status.hasUnstagedChanges && status.hasUncommittedChanges) {
+        lines.push(`Your local changes would be overwritten by ${operation}.`);
+        lines.push(`Please commit your changes or stash them before you ${operation}.`);
+    }
+    else if (status.hasUncommittedChanges) {
+        lines.push(`You have uncommitted changes.`);
+        lines.push(`Please commit your changes before you ${operation}.`);
+    }
+    else {
+        lines.push(`You have unstaged changes.`);
+        lines.push(`Please stage and commit your changes before you ${operation}.`);
+    }
+    return { clean: false, message: lines.join('\n') };
+}
+function printDirtyWorkingTreeError(status, operation) {
+    console.log('');
+    if (status.hasUnstagedChanges && status.hasUncommittedChanges) {
+        error(`Your local changes would be overwritten by ${operation}.`);
+        hint(`Commit your changes or stash them before you ${operation}.`);
+    }
+    else if (status.hasUncommittedChanges) {
+        error(`You have uncommitted changes.`);
+        hint(`Please commit your changes before you ${operation}.`);
+    }
+    else {
+        error(`You have unstaged changes.`);
+        hint(`Please stage and commit your changes before you ${operation}.`);
+    }
+    console.log('');
+    if (status.hasUncommittedChanges) {
+        console.log(`Changes to be committed:`);
+        console.log(`  ${exports.colors.gray('(use "relq restore --staged <file>..." to unstage)')}`);
+        console.log('');
+        for (const change of status.stagedChanges.slice(0, 10)) {
+            const prefix = change.type === 'CREATE' ? 'new' : change.type === 'DROP' ? 'deleted' : 'modified';
+            const color = change.type === 'CREATE' ? exports.colors.green : change.type === 'DROP' ? exports.colors.red : exports.colors.yellow;
+            console.log(`\t${color(`${prefix}:`.padEnd(12))}${change.objectName}`);
+        }
+        if (status.stagedChanges.length > 10) {
+            console.log(`\t${exports.colors.gray(`... and ${status.stagedChanges.length - 10} more`)}`);
+        }
+        console.log('');
+    }
+    if (status.hasUnstagedChanges) {
+        console.log(`Changes not staged for commit:`);
+        console.log(`  ${exports.colors.gray('(use "relq add <file>..." to update what will be committed)')}`);
+        console.log(`  ${exports.colors.gray('(use "relq restore <file>..." to discard changes in working directory)')}`);
+        console.log('');
+        for (const change of status.unstagedChanges.slice(0, 10)) {
+            const prefix = change.type === 'CREATE' ? 'new' : change.type === 'DROP' ? 'deleted' : 'modified';
+            const color = change.type === 'CREATE' ? exports.colors.green : change.type === 'DROP' ? exports.colors.red : exports.colors.yellow;
+            console.log(`\t${color(`${prefix}:`.padEnd(12))}${change.objectName}`);
+        }
+        if (status.unstagedChanges.length > 10) {
+            console.log(`\t${exports.colors.gray(`... and ${status.unstagedChanges.length - 10} more`)}`);
+        }
+        console.log('');
+    }
+    console.log('Aborting.');
+}
+function detectConflicts(localChanges, incomingChanges) {
+    const conflicts = [];
+    const localByKey = new Map();
+    for (const change of localChanges) {
+        const key = `${change.objectType}:${change.parentName || ''}:${change.objectName}`;
+        localByKey.set(key, change);
+    }
+    const incomingByKey = new Map();
+    for (const change of incomingChanges) {
+        const key = `${change.objectType}:${change.parentName || ''}:${change.objectName}`;
+        incomingByKey.set(key, change);
+    }
+    for (const [key, localChange] of localByKey) {
+        const incomingChange = incomingByKey.get(key);
+        if (incomingChange) {
+            conflicts.push({
+                objectType: localChange.objectType,
+                objectName: localChange.objectName,
+                localChange,
+                incomingChange,
+            });
+        }
+    }
+    return {
+        hasConflicts: conflicts.length > 0,
+        conflicts,
+    };
+}
+function printConflictError(conflictInfo, operation) {
+    console.log('');
+    error(`Automatic ${operation} failed; fix conflicts and then commit the result.`);
+    console.log('');
+    console.log(`CONFLICT (content): Merge conflict in schema`);
+    console.log('');
+    for (const conflict of conflictInfo.conflicts.slice(0, 10)) {
+        console.log(`  ${exports.colors.red('both modified:')}   ${conflict.objectType.toLowerCase()} ${conflict.objectName}`);
+    }
+    if (conflictInfo.conflicts.length > 10) {
+        console.log(`  ${exports.colors.gray(`... and ${conflictInfo.conflicts.length - 10} more conflicts`)}`);
+    }
+    console.log('');
+    hint(`Fix conflicts manually and use:`);
+    hint(`  relq add .          - to mark resolution`);
+    hint(`  relq commit         - to complete the ${operation}`);
+    console.log('');
+    hint(`Or abort the ${operation} with:`);
+    hint(`  relq ${operation} --abort`);
+    console.log('');
+}
+function checkUncommittedChanges(projectRoot = process.cwd()) {
+    const status = getWorkingTreeStatus(projectRoot);
+    if (status.isClean) {
+        return { status: 'clean' };
+    }
+    if (status.hasUnstagedChanges) {
+        return { status: 'needs_staging', changes: status.unstagedChanges };
+    }
+    if (status.hasUncommittedChanges) {
+        return { status: 'needs_commit', changes: status.stagedChanges };
+    }
+    return { status: 'clean' };
+}
+function printMergeStrategyHelp() {
+    console.log('');
+    console.log('Resolution options:');
+    console.log(`  ${exports.colors.cyan('--theirs')}   Accept all incoming changes (overwrite local)`);
+    console.log(`  ${exports.colors.cyan('--ours')}     Keep all local changes (reject incoming)`);
+    console.log(`  ${exports.colors.cyan('--force')}    Force operation, overwrite local changes`);
+    console.log(`  ${exports.colors.cyan('--abort')}    Abort and restore previous state`);
+    console.log('');
+}
+function validatePostgresSQL(content) {
+    const errors = [];
+    const warnings = [];
+    if (!content.trim()) {
+        errors.push('SQL file is empty');
+        return { valid: false, errors, warnings };
+    }
+    const hasValidStatements = /\b(CREATE|ALTER|DROP|INSERT|UPDATE|DELETE|SELECT|GRANT|REVOKE|COMMENT)\b/i.test(content);
+    if (!hasValidStatements) {
+        errors.push('No valid SQL statements found');
+    }
+    let contentForQuoteCheck = content;
+    contentForQuoteCheck = contentForQuoteCheck.replace(/--[^\n]*/g, '');
+    contentForQuoteCheck = contentForQuoteCheck.replace(/\/\*[\s\S]*?\*\//g, '');
+    contentForQuoteCheck = contentForQuoteCheck.replace(/\$([a-zA-Z_]*)\$[\s\S]*?\$\1\$/g, '');
+    const openParens = (contentForQuoteCheck.match(/\(/g) || []).length;
+    const closeParens = (contentForQuoteCheck.match(/\)/g) || []).length;
+    if (Math.abs(openParens - closeParens) > 5) {
+        errors.push(`Significantly unbalanced parentheses: ${openParens} opening, ${closeParens} closing`);
+    }
+    const hasPostgresPatterns = (/\bSERIAL\b/i.test(content) ||
+        /\bTEXT\b/i.test(content) ||
+        /\bJSONB?\b/i.test(content) ||
+        /\bUUID\b/i.test(content) ||
+        /\bTIMESTAMPTZ\b/i.test(content) ||
+        /\bBOOLEAN\b/i.test(content) ||
+        /\bCREATE\s+TABLE\b/i.test(content) ||
+        /\bCREATE\s+TYPE\b/i.test(content) ||
+        /\bCREATE\s+EXTENSION\b/i.test(content));
+    if (!hasPostgresPatterns) {
+        warnings.push('No PostgreSQL-specific syntax detected. Ensure this is a PostgreSQL schema.');
+    }
+    if (/\bDROP\s+DATABASE\b/i.test(content)) {
+        warnings.push('Found DROP DATABASE statement - this may be dangerous');
+    }
+    if (/\bTRUNCATE\b/i.test(content)) {
+        warnings.push('Found TRUNCATE statement - this will delete data');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+function readSQLFile(filePath) {
+    const absolutePath = path.resolve(filePath);
+    if (!fs.existsSync(absolutePath)) {
+        return { error: `pathspec '${filePath}' did not match any files` };
+    }
+    const stat = fs.statSync(absolutePath);
+    if (stat.isDirectory()) {
+        return { error: `'${filePath}' is a directory, not a file` };
+    }
+    const content = fs.readFileSync(absolutePath, 'utf-8');
+    const validation = validatePostgresSQL(content);
+    return { content, validation };
+}
+function createSpinner() {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let frameIndex = 0;
+    let interval = null;
+    let currentMessage = '';
+    return {
+        start(message) {
+            currentMessage = message;
+            if (process.stdout.isTTY) {
+                interval = setInterval(() => {
+                    process.stdout.write(`\r${frames[frameIndex]} ${currentMessage}`);
+                    frameIndex = (frameIndex + 1) % frames.length;
+                }, 80);
+            }
+            else {
+                console.log(`  ${message}...`);
+            }
+        },
+        stop() {
+            if (interval) {
+                clearInterval(interval);
+                interval = null;
+                if (process.stdout.isTTY) {
+                    process.stdout.write('\r' + ' '.repeat(currentMessage.length + 4) + '\r');
+                }
+            }
+        },
+        succeed(message) {
+            this.stop();
+            console.log(`${exports.colors.green('✓')} ${message}`);
+        },
+        fail(message) {
+            this.stop();
+            console.log(`${exports.colors.red('✗')} ${message}`);
+        },
+        info(message) {
+            this.stop();
+            console.log(`${exports.colors.blue('ℹ')} ${message}`);
+        },
+    };
+}
+const readline = __importStar(require("readline"));
+function confirm(question, defaultYes = true) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const suffix = defaultYes ? '[Y/n]' : '[y/N]';
+    return new Promise((resolve) => {
+        rl.question(`${question} ${exports.colors.gray(suffix)} `, (answer) => {
+            rl.close();
+            const a = answer.trim().toLowerCase();
+            if (!a)
+                resolve(defaultYes);
+            else
+                resolve(a === 'y' || a === 'yes');
+        });
+    });
+}
+function select(question, options) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    console.log(question);
+    options.forEach((opt, i) => {
+        console.log(`  ${i + 1}) ${opt}`);
+    });
+    return new Promise((resolve) => {
+        rl.question(`${exports.colors.gray('Select [1-' + options.length + ']:')} `, (answer) => {
+            rl.close();
+            const num = parseInt(answer.trim(), 10);
+            if (num >= 1 && num <= options.length) {
+                resolve(num - 1);
+            }
+            else {
+                resolve(0);
+            }
+        });
+    });
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.floor(ms / 60000)}m ${Math.floor((ms % 60000) / 1000)}s`;
+}

package/dist/cjs/cli/utils/migration-generator.cjs

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMigration = generateMigration;
+exports.generateMigrationFile = generateMigrationFile;
+exports.getNextMigrationNumber = getNextMigrationNumber;
+exports.generateTimestampedName = generateTimestampedName;
+function generateMigration(diff, options = {}) {
+    const { includeDown = true } = options;
+    const up = [];
+    const down = [];
+    for (const table of diff.tables.filter(t => t.action === 'remove')) {
+        up.push(...generateDropTable(table));
+        if (includeDown && table.before) {
+            down.unshift(...generateCreateTable(table.before));
+        }
+    }
+    for (const table of diff.tables.filter(t => t.action === 'add')) {
+        if (table.after) {
+            up.push(...generateCreateTable(table.after));
+            if (includeDown) {
+                down.unshift(`DROP TABLE IF EXISTS "${table.name}" CASCADE;`);
+            }
+        }
+    }
+    for (const table of diff.tables.filter(t => t.action === 'modify')) {
+        const { upSQL, downSQL } = generateAlterTable(table, includeDown);
+        up.push(...upSQL);
+        down.unshift(...downSQL);
+    }
+    return { up, down };
+}
+function generateMigrationFile(diff, name, options = {}) {
+    const { message, includeComments = true } = options;
+    const { up, down } = generateMigration(diff, options);
+    const lines = [];
+    lines.push(`-- Migration: ${name}`);
+    if (message) {
+        lines.push(`-- ${message}`);
+    }
+    lines.push(`-- Generated: ${new Date().toISOString()}`);
+    lines.push('');
+    lines.push('-- UP');
+    if (up.length === 0) {
+        lines.push('-- No changes');
+    }
+    else {
+        if (includeComments) {
+            lines.push(`-- ${diff.summary.tablesAdded} tables added, ${diff.summary.tablesRemoved} removed, ${diff.summary.tablesModified} modified`);
+        }
+        lines.push('');
+        lines.push(...up);
+    }
+    lines.push('');
+    lines.push('-- DOWN');
+    if (down.length === 0) {
+        lines.push('-- No rollback');
+    }
+    else {
+        lines.push('');
+        lines.push(...down);
+    }
+    return {
+        name,
+        content: lines.join('\n'),
+        upSQL: up,
+        downSQL: down,
+    };
+}
+function generateCreateTable(table) {
+    const sql = [];
+    const columnDefs = [];
+    const constraintDefs = [];
+    for (const col of table.columns) {
+        columnDefs.push(`    ${generateColumnDefinition(col)}`);
+    }
+    const hasPKColumn = table.columns.some(c => c.isPrimaryKey);
+    for (const con of table.constraints || []) {
+        if (con.type === 'PRIMARY KEY' && hasPKColumn)
+            continue;
+        constraintDefs.push(`    CONSTRAINT "${con.name}" ${con.definition}`);
+    }
+    const allDefs = [...columnDefs, ...constraintDefs];
+    let createSQL = `CREATE TABLE "${table.name}" (\n${allDefs.join(',\n')}\n)`;
+    if (table.isPartitioned && table.partitionType && table.partitionKey?.length) {
+        createSQL += ` PARTITION BY ${table.partitionType} (${table.partitionKey.join(', ')})`;
+    }
+    sql.push(createSQL + ';');
+    for (const idx of table.indexes || []) {
+        if (idx.isPrimary)
+            continue;
+        sql.push(generateCreateIndex(table.name, idx));
+    }
+    return sql;
+}
+function generateDropTable(table) {
+    return [`DROP TABLE IF EXISTS "${table.name}" CASCADE;`];
+}
+function generateAlterTable(table, includeDown) {
+    const upSQL = [];
+    const downSQL = [];
+    const tableName = table.name;
+    for (const col of table.columns || []) {
+        const { up, down } = generateColumnChange(tableName, col);
+        upSQL.push(...up);
+        if (includeDown)
+            downSQL.unshift(...down);
+    }
+    for (const idx of table.indexes || []) {
+        const { up, down } = generateIndexChange(tableName, idx);
+        upSQL.push(...up);
+        if (includeDown)
+            downSQL.unshift(...down);
+    }
+    for (const con of table.constraints || []) {
+        const { up, down } = generateConstraintChange(tableName, con);
+        upSQL.push(...up);
+        if (includeDown)
+            downSQL.unshift(...down);
+    }
+    return { upSQL, downSQL };
+}
+function generateColumnDefinition(col) {
+    const parts = [`"${col.name}"`, mapDataType(col)];
+    if (col.isPrimaryKey) {
+        parts.push('PRIMARY KEY');
+    }
+    if (!col.isNullable && !col.isPrimaryKey) {
+        parts.push('NOT NULL');
+    }
+    if (col.isUnique && !col.isPrimaryKey) {
+        parts.push('UNIQUE');
+    }
+    if (col.defaultValue) {
+        parts.push(`DEFAULT ${col.defaultValue}`);
+    }
+    if (col.references) {
+        parts.push(`REFERENCES "${col.references.table}"("${col.references.column}")`);
+    }
+    return parts.join(' ');
+}
+function generateColumnChange(tableName, col) {
+    const up = [];
+    const down = [];
+    if (col.action === 'add' && col.after) {
+        up.push(`ALTER TABLE "${tableName}" ADD COLUMN ${generateColumnDefinition(col.after)};`);
+        down.push(`ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS "${col.name}";`);
+    }
+    if (col.action === 'remove' && col.before) {
+        up.push(`ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS "${col.name}";`);
+        down.push(`ALTER TABLE "${tableName}" ADD COLUMN ${generateColumnDefinition(col.before)};`);
+    }
+    if (col.action === 'modify' && col.changesV2 && col.before && col.after) {
+        if (col.changesV2.type) {
+            const newType = mapDataType(col.after);
+            up.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" TYPE ${newType} USING "${col.name}"::${newType};`);
+            down.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" TYPE ${mapDataType(col.before)} USING "${col.name}"::${mapDataType(col.before)};`);
+        }
+        if (col.changesV2.nullable) {
+            if (col.changesV2.nullable.to) {
+                up.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" DROP NOT NULL;`);
+                down.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" SET NOT NULL;`);
+            }
+            else {
+                up.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" SET NOT NULL;`);
+                down.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" DROP NOT NULL;`);
+            }
+        }
+        if (col.changesV2.default) {
+            if (col.changesV2.default.to) {
+                up.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" SET DEFAULT ${col.changesV2.default.to};`);
+            }
+            else {
+                up.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" DROP DEFAULT;`);
+            }
+            if (col.changesV2.default.from) {
+                down.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" SET DEFAULT ${col.changesV2.default.from};`);
+            }
+            else {
+                down.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" DROP DEFAULT;`);
+            }
+        }
+    }
+    return { up, down };
+}
+function generateCreateIndex(tableName, idx) {
+    const unique = idx.isUnique ? 'UNIQUE ' : '';
+    const cols = Array.isArray(idx.columns) ? idx.columns : [idx.columns];
+    const colList = cols.map(c => `"${c}"`).join(', ');
+    const using = idx.type && idx.type !== 'btree' ? ` USING ${idx.type}` : '';
+    return `CREATE ${unique}INDEX IF NOT EXISTS "${idx.name}" ON "${tableName}"${using} (${colList});`;
+}
+function generateIndexChange(tableName, idx) {
+    const up = [];
+    const down = [];
+    if (idx.action === 'add' && idx.after) {
+        up.push(generateCreateIndex(tableName, idx.after));
+        down.push(`DROP INDEX IF EXISTS "${idx.name}";`);
+    }
+    if (idx.action === 'remove' && idx.before) {
+        up.push(`DROP INDEX IF EXISTS "${idx.name}";`);
+        down.push(generateCreateIndex(tableName, idx.before));
+    }
+    return { up, down };
+}
+function generateConstraintChange(tableName, con) {
+    const up = [];
+    const down = [];
+    if (con.action === 'add' && con.after) {
+        up.push(`ALTER TABLE "${tableName}" ADD CONSTRAINT "${con.name}" ${con.after.definition};`);
+        down.push(`ALTER TABLE "${tableName}" DROP CONSTRAINT IF EXISTS "${con.name}";`);
+    }
+    if (con.action === 'remove' && con.before) {
+        up.push(`ALTER TABLE "${tableName}" DROP CONSTRAINT IF EXISTS "${con.name}";`);
+        down.push(`ALTER TABLE "${tableName}" ADD CONSTRAINT "${con.name}" ${con.before.definition};`);
+    }
+    return { up, down };
+}
+function mapDataType(col) {
+    let type = col.dataType.toUpperCase();
+    if ((type === 'VARCHAR' || type === 'CHARACTER VARYING') && col.maxLength) {
+        return `VARCHAR(${col.maxLength})`;
+    }
+    if ((type === 'CHAR' || type === 'CHARACTER' || type === 'BPCHAR') && col.maxLength) {
+        return `CHAR(${col.maxLength})`;
+    }
+    if ((type === 'NUMERIC' || type === 'DECIMAL') && col.precision) {
+        if (col.scale) {
+            return `NUMERIC(${col.precision}, ${col.scale})`;
+        }
+        return `NUMERIC(${col.precision})`;
+    }
+    const typeMap = {
+        'INT4': 'INTEGER',
+        'INT8': 'BIGINT',
+        'INT2': 'SMALLINT',
+        'FLOAT4': 'REAL',
+        'FLOAT8': 'DOUBLE PRECISION',
+        'BOOL': 'BOOLEAN',
+        'TIMESTAMPTZ': 'TIMESTAMP WITH TIME ZONE',
+        'TIMETZ': 'TIME WITH TIME ZONE',
+    };
+    return typeMap[type] || type;
+}
+function getNextMigrationNumber(migrationsDir) {
+    const fs = require('fs');
+    if (!fs.existsSync(migrationsDir)) {
+        return '001';
+    }
+    const files = fs.readdirSync(migrationsDir)
+        .filter((f) => f.endsWith('.sql'))
+        .sort();
+    if (files.length === 0) {
+        return '001';
+    }
+    const lastFile = files[files.length - 1];
+    const match = lastFile.match(/^(\d+)/);
+    if (match) {
+        const num = parseInt(match[1]) + 1;
+        return num.toString().padStart(3, '0');
+    }
+    return '001';
+}
+function generateTimestampedName(name) {
+    const now = new Date();
+    const timestamp = now.toISOString()
+        .replace(/[-:T]/g, '')
+        .slice(0, 14);
+    return `${timestamp}_${name.replace(/\s+/g, '_').toLowerCase()}`;
+}