relq 1.0.25 → 1.0.26

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateMigration = generateMigration;
+exports.generateMigrationFromComparison = generateMigrationFromComparison;
 exports.generateMigrationFile = generateMigrationFile;
 exports.getNextMigrationNumber = getNextMigrationNumber;
 exports.generateTimestampedName = generateTimestampedName;
@@ -29,6 +30,324 @@ function generateMigration(diff, options = {}) {
     }
     return { up, down };
 }
+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};`;
+}
 function generateMigrationFile(diff, name, options = {}) {
     const { message, includeComments = true } = options;
     const { up, down } = generateMigration(diff, options);

package/dist/cjs/cli/utils/repo-manager.cjs

@@ -51,6 +51,7 @@ exports.saveCommit = saveCommit;
 exports.loadCommit = loadCommit;
 exports.getAllCommits = getAllCommits;
 exports.getCommitHistory = getCommitHistory;
+exports.buildTrackingMap = buildTrackingMap;
 exports.createCommit = createCommit;
 exports.getStaged = getStaged;
 exports.setStaged = setStaged;
@@ -75,6 +76,8 @@ exports.cleanupStagedChanges = cleanupStagedChanges;
 exports.getUnstagedChanges = getUnstagedChanges;
 exports.hasUncommittedChanges = hasUncommittedChanges;
 exports.ensureRemoteTable = ensureRemoteTable;
+exports.markCommitAsApplied = markCommitAsApplied;
+exports.markCommitAsRolledBack = markCommitAsRolledBack;
 exports.fetchRemoteCommits = fetchRemoteCommits;
 exports.getRemoteHead = getRemoteHead;
 exports.pushCommit = pushCommit;
@@ -270,7 +273,42 @@ function getCommitHistory(limit = 20, projectRoot = process.cwd()) {
     }
     return history;
 }
-function createCommit(schema, author, message, projectRoot = process.cwd()) {
+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;
+}
+function createCommit(schema, author, message, projectRoot = process.cwd(), options) {
     const hash = generateHash(schema);
     const parentHash = getHead(projectRoot);
     const commit = {
@@ -292,9 +330,18 @@ 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;
 }
 function getStaged(projectRoot = process.cwd()) {
@@ -517,12 +564,61 @@ 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();
+    }
+}
+async function markCommitAsApplied(connection, commitHash) {
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
+    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();
+    }
+}
+async function markCommitAsRolledBack(connection, commitHash) {
+    const { Pool } = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
+    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();