relq 1.0.25 → 1.0.26

package/dist/esm/cli/utils/ast-transformer.js

@@ -476,6 +476,7 @@ export async function parseSQL(sql) {
     const schema = {
         enums: [],
         domains: [],
+        compositeTypes: [],
         sequences: [],
         tables: [],
         views: [],
@@ -550,6 +551,7 @@ export async function introspectedToParsedSchema(schema) {
         tables: [],
         enums: [],
         domains: [],
+        compositeTypes: [],
         sequences: [],
         views: [],
         functions: [],
@@ -571,6 +573,15 @@ export async function introspectedToParsedSchema(schema) {
             checkExpression: d.checkExpression,
         });
     }
+    for (const ct of schema.compositeTypes || []) {
+        parsed.compositeTypes.push({
+            name: ct.name,
+            attributes: ct.attributes.map(attr => ({
+                name: attr.name,
+                type: attr.type,
+            })),
+        });
+    }
     for (const t of schema.tables || []) {
         const columns = [];
         for (const c of t.columns) {
@@ -805,6 +816,7 @@ export function normalizedToParsedSchema(schema) {
             checkExpression: d.check,
             checkName: d.checkName,
         })),
+        compositeTypes: [],
         sequences: (schema.sequences || []).map(s => ({
             name: s.name,
             startValue: s.start,

package/dist/esm/cli/utils/change-tracker.js

@@ -556,3 +556,137 @@ export function generateCombinedSQL(changes) {
     }
     return lines.join('\n');
 }
+export function generateDownSQL(changes) {
+    const reversed = [...changes].reverse();
+    const lines = [
+        '--',
+        '-- DOWN Migration (Rollback)',
+        `-- Generated at: ${new Date().toISOString()}`,
+        '--',
+        '',
+    ];
+    for (const change of reversed) {
+        const downSQL = generateDownSQLForChange(change);
+        if (downSQL) {
+            lines.push(downSQL);
+            lines.push('');
+        }
+    }
+    return lines.join('\n');
+}
+function generateDownSQLForChange(change) {
+    const { type, objectType, objectName, parentName, before, after } = change;
+    switch (type) {
+        case 'CREATE':
+            return generateDropSQL(objectType, objectName, parentName);
+        case 'DROP':
+            if (before) {
+                return generateCreateSQL(objectType, objectName, before, parentName);
+            }
+            return `-- Cannot reverse DROP ${objectType} ${objectName} (no 'before' state saved)`;
+        case 'ALTER':
+            if (before && after) {
+                return generateAlterReverseSQL(objectType, objectName, after, before, parentName);
+            }
+            return `-- Cannot reverse ALTER ${objectType} ${objectName} (no state saved)`;
+        case 'RENAME':
+            if (before && after) {
+                const oldName = before.name || objectName;
+                const newName = after.name || objectName;
+                return generateRenameSQL(objectType, newName, oldName, parentName);
+            }
+            return `-- Cannot reverse RENAME ${objectType} ${objectName} (no state saved)`;
+        default:
+            return null;
+    }
+}
+function generateDropSQL(objectType, objectName, parentName) {
+    switch (objectType) {
+        case 'TABLE':
+            return `DROP TABLE IF EXISTS "${objectName}" CASCADE;`;
+        case 'COLUMN':
+            return `ALTER TABLE "${parentName}" DROP COLUMN IF EXISTS "${objectName}";`;
+        case 'INDEX':
+            return `DROP INDEX IF EXISTS "${objectName}";`;
+        case 'ENUM':
+            return `DROP TYPE IF EXISTS "${objectName}";`;
+        case 'SEQUENCE':
+            return `DROP SEQUENCE IF EXISTS "${objectName}";`;
+        case 'FUNCTION':
+            return `DROP FUNCTION IF EXISTS "${objectName}" CASCADE;`;
+        case 'TRIGGER':
+            return `DROP TRIGGER IF EXISTS "${objectName}" ON "${parentName}";`;
+        case 'VIEW':
+            return `DROP VIEW IF EXISTS "${objectName}";`;
+        case 'CONSTRAINT':
+        case 'CHECK':
+        case 'FOREIGN_KEY':
+        case 'PRIMARY_KEY':
+            return `ALTER TABLE "${parentName}" DROP CONSTRAINT IF EXISTS "${objectName}";`;
+        default:
+            return `-- Cannot generate DROP for ${objectType} ${objectName}`;
+    }
+}
+function generateCreateSQL(objectType, objectName, state, parentName) {
+    switch (objectType) {
+        case 'COLUMN':
+            if (state.dataType) {
+                const nullable = state.isNullable === false ? ' NOT NULL' : '';
+                const defaultVal = state.defaultValue ? ` DEFAULT ${state.defaultValue}` : '';
+                return `ALTER TABLE "${parentName}" ADD COLUMN "${objectName}" ${state.dataType}${nullable}${defaultVal};`;
+            }
+            break;
+        case 'INDEX':
+            if (state.columns) {
+                const unique = state.isUnique ? 'UNIQUE ' : '';
+                const cols = Array.isArray(state.columns) ? state.columns.join(', ') : state.columns;
+                return `CREATE ${unique}INDEX "${objectName}" ON "${state.tableName || parentName}" (${cols});`;
+            }
+            break;
+    }
+    return `-- Cannot reconstruct CREATE ${objectType} ${objectName} from saved state`;
+}
+function generateAlterReverseSQL(objectType, objectName, from, to, parentName) {
+    switch (objectType) {
+        case 'COLUMN':
+            const stmts = [];
+            if (from.dataType !== to.dataType && to.dataType) {
+                stmts.push(`ALTER TABLE "${parentName}" ALTER COLUMN "${objectName}" TYPE ${to.dataType};`);
+            }
+            if (from.isNullable !== to.isNullable) {
+                if (to.isNullable === false) {
+                    stmts.push(`ALTER TABLE "${parentName}" ALTER COLUMN "${objectName}" SET NOT NULL;`);
+                }
+                else {
+                    stmts.push(`ALTER TABLE "${parentName}" ALTER COLUMN "${objectName}" DROP NOT NULL;`);
+                }
+            }
+            if (from.defaultValue !== to.defaultValue) {
+                if (to.defaultValue) {
+                    stmts.push(`ALTER TABLE "${parentName}" ALTER COLUMN "${objectName}" SET DEFAULT ${to.defaultValue};`);
+                }
+                else {
+                    stmts.push(`ALTER TABLE "${parentName}" ALTER COLUMN "${objectName}" DROP DEFAULT;`);
+                }
+            }
+            return stmts.length > 0 ? stmts.join('\n') : `-- No reverse ALTER needed for ${objectName}`;
+        default:
+            return `-- Cannot reverse ALTER ${objectType} ${objectName}`;
+    }
+}
+function generateRenameSQL(objectType, fromName, toName, parentName) {
+    switch (objectType) {
+        case 'TABLE':
+            return `ALTER TABLE "${fromName}" RENAME TO "${toName}";`;
+        case 'COLUMN':
+            return `ALTER TABLE "${parentName}" RENAME COLUMN "${fromName}" TO "${toName}";`;
+        case 'INDEX':
+            return `ALTER INDEX "${fromName}" RENAME TO "${toName}";`;
+        case 'ENUM':
+            return `ALTER TYPE "${fromName}" RENAME TO "${toName}";`;
+        case 'SEQUENCE':
+            return `ALTER SEQUENCE "${fromName}" RENAME TO "${toName}";`;
+        default:
+            return `-- Cannot rename ${objectType} ${fromName} to ${toName}`;
+    }
+}

package/dist/esm/cli/utils/commit-manager.js

@@ -1,6 +1,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
+import * as crypto from 'crypto';
 import { normalizeSchema, generateSchemaHash } from "./schema-hash.js";
+import { schemaToAST } from "./schema-to-ast.js";
 const RELQ_DIR = '.relq';
 const COMMITS_FILE = 'commits.json';
 const HEAD_FILE = 'HEAD';
@@ -189,3 +191,52 @@ export async function checkSyncStatus(connection, baseDir = process.cwd()) {
     const remoteAhead = [...remoteHashes].filter(h => !localHashes.has(h)).length;
     return { inSync, localHead, remoteHead, localAhead, remoteAhead };
 }
+export function generateASTHash(ast) {
+    const normalized = {
+        enums: [...ast.enums].sort((a, b) => a.name.localeCompare(b.name)),
+        domains: [...ast.domains].sort((a, b) => a.name.localeCompare(b.name)),
+        compositeTypes: [...ast.compositeTypes].sort((a, b) => a.name.localeCompare(b.name)),
+        sequences: [...ast.sequences].sort((a, b) => a.name.localeCompare(b.name)),
+        tables: [...ast.tables].sort((a, b) => a.name.localeCompare(b.name)),
+        views: [...ast.views].sort((a, b) => a.name.localeCompare(b.name)),
+        functions: [...ast.functions].sort((a, b) => a.name.localeCompare(b.name)),
+        triggers: [...ast.triggers].sort((a, b) => a.name.localeCompare(b.name)),
+        extensions: [...ast.extensions].sort(),
+    };
+    const json = JSON.stringify(normalized, null, 0);
+    return crypto
+        .createHash('sha1')
+        .update(json, 'utf8')
+        .digest('hex');
+}
+export function createCommitFromSchema(schema, author, message, commitLimit = 1000, baseDir = process.cwd()) {
+    const parsedSchema = schemaToAST(schema);
+    const hash = generateASTHash(parsedSchema);
+    const parentHash = getLocalHead(baseDir);
+    const commit = {
+        hash,
+        parentHash,
+        schemaSnapshot: parsedSchema,
+        author,
+        message,
+        createdAt: new Date(),
+    };
+    addLocalCommit(commit, commitLimit, baseDir);
+    return commit;
+}
+export async function createCommitFromSchemaWithRemote(schema, connection, author, message, commitLimit = 1000, baseDir = process.cwd()) {
+    const parsedSchema = schemaToAST(schema);
+    const hash = generateASTHash(parsedSchema);
+    const parentHash = getLocalHead(baseDir);
+    const commit = {
+        hash,
+        parentHash,
+        schemaSnapshot: parsedSchema,
+        author,
+        message,
+        createdAt: new Date(),
+    };
+    addLocalCommit(commit, commitLimit, baseDir);
+    await addRemoteCommit(connection, commit, commitLimit);
+    return commit;
+}

package/dist/esm/cli/utils/migration-generator.js

@@ -23,6 +23,324 @@ export function generateMigration(diff, options = {}) {
     }
     return { up, down };
 }
+export function generateMigrationFromComparison(comparison, options = {}) {
+    const { includeDown = true } = options;
+    const up = [];
+    const down = [];
+    for (const rename of comparison.renamed.enums) {
+        up.push(`ALTER TYPE "${rename.from}" RENAME TO "${rename.to}";`);
+        if (includeDown) {
+            down.unshift(`ALTER TYPE "${rename.to}" RENAME TO "${rename.from}";`);
+        }
+    }
+    for (const rename of comparison.renamed.sequences) {
+        up.push(`ALTER SEQUENCE "${rename.from}" RENAME TO "${rename.to}";`);
+        if (includeDown) {
+            down.unshift(`ALTER SEQUENCE "${rename.to}" RENAME TO "${rename.from}";`);
+        }
+    }
+    for (const rename of comparison.renamed.tables) {
+        up.push(`ALTER TABLE "${rename.from}" RENAME TO "${rename.to}";`);
+        if (includeDown) {
+            down.unshift(`ALTER TABLE "${rename.to}" RENAME TO "${rename.from}";`);
+        }
+    }
+    for (const rename of comparison.renamed.columns) {
+        up.push(`ALTER TABLE "${rename.table}" RENAME COLUMN "${rename.from}" TO "${rename.to}";`);
+        if (includeDown) {
+            down.unshift(`ALTER TABLE "${rename.table}" RENAME COLUMN "${rename.to}" TO "${rename.from}";`);
+        }
+    }
+    for (const rename of comparison.renamed.indexes) {
+        up.push(`ALTER INDEX "${rename.from}" RENAME TO "${rename.to}";`);
+        if (includeDown) {
+            down.unshift(`ALTER INDEX "${rename.to}" RENAME TO "${rename.from}";`);
+        }
+    }
+    for (const rename of comparison.renamed.functions) {
+        up.push(`ALTER FUNCTION "${rename.from}" RENAME TO "${rename.to}";`);
+        if (includeDown) {
+            down.unshift(`ALTER FUNCTION "${rename.to}" RENAME TO "${rename.from}";`);
+        }
+    }
+    for (const enumMod of comparison.modified.enums) {
+        for (const value of enumMod.changes.added) {
+            up.push(`ALTER TYPE "${enumMod.name}" ADD VALUE IF NOT EXISTS '${value}';`);
+        }
+        if (enumMod.changes.removed.length > 0 && includeDown) {
+            down.unshift(`-- Warning: Cannot remove enum values in PostgreSQL: ${enumMod.changes.removed.join(', ')}`);
+        }
+    }
+    for (const colMod of comparison.modified.columns) {
+        const { upSQL, downSQL } = generateColumnModification(colMod.table, colMod.column, colMod.changes);
+        up.push(...upSQL);
+        if (includeDown)
+            down.unshift(...downSQL);
+    }
+    for (const ext of comparison.added.extensions) {
+        up.push(`CREATE EXTENSION IF NOT EXISTS "${ext}";`);
+        if (includeDown) {
+            down.unshift(`DROP EXTENSION IF EXISTS "${ext}";`);
+        }
+    }
+    for (const enumDef of comparison.added.enums) {
+        const values = enumDef.values.map(v => `'${v}'`).join(', ');
+        up.push(`CREATE TYPE "${enumDef.name}" AS ENUM (${values});`);
+        if (includeDown) {
+            down.unshift(`DROP TYPE IF EXISTS "${enumDef.name}";`);
+        }
+    }
+    for (const domain of comparison.added.domains) {
+        let domainSQL = `CREATE DOMAIN "${domain.name}" AS ${domain.baseType}`;
+        if (domain.notNull)
+            domainSQL += ' NOT NULL';
+        if (domain.defaultValue)
+            domainSQL += ` DEFAULT ${domain.defaultValue}`;
+        if (domain.checkExpression) {
+            const checkName = domain.checkName ? `CONSTRAINT "${domain.checkName}" ` : '';
+            domainSQL += ` ${checkName}CHECK (${domain.checkExpression})`;
+        }
+        up.push(domainSQL + ';');
+        if (includeDown) {
+            down.unshift(`DROP DOMAIN IF EXISTS "${domain.name}";`);
+        }
+    }
+    for (const seq of comparison.added.sequences) {
+        const parts = [`CREATE SEQUENCE "${seq.name}"`];
+        if (seq.startValue !== undefined)
+            parts.push(`START WITH ${seq.startValue}`);
+        if (seq.increment !== undefined)
+            parts.push(`INCREMENT BY ${seq.increment}`);
+        if (seq.minValue !== undefined)
+            parts.push(`MINVALUE ${seq.minValue}`);
+        if (seq.maxValue !== undefined)
+            parts.push(`MAXVALUE ${seq.maxValue}`);
+        if (seq.cache !== undefined)
+            parts.push(`CACHE ${seq.cache}`);
+        if (seq.cycle)
+            parts.push('CYCLE');
+        up.push(parts.join(' ') + ';');
+        if (includeDown) {
+            down.unshift(`DROP SEQUENCE IF EXISTS "${seq.name}";`);
+        }
+    }
+    for (const table of comparison.added.tables) {
+        up.push(...generateCreateTableFromParsed(table));
+        if (includeDown) {
+            down.unshift(`DROP TABLE IF EXISTS "${table.name}" CASCADE;`);
+        }
+    }
+    for (const { table, column } of comparison.added.columns) {
+        up.push(`ALTER TABLE "${table}" ADD COLUMN ${generateParsedColumnDef(column)};`);
+        if (includeDown) {
+            down.unshift(`ALTER TABLE "${table}" DROP COLUMN IF EXISTS "${column.name}";`);
+        }
+    }
+    for (const { table, index } of comparison.added.indexes) {
+        up.push(generateCreateIndexFromParsed(table, index));
+        if (includeDown) {
+            down.unshift(`DROP INDEX IF EXISTS "${index.name}";`);
+        }
+    }
+    for (const view of comparison.added.views) {
+        const materialized = view.isMaterialized ? 'MATERIALIZED ' : '';
+        up.push(`CREATE ${materialized}VIEW "${view.name}" AS ${view.definition};`);
+        if (includeDown) {
+            down.unshift(`DROP ${materialized}VIEW IF EXISTS "${view.name}";`);
+        }
+    }
+    for (const func of comparison.added.functions) {
+        const argsStr = func.args.map(a => `${a.name || ''} ${a.type}`.trim()).join(', ');
+        const volatility = func.volatility || 'VOLATILE';
+        up.push(`CREATE OR REPLACE FUNCTION "${func.name}"(${argsStr}) RETURNS ${func.returnType} LANGUAGE ${func.language} ${volatility} AS $$ ${func.body} $$;`);
+        if (includeDown) {
+            down.unshift(`DROP FUNCTION IF EXISTS "${func.name}"(${func.args.map(a => a.type).join(', ')});`);
+        }
+    }
+    for (const trigger of comparison.added.triggers) {
+        const events = trigger.events.join(' OR ');
+        const forEach = trigger.forEach || 'ROW';
+        up.push(`CREATE TRIGGER "${trigger.name}" ${trigger.timing} ${events} ON "${trigger.table}" FOR EACH ${forEach} EXECUTE FUNCTION ${trigger.functionName}();`);
+        if (includeDown) {
+            down.unshift(`DROP TRIGGER IF EXISTS "${trigger.name}" ON "${trigger.table}";`);
+        }
+    }
+    for (const trigger of comparison.removed.triggers) {
+        up.push(`DROP TRIGGER IF EXISTS "${trigger.name}" ON "${trigger.table}";`);
+        if (includeDown) {
+            const events = trigger.events.join(' OR ');
+            const forEach = trigger.forEach || 'ROW';
+            down.unshift(`CREATE TRIGGER "${trigger.name}" ${trigger.timing} ${events} ON "${trigger.table}" FOR EACH ${forEach} EXECUTE FUNCTION ${trigger.functionName}();`);
+        }
+    }
+    for (const func of comparison.removed.functions) {
+        const argTypes = func.args.map(a => a.type).join(', ');
+        up.push(`DROP FUNCTION IF EXISTS "${func.name}"(${argTypes});`);
+        if (includeDown) {
+            const argsStr = func.args.map(a => `${a.name || ''} ${a.type}`.trim()).join(', ');
+            const volatility = func.volatility || 'VOLATILE';
+            down.unshift(`CREATE OR REPLACE FUNCTION "${func.name}"(${argsStr}) RETURNS ${func.returnType} LANGUAGE ${func.language} ${volatility} AS $$ ${func.body} $$;`);
+        }
+    }
+    for (const view of comparison.removed.views) {
+        const materialized = view.isMaterialized ? 'MATERIALIZED ' : '';
+        up.push(`DROP ${materialized}VIEW IF EXISTS "${view.name}";`);
+        if (includeDown) {
+            down.unshift(`CREATE ${materialized}VIEW "${view.name}" AS ${view.definition};`);
+        }
+    }
+    for (const { index } of comparison.removed.indexes) {
+        up.push(`DROP INDEX IF EXISTS "${index.name}";`);
+    }
+    for (const { table, column } of comparison.removed.columns) {
+        up.push(`ALTER TABLE "${table}" DROP COLUMN IF EXISTS "${column.name}";`);
+        if (includeDown) {
+            down.unshift(`ALTER TABLE "${table}" ADD COLUMN ${generateParsedColumnDef(column)};`);
+        }
+    }
+    for (const table of comparison.removed.tables) {
+        up.push(`DROP TABLE IF EXISTS "${table.name}" CASCADE;`);
+        if (includeDown) {
+            down.unshift(...generateCreateTableFromParsed(table));
+        }
+    }
+    for (const seq of comparison.removed.sequences) {
+        up.push(`DROP SEQUENCE IF EXISTS "${seq.name}";`);
+        if (includeDown) {
+            const parts = [`CREATE SEQUENCE "${seq.name}"`];
+            if (seq.startValue !== undefined)
+                parts.push(`START WITH ${seq.startValue}`);
+            if (seq.increment !== undefined)
+                parts.push(`INCREMENT BY ${seq.increment}`);
+            if (seq.minValue !== undefined)
+                parts.push(`MINVALUE ${seq.minValue}`);
+            if (seq.maxValue !== undefined)
+                parts.push(`MAXVALUE ${seq.maxValue}`);
+            if (seq.cache !== undefined)
+                parts.push(`CACHE ${seq.cache}`);
+            if (seq.cycle)
+                parts.push('CYCLE');
+            down.unshift(parts.join(' ') + ';');
+        }
+    }
+    for (const domain of comparison.removed.domains) {
+        up.push(`DROP DOMAIN IF EXISTS "${domain.name}";`);
+        if (includeDown) {
+            let domainSQL = `CREATE DOMAIN "${domain.name}" AS ${domain.baseType}`;
+            if (domain.notNull)
+                domainSQL += ' NOT NULL';
+            if (domain.defaultValue)
+                domainSQL += ` DEFAULT ${domain.defaultValue}`;
+            if (domain.checkExpression) {
+                const checkName = domain.checkName ? `CONSTRAINT "${domain.checkName}" ` : '';
+                domainSQL += ` ${checkName}CHECK (${domain.checkExpression})`;
+            }
+            down.unshift(domainSQL + ';');
+        }
+    }
+    for (const enumDef of comparison.removed.enums) {
+        up.push(`DROP TYPE IF EXISTS "${enumDef.name}";`);
+        if (includeDown) {
+            const values = enumDef.values.map(v => `'${v}'`).join(', ');
+            down.unshift(`CREATE TYPE "${enumDef.name}" AS ENUM (${values});`);
+        }
+    }
+    for (const ext of comparison.removed.extensions) {
+        up.push(`DROP EXTENSION IF EXISTS "${ext}";`);
+        if (includeDown) {
+            down.unshift(`CREATE EXTENSION IF NOT EXISTS "${ext}";`);
+        }
+    }
+    return { up, down };
+}
+function generateColumnModification(tableName, columnName, changes) {
+    const upSQL = [];
+    const downSQL = [];
+    for (const change of changes) {
+        switch (change.field) {
+            case 'type':
+                upSQL.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${columnName}" TYPE ${change.to} USING "${columnName}"::${change.to};`);
+                downSQL.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${columnName}" TYPE ${change.from} USING "${columnName}"::${change.from};`);
+                break;
+            case 'nullable':
+                if (change.to) {
+                    upSQL.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${columnName}" DROP NOT NULL;`);
+                    downSQL.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${columnName}" SET NOT NULL;`);
+                }
+                else {
+                    upSQL.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${columnName}" SET NOT NULL;`);
+                    downSQL.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${columnName}" DROP NOT NULL;`);
+                }
+                break;
+            case 'default':
+                if (change.to !== undefined && change.to !== null) {
+                    upSQL.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${columnName}" SET DEFAULT ${change.to};`);
+                }
+                else {
+                    upSQL.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${columnName}" DROP DEFAULT;`);
+                }
+                if (change.from !== undefined && change.from !== null) {
+                    downSQL.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${columnName}" SET DEFAULT ${change.from};`);
+                }
+                else {
+                    downSQL.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${columnName}" DROP DEFAULT;`);
+                }
+                break;
+        }
+    }
+    return { upSQL, downSQL };
+}
+function generateCreateTableFromParsed(table) {
+    const sql = [];
+    const columnDefs = [];
+    for (const col of table.columns) {
+        columnDefs.push(`    ${generateParsedColumnDef(col)}`);
+    }
+    let createSQL = `CREATE TABLE "${table.name}" (\n${columnDefs.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) {
+        const isPKIndex = table.columns.some(c => c.isPrimaryKey && idx.columns.includes(c.name) && idx.columns.length === 1);
+        if (!isPKIndex) {
+            sql.push(generateCreateIndexFromParsed(table.name, idx));
+        }
+    }
+    return sql;
+}
+function generateParsedColumnDef(col) {
+    const parts = [`"${col.name}"`, col.type];
+    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 !== undefined) {
+        parts.push(`DEFAULT ${col.defaultValue}`);
+    }
+    if (col.references) {
+        parts.push(`REFERENCES "${col.references.table}"("${col.references.column}")`);
+        if (col.references.onDelete) {
+            parts.push(`ON DELETE ${col.references.onDelete}`);
+        }
+        if (col.references.onUpdate) {
+            parts.push(`ON UPDATE ${col.references.onUpdate}`);
+        }
+    }
+    return parts.join(' ');
+}
+function generateCreateIndexFromParsed(tableName, idx) {
+    const unique = idx.isUnique ? 'UNIQUE ' : '';
+    const colList = idx.columns.map(c => `"${c}"`).join(', ');
+    const using = idx.method && idx.method !== 'btree' ? ` USING ${idx.method}` : '';
+    const where = idx.whereClause ? ` WHERE ${idx.whereClause}` : '';
+    return `CREATE ${unique}INDEX IF NOT EXISTS "${idx.name}" ON "${tableName}"${using} (${colList})${where};`;
+}
 export function generateMigrationFile(diff, name, options = {}) {
     const { message, includeComments = true } = options;
     const { up, down } = generateMigration(diff, options);

package/dist/esm/cli/utils/repo-manager.js

@@ -183,7 +183,42 @@ export function getCommitHistory(limit = 20, projectRoot = process.cwd()) {
     }
     return history;
 }
-export function createCommit(schema, author, message, projectRoot = process.cwd()) {
+export function buildTrackingMap(ast) {
+    const map = {
+        tables: {},
+        columns: {},
+        indexes: {},
+        enums: {},
+        functions: {},
+    };
+    for (const table of ast.tables) {
+        if (table.trackingId) {
+            map.tables[table.trackingId] = table.name;
+        }
+        for (const col of table.columns) {
+            if (col.trackingId) {
+                map.columns[col.trackingId] = `${table.name}.${col.name}`;
+            }
+        }
+        for (const idx of table.indexes) {
+            if (idx.trackingId) {
+                map.indexes[idx.trackingId] = idx.name;
+            }
+        }
+    }
+    for (const e of ast.enums) {
+        if (e.trackingId) {
+            map.enums[e.trackingId] = e.name;
+        }
+    }
+    for (const f of ast.functions) {
+        if (f.trackingId) {
+            map.functions[f.trackingId] = f.name;
+        }
+    }
+    return map;
+}
+export function createCommit(schema, author, message, projectRoot = process.cwd(), options) {
     const hash = generateHash(schema);
     const parentHash = getHead(projectRoot);
     const commit = {
@@ -205,9 +240,18 @@ export function createCommit(schema, author, message, projectRoot = process.cwd(
             triggers: schema.triggers?.length || 0,
         },
     };
+    if (options?.schemaAST) {
+        commit.schemaAST = options.schemaAST;
+        commit.trackingMap = buildTrackingMap(options.schemaAST);
+    }
+    if (options?.changes) {
+        commit.changes = options.changes;
+    }
     saveCommit(commit, projectRoot);
     setHead(hash, projectRoot);
-    clearStaged(projectRoot);
+    if (!options?.skipClearStaged) {
+        clearStaged(projectRoot);
+    }
     return commit;
 }
 export function getStaged(projectRoot = process.cwd()) {
@@ -430,12 +474,61 @@ export async function ensureRemoteTable(connection) {
                 message TEXT,
                 schema_snapshot JSONB NOT NULL,
                 stats JSONB,
-                created_at TIMESTAMPTZ DEFAULT NOW()
+                created_at TIMESTAMPTZ DEFAULT NOW(),
+                applied_at TIMESTAMPTZ,
+                rolled_back_at TIMESTAMPTZ
             );
 
             CREATE INDEX IF NOT EXISTS idx_relq_commits_hash ON _relq_commits(hash);
             CREATE INDEX IF NOT EXISTS idx_relq_commits_created ON _relq_commits(created_at DESC);
         `);
+        await pool.query(`
+            DO $$
+            BEGIN
+                IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name = '_relq_commits' AND column_name = 'applied_at') THEN
+                    ALTER TABLE _relq_commits ADD COLUMN applied_at TIMESTAMPTZ;
+                END IF;
+                IF NOT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name = '_relq_commits' AND column_name = 'rolled_back_at') THEN
+                    ALTER TABLE _relq_commits ADD COLUMN rolled_back_at TIMESTAMPTZ;
+                END IF;
+            END $$;
+        `);
+    }
+    finally {
+        await pool.end();
+    }
+}
+export async function markCommitAsApplied(connection, commitHash) {
+    const { Pool } = await import("../../addon/pg/index.js");
+    const pool = new Pool({
+        host: connection.host,
+        port: connection.port || 5432,
+        database: connection.database,
+        user: connection.user,
+        password: connection.password,
+        connectionString: connection.url,
+        ssl: connection.ssl,
+    });
+    try {
+        await pool.query(`UPDATE _relq_commits SET applied_at = NOW(), rolled_back_at = NULL WHERE hash = $1`, [commitHash]);
+    }
+    finally {
+        await pool.end();
+    }
+}
+export async function markCommitAsRolledBack(connection, commitHash) {
+    const { Pool } = await import("../../addon/pg/index.js");
+    const pool = new Pool({
+        host: connection.host,
+        port: connection.port || 5432,
+        database: connection.database,
+        user: connection.user,
+        password: connection.password,
+        connectionString: connection.url,
+        ssl: connection.ssl,
+    });
+    try {
+        await pool.query(`UPDATE _relq_commits SET rolled_back_at = NOW() WHERE hash = $1`, [commitHash]);
     }
     finally {
         await pool.end();