relq 1.0.0

package/dist/cjs/cli/commands/history.cjs

@@ -0,0 +1,165 @@
+"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.historyCommand = historyCommand;
+const fs = __importStar(require("fs"));
+const config_loader_1 = require("../utils/config-loader.cjs");
+const env_loader_1 = require("../utils/env-loader.cjs");
+const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+};
+async function historyCommand(context) {
+    const { config, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    (0, config_loader_1.requireValidConfig)(config);
+    const connection = config.connection;
+    const migrationsDir = config.migrations?.directory || './migrations';
+    const tableName = config.migrations?.tableName || '_relq_migrations';
+    const limit = parseInt(flags['n']) || 20;
+    console.log(`${colors.bold}Migration History${colors.reset}`);
+    console.log(`Database: ${(0, env_loader_1.getConnectionDescription)(connection)}`);
+    console.log('');
+    try {
+        const migrationFiles = getMigrationFiles(migrationsDir);
+        const appliedMigrations = await getAppliedMigrations(connection, tableName);
+        const history = [];
+        for (const file of migrationFiles) {
+            const applied = appliedMigrations.find(m => m.name === file);
+            history.push({
+                name: file,
+                appliedAt: applied?.appliedAt || null,
+                pending: !applied,
+            });
+        }
+        history.sort((a, b) => b.name.localeCompare(a.name));
+        const toShow = history.slice(0, limit);
+        const pendingCount = history.filter(h => h.pending).length;
+        const appliedCount = history.filter(h => !h.pending).length;
+        console.log(`${colors.dim}Showing ${toShow.length} of ${history.length} migrations${colors.reset}`);
+        console.log(`${colors.green}${appliedCount} applied${colors.reset}, ${colors.yellow}${pendingCount} pending${colors.reset}`);
+        console.log('');
+        for (const record of toShow) {
+            if (record.pending) {
+                console.log(`${colors.yellow}○ ${record.name}${colors.reset} ${colors.dim}(pending)${colors.reset}`);
+            }
+            else {
+                const date = record.appliedAt ? formatDate(record.appliedAt) : '';
+                console.log(`${colors.green}● ${record.name}${colors.reset} ${colors.dim}${date}${colors.reset}`);
+            }
+        }
+        if (history.length > limit) {
+            console.log('');
+            console.log(`${colors.dim}Use "relq history -n ${history.length}" to see all.${colors.reset}`);
+        }
+    }
+    catch (error) {
+        if (error?.code === '42P01') {
+            console.log(`${colors.yellow}No migration table found.${colors.reset}`);
+            console.log(`Run "${colors.cyan}relq push${colors.reset}" to initialize.`);
+            console.log('');
+            const files = getMigrationFiles(migrationsDir);
+            if (files.length > 0) {
+                console.log(`${colors.bold}Pending migrations:${colors.reset}`);
+                for (const file of files.slice(0, limit)) {
+                    console.log(`  ${colors.yellow}○ ${file}${colors.reset}`);
+                }
+            }
+            else {
+                console.log(`${colors.dim}No migration files found.${colors.reset}`);
+            }
+            return;
+        }
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+function getMigrationFiles(migrationsDir) {
+    if (!fs.existsSync(migrationsDir)) {
+        return [];
+    }
+    return fs.readdirSync(migrationsDir)
+        .filter(f => f.endsWith('.sql'))
+        .sort();
+}
+async function getAppliedMigrations(connection, tableName) {
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addons/pg.js")));
+    const pool = new Pool({
+        host: connection.host,
+        port: connection.port || 5432,
+        database: connection.database,
+        user: connection.user,
+        password: connection.password,
+        connectionString: connection.url,
+    });
+    try {
+        const result = await pool.query(`
+            SELECT name, applied_at 
+            FROM "${tableName}" 
+            ORDER BY id DESC;
+        `);
+        return result.rows.map(r => ({
+            name: r.name,
+            appliedAt: new Date(r.applied_at),
+        }));
+    }
+    finally {
+        await pool.end();
+    }
+}
+function formatDate(date) {
+    const now = new Date();
+    const diff = now.getTime() - date.getTime();
+    const days = Math.floor(diff / (1000 * 60 * 60 * 24));
+    if (days === 0)
+        return 'today';
+    if (days === 1)
+        return 'yesterday';
+    if (days < 7)
+        return `${days} days ago`;
+    if (days < 30)
+        return `${Math.floor(days / 7)} weeks ago`;
+    if (days < 365)
+        return `${Math.floor(days / 30)} months ago`;
+    return date.toLocaleDateString();
+}

package/dist/cjs/cli/commands/import.cjs

@@ -0,0 +1,524 @@
+"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.importCommand = importCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const sql_parser_1 = require("../utils/sql-parser.cjs");
+const type_generator_1 = require("../utils/type-generator.cjs");
+const repo_manager_1 = require("../utils/repo-manager.cjs");
+const schema_comparator_1 = require("../utils/schema-comparator.cjs");
+const change_tracker_1 = require("../utils/change-tracker.cjs");
+const git_utils_1 = require("../utils/git-utils.cjs");
+async function importCommand(sqlFilePath, options = {}) {
+    const { includeFunctions = false, includeTriggers = false, force = false, dryRun = false } = options;
+    const projectRoot = process.cwd();
+    const spinner = (0, git_utils_1.createSpinner)();
+    console.log('');
+    if (!sqlFilePath) {
+        (0, git_utils_1.error)('No SQL file specified.');
+        console.log('');
+        console.log('usage: relq import <sql-file> [options]');
+        console.log('');
+        console.log('Options:');
+        console.log('    --output <path>       Output schema file path');
+        console.log('    --force               Force import, overwrite local changes');
+        console.log('    --dry-run             Preview changes without applying');
+        console.log('    --theirs              Accept all incoming changes');
+        console.log('    --ours                Keep all local changes (reject incoming)');
+        console.log('    --abort               Abort the import operation');
+        console.log('    --include-functions   Include functions in import');
+        console.log('    --include-triggers    Include triggers in import');
+        process.exit(1);
+    }
+    if (options.abort) {
+        console.log('Aborting import...');
+        (0, git_utils_1.hint)('Working tree has been restored.');
+        process.exit(0);
+    }
+    let mergeStrategy = 'merge';
+    if (options.theirs || force) {
+        mergeStrategy = 'theirs';
+    }
+    else if (options.ours) {
+        mergeStrategy = 'ours';
+    }
+    const sqlResult = (0, git_utils_1.readSQLFile)(sqlFilePath);
+    if ('error' in sqlResult) {
+        (0, git_utils_1.fatal)(sqlResult.error);
+    }
+    const { content: sqlContent, validation } = sqlResult;
+    for (const warn of validation.warnings) {
+        (0, git_utils_1.warning)(warn);
+    }
+    if (!validation.valid) {
+        (0, git_utils_1.error)('Invalid PostgreSQL SQL file:');
+        for (const err of validation.errors) {
+            console.log(`  - ${err}`);
+        }
+        process.exit(1);
+    }
+    console.log(`Importing ${git_utils_1.colors.cyan(path.basename(sqlFilePath))} ${git_utils_1.colors.gray(`(${(0, git_utils_1.formatBytes)(sqlContent.length)})`)}`);
+    console.log('');
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        (0, repo_manager_1.initRepository)(projectRoot);
+        console.log(`Initialized empty Relq repository in ${git_utils_1.colors.cyan('.relq/')}`);
+        console.log('');
+    }
+    if (mergeStrategy === 'merge') {
+        const status = (0, git_utils_1.getWorkingTreeStatus)(projectRoot);
+        if (!status.isClean) {
+            (0, git_utils_1.printDirtyWorkingTreeError)(status, 'import');
+            console.log('');
+            (0, git_utils_1.printMergeStrategyHelp)();
+            process.exit(1);
+        }
+    }
+    spinner.start('Parsing SQL schema');
+    const parsedSchema = (0, sql_parser_1.parseSqlFile)(sqlContent);
+    const functions = includeFunctions ? (0, sql_parser_1.parseFunctions)(sqlContent) : [];
+    const triggers = includeTriggers ? (0, sql_parser_1.parseTriggers)(sqlContent) : [];
+    const comments = (0, sql_parser_1.parseComments)(sqlContent);
+    spinner.succeed(`Parsed ${parsedSchema.tables.length} tables, ${parsedSchema.enums.length} enums, ${parsedSchema.extensions.length} extensions`);
+    if (parsedSchema.tables.length > 0) {
+        console.log('');
+        console.log(`${git_utils_1.colors.bold('Tables:')}`);
+        for (const table of parsedSchema.tables.slice(0, 10)) {
+            const partInfo = table.isPartitioned ? ` ${git_utils_1.colors.gray('(partitioned)')}` : '';
+            console.log(`  ${git_utils_1.colors.green('+')} ${table.name} ${git_utils_1.colors.gray(`(${table.columns.length} columns)`)}${partInfo}`);
+        }
+        if (parsedSchema.tables.length > 10) {
+            console.log(`  ${git_utils_1.colors.gray(`... and ${parsedSchema.tables.length - 10} more`)}`);
+        }
+    }
+    if (parsedSchema.enums.length > 0) {
+        console.log('');
+        console.log(`${git_utils_1.colors.bold('Types:')}`);
+        for (const e of parsedSchema.enums.slice(0, 5)) {
+            console.log(`  ${git_utils_1.colors.yellow('+')} ${e.name} ${git_utils_1.colors.gray(`(${e.values.length} values)`)}`);
+        }
+        if (parsedSchema.enums.length > 5) {
+            console.log(`  ${git_utils_1.colors.gray(`... and ${parsedSchema.enums.length - 5} more`)}`);
+        }
+    }
+    if (parsedSchema.domains.length > 0) {
+        console.log('');
+        console.log(`${git_utils_1.colors.bold('Domains:')}`);
+        for (const d of parsedSchema.domains.slice(0, 5)) {
+            console.log(`  ${git_utils_1.colors.magenta('+')} ${d.name} ${git_utils_1.colors.gray(`(${d.baseType})`)}`);
+        }
+        if (parsedSchema.domains.length > 5) {
+            console.log(`  ${git_utils_1.colors.gray(`... and ${parsedSchema.domains.length - 5} more`)}`);
+        }
+    }
+    console.log('');
+    spinner.start('Generating TypeScript schema');
+    const dbSchema = convertToDbSchema(parsedSchema, functions, triggers, comments);
+    const typescriptContent = (0, type_generator_1.generateTypeScript)(dbSchema, {
+        camelCase: true,
+        includeFunctions,
+        includeTriggers,
+    });
+    spinner.succeed('Generated TypeScript schema');
+    const normalizedSchema = convertToNormalizedSchema(parsedSchema, functions, triggers);
+    const existingSnapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
+    let changes = [];
+    if (existingSnapshot) {
+        spinner.start('Detecting changes');
+        const beforeSchema = snapshotToDbSchema(existingSnapshot);
+        const afterSchema = snapshotToDbSchema(normalizedSchema);
+        changes = (0, schema_comparator_1.compareSchemas)(beforeSchema, afterSchema);
+        spinner.stop();
+        if (changes.length > 0) {
+            console.log('');
+            console.log(`${git_utils_1.colors.bold('Changes detected:')}`);
+            console.log('');
+            const creates = changes.filter(c => c.type === 'CREATE');
+            const alters = changes.filter(c => c.type === 'ALTER');
+            const drops = changes.filter(c => c.type === 'DROP');
+            if (creates.length > 0) {
+                for (const change of creates.slice(0, 10)) {
+                    console.log(`\t${git_utils_1.colors.green((0, change_tracker_1.getChangeDisplayName)(change))}`);
+                }
+                if (creates.length > 10) {
+                    console.log(`\t${git_utils_1.colors.gray(`... and ${creates.length - 10} more additions`)}`);
+                }
+            }
+            if (alters.length > 0) {
+                for (const change of alters.slice(0, 10)) {
+                    console.log(`\t${git_utils_1.colors.yellow((0, change_tracker_1.getChangeDisplayName)(change))}`);
+                }
+                if (alters.length > 10) {
+                    console.log(`\t${git_utils_1.colors.gray(`... and ${alters.length - 10} more modifications`)}`);
+                }
+            }
+            if (drops.length > 0) {
+                for (const change of drops.slice(0, 10)) {
+                    console.log(`\t${git_utils_1.colors.red((0, change_tracker_1.getChangeDisplayName)(change))}`);
+                }
+                if (drops.length > 10) {
+                    console.log(`\t${git_utils_1.colors.gray(`... and ${drops.length - 10} more deletions`)}`);
+                }
+            }
+            console.log('');
+            console.log(` ${changes.length} change(s) detected`);
+        }
+        else {
+            console.log('');
+            console.log(`${git_utils_1.colors.green('Already up to date.')} No changes detected.`);
+        }
+    }
+    else {
+        changes = [];
+        console.log(`${git_utils_1.colors.cyan('First import')} - creating initial snapshot`);
+    }
+    if (dryRun) {
+        console.log('');
+        console.log(`${git_utils_1.colors.yellow('Dry run mode')} - no files written`);
+        console.log('');
+        console.log('Would write:');
+        console.log(`  ${git_utils_1.colors.cyan(options.output || './db/schema.ts')} ${git_utils_1.colors.gray(`(${(0, git_utils_1.formatBytes)(typescriptContent.length)})`)}`);
+        console.log(`  ${git_utils_1.colors.cyan('.relq/snapshot.json')}`);
+        if (changes.length > 0) {
+            console.log(`  Stage ${changes.length} change(s)`);
+        }
+        console.log('');
+        return;
+    }
+    const outputPath = options.output || './db/schema.ts';
+    const absoluteOutputPath = path.resolve(outputPath);
+    const outputDir = path.dirname(absoluteOutputPath);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    fs.writeFileSync(absoluteOutputPath, typescriptContent, 'utf-8');
+    console.log(`Written ${git_utils_1.colors.cyan(outputPath)} ${git_utils_1.colors.gray(`(${(0, git_utils_1.formatBytes)(typescriptContent.length)})`)}`);
+    (0, repo_manager_1.saveSnapshot)(normalizedSchema, projectRoot);
+    if (changes.length > 0) {
+        (0, repo_manager_1.addUnstagedChanges)(changes, projectRoot);
+        (0, repo_manager_1.stageChanges)(['.'], projectRoot);
+        console.log('');
+        console.log(`${git_utils_1.colors.green('✓')} ${changes.length} change(s) staged for commit`);
+    }
+    console.log('');
+    console.log(`${git_utils_1.colors.green('Import successful.')}`);
+    console.log('');
+    if (changes.length > 0) {
+        (0, git_utils_1.hint)('Run "relq status" to see staged changes');
+        (0, git_utils_1.hint)('Run "relq commit -m <message>" to commit');
+    }
+    else {
+        (0, git_utils_1.hint)('Run "relq status" to see current state');
+    }
+    console.log('');
+}
+function toCamelCase(str) {
+    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function convertToDbSchema(parsed, functions = [], triggers = [], comments = []) {
+    const tableComments = new Map();
+    const columnComments = new Map();
+    const indexComments = new Map();
+    const functionComments = new Map();
+    const triggerComments = new Map();
+    for (const c of comments) {
+        if (c.objectType === 'TABLE') {
+            tableComments.set(c.objectName, c.comment);
+        }
+        else if (c.objectType === 'COLUMN' && c.subObjectName) {
+            columnComments.set(`${c.objectName}.${c.subObjectName}`, c.comment);
+        }
+        else if (c.objectType === 'INDEX') {
+            indexComments.set(c.objectName, c.comment);
+        }
+        else if (c.objectType === 'FUNCTION' || c.objectType === 'PROCEDURE') {
+            functionComments.set(c.objectName, c.comment);
+        }
+        else if (c.objectType === 'TRIGGER' && c.subObjectName) {
+            triggerComments.set(`${c.objectName}.${c.subObjectName}`, c.comment);
+        }
+    }
+    return {
+        tables: parsed.tables.map(t => ({
+            name: t.name,
+            schema: t.schema,
+            comment: tableComments.get(t.name) || null,
+            columns: t.columns.map(c => ({
+                name: c.name,
+                dataType: c.dataType,
+                udtName: c.dataType,
+                isNullable: c.isNullable,
+                defaultValue: c.defaultValue,
+                isPrimaryKey: c.isPrimaryKey,
+                isUnique: c.isUnique,
+                maxLength: c.maxLength,
+                precision: c.precision,
+                scale: c.scale,
+                references: c.references ? `${c.references.table}.${c.references.column}` : null,
+                comment: columnComments.get(`${t.name}.${c.name}`) || c.comment || null,
+                isGenerated: c.isGenerated || false,
+                generationExpression: c.generationExpression || null,
+            })),
+            indexes: t.indexes.map(idx => ({
+                name: idx.name,
+                columns: idx.columns,
+                isUnique: idx.isUnique,
+                isPrimary: idx.isPrimary,
+                type: idx.type,
+                definition: idx.definition,
+                whereClause: idx.whereClause,
+                expression: idx.expression,
+                comment: indexComments.get(idx.name) || null,
+            })),
+            constraints: t.constraints,
+            rowCount: 0,
+            isPartitioned: t.isPartitioned,
+            partitionType: t.partitionType,
+            partitionKey: t.partitionKey,
+        })),
+        enums: parsed.enums.map(e => ({
+            name: e.name,
+            values: e.values,
+        })),
+        domains: parsed.domains?.map((d) => ({
+            name: d.name,
+            baseType: d.baseType,
+            isNotNull: d.notNull || false,
+            defaultValue: d.default || null,
+            checkExpression: d.check || null,
+            check: d.check,
+            default: d.default,
+            notNull: d.notNull,
+        })) || [],
+        compositeTypes: parsed.compositeTypes?.map((c) => ({
+            name: c.name,
+            attributes: c.attributes || [],
+        })) || [],
+        sequences: parsed.sequences?.map((s) => ({
+            name: s.name,
+            dataType: s.dataType,
+            start: s.start,
+            increment: s.increment,
+            minValue: s.minValue,
+            maxValue: s.maxValue,
+            cache: s.cache,
+            cycle: s.cycle,
+            ownedBy: s.ownedBy,
+        })) || [],
+        extensions: parsed.extensions,
+        partitions: parsed.partitions,
+        functions: functions.map(f => ({
+            ...f,
+            comment: functionComments.get(f.name) || null,
+        })),
+        triggers: triggers.map(t => ({
+            ...t,
+            comment: triggerComments.get(`${t.name}.${t.tableName}`) || null,
+        })),
+        policies: [],
+        foreignServers: [],
+        foreignTables: [],
+    };
+}
+function convertToNormalizedSchema(parsed, functions = [], triggers = []) {
+    return {
+        extensions: parsed.extensions.map(ext => ({ name: ext })),
+        enums: parsed.enums.map(e => ({
+            name: e.name,
+            schema: 'public',
+            values: e.values,
+        })),
+        domains: parsed.domains.map(d => ({
+            name: d.name,
+            schema: 'public',
+            baseType: d.baseType,
+            notNull: d.notNull || false,
+            default: d.default || null,
+            check: d.check || null,
+        })),
+        compositeTypes: parsed.compositeTypes.map(c => ({
+            name: c.name,
+            schema: 'public',
+            attributes: c.attributes,
+        })),
+        sequences: parsed.sequences.map(s => ({
+            name: s.name,
+            schema: 'public',
+            dataType: 'bigint',
+            startValue: s.start || 1,
+            increment: s.increment || 1,
+            minValue: s.minValue || null,
+            maxValue: s.maxValue || null,
+            cache: 1,
+            cycle: false,
+            ownedBy: null,
+        })),
+        collations: [],
+        tables: parsed.tables.map(t => {
+            const childPartitions = parsed.partitions.filter(p => p.parentTable === t.name);
+            return {
+                name: t.name,
+                schema: t.schema,
+                columns: t.columns.map(c => ({
+                    name: c.name,
+                    tsName: toCamelCase(c.name),
+                    type: c.dataType,
+                    nullable: c.isNullable,
+                    default: c.defaultValue,
+                    primaryKey: c.isPrimaryKey,
+                    unique: c.isUnique,
+                    identity: c.identityGeneration ? {
+                        type: c.identityGeneration,
+                    } : undefined,
+                    isGenerated: c.isGenerated,
+                    generationExpression: c.generationExpression,
+                })),
+                indexes: t.indexes.map(idx => ({
+                    name: idx.name,
+                    columns: idx.columns,
+                    unique: idx.isUnique,
+                    type: idx.type || 'btree',
+                    definition: idx.definition,
+                    whereClause: idx.whereClause,
+                    expression: idx.expression,
+                })),
+                constraints: t.constraints.map(c => ({
+                    name: c.name,
+                    type: c.type,
+                    definition: c.definition,
+                })),
+                isPartitioned: t.isPartitioned,
+                partitionType: t.partitionType,
+                partitionKey: t.partitionKey,
+                partitions: childPartitions.length > 0 ? childPartitions.map(p => ({
+                    name: p.name,
+                    bound: p.partitionBound || '',
+                })) : undefined,
+            };
+        }),
+        functions: functions.map(f => ({
+            name: f.name,
+            returnType: f.returnType,
+            argTypes: f.argTypes,
+            language: f.language,
+        })),
+        triggers: triggers.map(t => ({
+            name: t.name,
+            table: t.tableName,
+            events: [t.event],
+            timing: t.timing,
+            forEach: 'STATEMENT',
+            functionName: t.functionName || '',
+        })),
+    };
+}
+function snapshotToDbSchema(snapshot) {
+    return ({
+        tables: snapshot.tables.map(t => ({
+            name: t.name,
+            schema: t.schema || 'public',
+            columns: t.columns.map(c => ({
+                name: c.name,
+                dataType: c.type,
+                isNullable: c.nullable,
+                defaultValue: c.default ?? null,
+                isPrimaryKey: c.primaryKey || false,
+                isUnique: c.unique || false,
+                maxLength: null,
+                precision: null,
+                scale: null,
+                isArray: false,
+                references: null,
+                comment: undefined,
+            })),
+            indexes: t.indexes.map(i => ({
+                name: i.name,
+                columns: Array.isArray(i.columns) ? i.columns : [i.columns],
+                isUnique: i.unique || false,
+                isPrimary: false,
+                type: i.type || 'btree',
+            })),
+            constraints: t.constraints?.map(c => ({
+                name: c.name,
+                type: c.type,
+                definition: c.definition,
+                columns: [],
+            })) || [],
+            isPartitioned: t.isPartitioned || false,
+            rowCount: 0,
+        })),
+        enums: snapshot.enums?.map(e => ({
+            name: e.name,
+            values: e.values,
+        })) || [],
+        domains: snapshot.domains?.map(d => ({
+            name: d.name,
+            baseType: d.baseType,
+            isNotNull: d.notNull || false,
+            defaultValue: d.default || null,
+            checkExpression: d.check || null,
+        })) || [],
+        compositeTypes: snapshot.compositeTypes?.map(c => ({
+            name: c.name,
+            attributes: c.attributes || [],
+        })) || [],
+        extensions: (snapshot.extensions || []).map(e => typeof e === 'string' ? e : e.name),
+        functions: snapshot.functions?.map(f => ({
+            name: f.name,
+            schema: 'public',
+            returnType: f.returnType,
+            argTypes: f.argTypes || [],
+            language: f.language,
+            definition: '',
+            isAggregate: false,
+            volatility: 'VOLATILE',
+        })) || [],
+        triggers: snapshot.triggers?.map(t => ({
+            name: t.name,
+            tableName: t.table,
+            timing: t.timing,
+            event: t.events?.[0] || '',
+            functionName: t.functionName || '',
+            definition: '',
+            isEnabled: t.isEnabled ?? true,
+        })) || [],
+        partitions: [],
+        policies: [],
+        foreignServers: [],
+        foreignTables: [],
+        sequences: [],
+    });
+}
+exports.default = importCommand;