relq 1.0.93 → 1.0.95

package/dist/cjs/cli/commands/push.cjs

@@ -116,7 +116,7 @@ function mergeTrackingIds(introspected, desired) {
     return introspected;
 }
 async function runPush(config, projectRoot, opts = {}) {
-    const { force = false, dryRun = false, skipPrompt = false } = opts;
+    const { force = false, dryRun = false, full = false, skipPrompt = false } = opts;
     const connection = config.connection;
     const includeFunctions = config.includeFunctions ?? false;
     const includeTriggers = config.includeTriggers ?? false;
@@ -235,7 +235,8 @@ async function runPush(config, projectRoot, opts = {}) {
             includeComments: false,
         });
         const upStatements = migration.upSQL;
-        spin.stop(`Generated ${upStatements.length} statement(s)`);
+        const sqlStatementCount = upStatements.filter(s => s.trim() && !s.trim().startsWith('--')).length;
+        spin.stop(`Generated ${sqlStatementCount} statement(s)`);
         const summaryLines = (0, schema_diff_1.formatCategorizedSummary)(filteredDiff);
         if (summaryLines.length > 0) {
             for (const line of summaryLines)
@@ -255,15 +256,22 @@ async function runPush(config, projectRoot, opts = {}) {
         if (dryRun) {
             console.log(`${colors_1.colors.yellow('Dry run')} - SQL that would be executed:`);
             console.log('');
-            for (const stmt of upStatements.slice(0, 15)) {
-                console.log(`   ${stmt.substring(0, 120)}${stmt.length > 120 ? '...' : ''}`);
-            }
-            if (upStatements.length > 15) {
-                console.log(`   ${colors_1.colors.muted(`... and ${upStatements.length - 15} more statements`)}`);
+            for (const stmt of upStatements) {
+                console.log(stmt);
             }
             if (migration.downSQL.length > 0) {
                 console.log('');
-                console.log(`${colors_1.colors.muted(`Rollback: ${migration.downSQL.length} revert statement(s) will be saved`)}`);
+                if (full) {
+                    console.log(`${colors_1.colors.yellow('Rollback')} - SQL to revert:`);
+                    console.log('');
+                    for (const stmt of migration.downSQL) {
+                        console.log(stmt);
+                    }
+                }
+                else {
+                    console.log(`${colors_1.colors.muted(`Rollback: ${migration.downSQL.length} revert statement(s) will be saved`)}`);
+                    console.log(`${colors_1.colors.muted('Use')} ${colors_1.colors.cyan('--full')} ${colors_1.colors.muted('to include rollback SQL.')}`);
+                }
             }
             console.log('');
             console.log(`${colors_1.colors.muted('Remove')} ${colors_1.colors.cyan('--dry-run')} ${colors_1.colors.muted('to execute.')}`);
@@ -415,6 +423,7 @@ exports.default = (0, citty_1.defineCommand)({
     args: {
         force: { type: 'boolean', description: 'Force push without confirmation' },
         'dry-run': { type: 'boolean', description: 'Show SQL without executing' },
+        full: { type: 'boolean', description: 'Show all statements in dry run (including rollback)' },
         yes: { type: 'boolean', alias: 'y', description: 'Skip confirmation' },
     },
     async run({ args }) {
@@ -423,6 +432,7 @@ exports.default = (0, citty_1.defineCommand)({
         await runPush(config, projectRoot, {
             force: args.force === true,
             dryRun: args['dry-run'] === true,
+            full: args.full === true,
             skipPrompt: args.yes === true,
         });
     },

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

@@ -55,22 +55,64 @@ function generateMigration(diff, options = {}) {
             }
         }
     }
+    const deferredFKsByTable = new Map();
     for (const table of diff.tables.filter(t => t.type === 'added')) {
         const columns = (table.columns || [])
             .filter(c => c.after)
             .map(c => c.after);
+        const allConstraints = (table.constraints || [])
+            .filter(c => c.after)
+            .map(c => c.after);
+        const inlineConstraints = allConstraints.filter(c => c.type !== 'FOREIGN KEY');
+        const fkConstraints = allConstraints.filter(c => c.type === 'FOREIGN KEY');
+        const indexes = (table.indexes || [])
+            .filter(i => i.after)
+            .map(i => i.after);
         if (columns.length > 0) {
-            up.push(...generateCreateTable({ name: table.name, columns }));
+            up.push(...generateCreateTable({ name: table.name, columns, constraints: inlineConstraints, indexes }));
+        }
+        if (fkConstraints.length > 0) {
+            const group = deferredFKsByTable.get(table.name) || { up: [], down: [] };
+            for (const fk of fkConstraints) {
+                group.up.push(`ALTER TABLE "${table.name}" ADD CONSTRAINT "${fk.name}" ${fk.definition};`);
+                if (includeDown) {
+                    group.down.push(`ALTER TABLE "${table.name}" DROP CONSTRAINT IF EXISTS "${fk.name}";`);
+                }
+            }
+            deferredFKsByTable.set(table.name, group);
         }
         if (includeDown) {
             down.unshift(`DROP TABLE IF EXISTS "${table.name}" CASCADE;`);
         }
     }
-    for (const table of diff.tables.filter(t => t.type === 'modified')) {
+    const modifiedTables = diff.tables.filter(t => t.type === 'modified');
+    for (const table of modifiedTables) {
+        up.push(`-- ==================================================================`);
+        up.push(`--  ALTER TABLE: ${table.name}`);
+        up.push(`-- ==================================================================`);
+        up.push('');
         const { upSQL, downSQL } = generateAlterTable(table, includeDown);
         up.push(...upSQL);
+        up.push('');
+        up.push('');
         down.unshift(...downSQL);
     }
+    if (deferredFKsByTable.size > 0) {
+        up.push(`-- ==================================================================`);
+        up.push(`--  FOREIGN KEY CONSTRAINTS`);
+        up.push(`-- ==================================================================`);
+        for (const [tableName, group] of deferredFKsByTable) {
+            up.push('');
+            up.push(`-- Foreign keys for ${tableName}`);
+            up.push(...group.up);
+            if (includeDown) {
+                down.unshift(...group.down);
+            }
+        }
+        up.push('');
+        up.push('');
+    }
+    up.splice(-2);
     return { up, down };
 }
 function generateMigrationFromComparison(comparison, options = {}) {
@@ -182,6 +224,9 @@ function generateMigrationFromComparison(comparison, options = {}) {
     }
     for (const { table, column } of comparison.added.columns) {
         up.push(`ALTER TABLE "${table}" ADD COLUMN ${generateParsedColumnDef(column)};`);
+        if (column.comment) {
+            up.push(`COMMENT ON COLUMN "${table}"."${column.name}" IS '${column.comment.replace(/'/g, "''")}';`);
+        }
         if (includeDown) {
             down.unshift(`ALTER TABLE "${table}" DROP COLUMN IF EXISTS "${column.name}";`);
         }
@@ -376,22 +421,67 @@ function generateColumnModification(tableName, columnName, changes) {
 function generateCreateTableFromParsed(table) {
     const sql = [];
     const columnDefs = [];
+    const constraintDefs = [];
     for (const col of table.columns) {
         columnDefs.push(`    ${generateParsedColumnDef(col)}`);
     }
-    let createSQL = `CREATE TABLE "${table.name}" (\n${columnDefs.join(',\n')}\n)`;
+    for (const con of table.constraints) {
+        if (con.type === 'FOREIGN KEY')
+            continue;
+        if (con.type === 'PRIMARY KEY' && con.columns.length === 1 &&
+            table.columns.some(c => c.isPrimaryKey && c.name === con.columns[0]))
+            continue;
+        if (con.type === 'UNIQUE' && con.columns.length === 1 &&
+            table.columns.some(c => c.isUnique && c.name === con.columns[0]))
+            continue;
+        constraintDefs.push(`    CONSTRAINT "${con.name}" ${buildParsedConstraintDef(con)}`);
+    }
+    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 col of table.columns) {
+        if (col.comment) {
+            sql.push(`COMMENT ON COLUMN "${table.name}"."${col.name}" IS '${col.comment.replace(/'/g, "''")}';`);
+        }
+    }
     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));
         }
     }
+    sql.push('');
+    sql.push('');
     return sql;
 }
+function buildParsedConstraintDef(con) {
+    const cols = con.columns.map(c => `"${c}"`).join(', ');
+    switch (con.type) {
+        case 'PRIMARY KEY':
+            return `PRIMARY KEY (${cols})`;
+        case 'UNIQUE':
+            return `UNIQUE (${cols})`;
+        case 'CHECK':
+            return `CHECK (${con.expression || ''})`;
+        case 'FOREIGN KEY': {
+            let def = `FOREIGN KEY (${cols})`;
+            if (con.references) {
+                const refCols = con.references.columns.map(c => `"${c}"`).join(', ');
+                def += ` REFERENCES "${con.references.table}" (${refCols})`;
+                if (con.references.onDelete)
+                    def += ` ON DELETE ${con.references.onDelete}`;
+                if (con.references.onUpdate)
+                    def += ` ON UPDATE ${con.references.onUpdate}`;
+            }
+            return def;
+        }
+        default:
+            return con.expression || '';
+    }
+}
 function generateParsedColumnDef(col) {
     const parts = [`"${col.name}"`, col.type];
     if (col.isPrimaryKey) {
@@ -463,15 +553,29 @@ function generateMigrationFile(diff, name, options = {}) {
 }
 function generateCreateTable(table) {
     const sql = [];
+    sql.push(`-- ==================================================================`);
+    sql.push(`--  TABLE: ${table.name}`);
+    sql.push(`-- ==================================================================`);
+    sql.push('');
     const columnDefs = [];
     const constraintDefs = [];
+    const maxNameLen = Math.max(...table.columns.map(c => {
+        const quotedName = needsQuote(c.name) ? `"${c.name}"` : c.name;
+        return quotedName.length;
+    }));
+    const padWidth = Math.max(maxNameLen + 4, 28);
     for (const col of table.columns) {
-        columnDefs.push(`    ${generateColumnDefinition(col)}`);
+        columnDefs.push(`    ${generateColumnDefinitionAligned(col, padWidth)}`);
     }
     const hasPKColumn = table.columns.some(c => c.isPrimaryKey);
     for (const con of table.constraints || []) {
         if (con.type === 'PRIMARY KEY' && hasPKColumn)
             continue;
+        if (con.type === 'UNIQUE') {
+            const uniqueMatch = con.definition?.match(/^UNIQUE\s*\("([^"]+)"\)$/);
+            if (uniqueMatch && table.columns.some(c => c.isUnique && c.name === uniqueMatch[1]))
+                continue;
+        }
         constraintDefs.push(`    CONSTRAINT "${con.name}" ${con.definition}`);
     }
     const allDefs = [...columnDefs, ...constraintDefs];
@@ -480,40 +584,79 @@ function generateCreateTable(table) {
         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));
+    const indexes = (table.indexes || []).filter(idx => !idx.isPrimary);
+    if (indexes.length > 0) {
+        sql.push('');
+        sql.push(`-- Indexes for ${table.name}`);
+        for (const idx of indexes) {
+            sql.push(generateCreateIndex(table.name, idx));
+        }
     }
+    const commentCols = table.columns.filter(c => c.comment);
+    if (commentCols.length > 0) {
+        sql.push('');
+        sql.push(`-- Comments for ${table.name}`);
+        for (const col of commentCols) {
+            sql.push(`COMMENT ON COLUMN "${table.name}"."${col.name}" IS '${col.comment.replace(/'/g, "''")}';`);
+        }
+    }
+    sql.push('');
+    sql.push('');
     return sql;
 }
 function generateDropTable(table) {
     return [`DROP TABLE IF EXISTS "${table.name}" CASCADE;`];
 }
 function generateAlterTable(table, includeDown) {
-    const upSQL = [];
+    const columnSQL = [];
     const downSQL = [];
     const tableName = table.name;
     for (const col of table.columns || []) {
         const { up, down } = generateColumnChange(tableName, col);
-        upSQL.push(...up);
+        columnSQL.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);
+    const ddlStatements = columnSQL.filter(s => !s.startsWith('COMMENT ON'));
+    const commentStatements = columnSQL.filter(s => s.startsWith('COMMENT ON'));
+    const upSQL = [...ddlStatements];
+    const indexChanges = table.indexes || [];
+    if (indexChanges.length > 0) {
+        upSQL.push('');
+        upSQL.push(`-- Indexes for ${tableName}`);
+        for (const idx of indexChanges) {
+            const { up, down } = generateIndexChange(tableName, idx);
+            upSQL.push(...up);
+            if (includeDown)
+                downSQL.unshift(...down);
+        }
+    }
+    if (commentStatements.length > 0) {
+        upSQL.push('');
+        upSQL.push(`-- Comments for ${tableName}`);
+        upSQL.push(...commentStatements);
+    }
+    const constraintChanges = table.constraints || [];
+    if (constraintChanges.length > 0) {
+        upSQL.push('');
+        upSQL.push(`-- Constraints for ${tableName}`);
+        for (const con of constraintChanges) {
+            const { up, down } = generateConstraintChange(tableName, con);
+            upSQL.push(...up);
+            if (includeDown)
+                downSQL.unshift(...down);
+        }
     }
     return { upSQL, downSQL };
 }
+const PG_RESERVED = new Set([
+    'action', 'comment', 'data', 'date', 'domain', 'key', 'language', 'locked',
+    'method', 'name', 'order', 'password', 'read', 'schema', 'type', 'valid',
+    'value', 'version', 'interval',
+]);
+function needsQuote(name) {
+    return PG_RESERVED.has(name.toLowerCase()) || /[A-Z\s-]/.test(name);
+}
 function generateColumnDefinition(col) {
     const parts = [`"${col.name}"`, mapDataType(col)];
     if (col.isPrimaryKey) {
@@ -533,16 +676,43 @@ function generateColumnDefinition(col) {
     }
     return parts.join(' ');
 }
+function generateColumnDefinitionAligned(col, padWidth) {
+    const quotedName = `"${col.name}"`;
+    const paddedName = quotedName.padEnd(padWidth);
+    const typeParts = [mapDataType(col)];
+    if (col.isPrimaryKey) {
+        typeParts.push('PRIMARY KEY');
+    }
+    if (!col.isNullable && !col.isPrimaryKey) {
+        typeParts.push('NOT NULL');
+    }
+    if (col.isUnique && !col.isPrimaryKey) {
+        typeParts.push('UNIQUE');
+    }
+    if (col.defaultValue) {
+        typeParts.push(`DEFAULT ${col.defaultValue}`);
+    }
+    if (col.references) {
+        typeParts.push(`REFERENCES "${col.references.table}"("${col.references.column}")`);
+    }
+    return `${paddedName} ${typeParts.join(' ')}`;
+}
 function generateColumnChange(tableName, col) {
     const up = [];
     const down = [];
     if (col.type === 'added' && col.after) {
         up.push(`ALTER TABLE "${tableName}" ADD COLUMN ${generateColumnDefinition(col.after)};`);
+        if (col.after.comment) {
+            up.push(`COMMENT ON COLUMN "${tableName}"."${col.name}" IS '${col.after.comment.replace(/'/g, "''")}';`);
+        }
         down.push(`ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS "${col.name}";`);
     }
     if (col.type === 'removed' && 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.before.comment) {
+            down.push(`COMMENT ON COLUMN "${tableName}"."${col.name}" IS '${col.before.comment.replace(/'/g, "''")}';`);
+        }
     }
     if (col.type === 'modified' && col.changes && col.changes.length > 0) {
         for (const change of col.changes) {
@@ -617,6 +787,23 @@ function generateColumnChange(tableName, col) {
                     }
                     break;
                 }
+                case 'comment': {
+                    const newComment = change.to != null ? String(change.to) : null;
+                    const oldComment = change.from != null ? String(change.from) : null;
+                    if (newComment) {
+                        up.push(`COMMENT ON COLUMN "${tableName}"."${col.name}" IS '${newComment.replace(/'/g, "''")}';`);
+                    }
+                    else {
+                        up.push(`COMMENT ON COLUMN "${tableName}"."${col.name}" IS NULL;`);
+                    }
+                    if (oldComment) {
+                        down.push(`COMMENT ON COLUMN "${tableName}"."${col.name}" IS '${oldComment.replace(/'/g, "''")}';`);
+                    }
+                    else {
+                        down.push(`COMMENT ON COLUMN "${tableName}"."${col.name}" IS NULL;`);
+                    }
+                    break;
+                }
             }
         }
     }
@@ -626,7 +813,8 @@ 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}` : '';
+    const normalizedType = (idx.type || 'btree').toLowerCase();
+    const using = normalizedType !== 'btree' ? ` USING ${idx.type}` : '';
     return `CREATE ${unique}INDEX IF NOT EXISTS "${idx.name}" ON "${tableName}"${using} (${colList});`;
 }
 function generateIndexChange(tableName, idx) {

package/dist/cjs/cli/utils/schema-diff.cjs

@@ -21,6 +21,7 @@ function normalizedToColumnInfo(col) {
         maxLength: col.length ?? null,
         precision: null,
         scale: null,
+        comment: col.comment,
     };
 }
 const TYPE_ALIASES = {
@@ -234,6 +235,21 @@ function diffTables(local, remote) {
     const diffs = [];
     const localMap = new Map(local.map(t => [t.name, t]));
     const remoteMap = new Map(remote.map(t => [t.name, t]));
+    const toConstraintInfo = (c) => ({
+        name: c.name,
+        type: (c.type || 'CHECK'),
+        columns: [],
+        definition: c.definition || '',
+        trackingId: c.trackingId,
+    });
+    const toIndexInfo = (i) => ({
+        name: i.name,
+        columns: i.columns,
+        isUnique: i.unique,
+        isPrimary: false,
+        type: i.type || 'btree',
+        trackingId: i.trackingId,
+    });
     for (const [name, remoteTable] of remoteMap) {
         if (!localMap.has(name)) {
             diffs.push({
@@ -244,7 +260,16 @@ function diffTables(local, remote) {
                     type: 'added',
                     after: normalizedToColumnInfo(c),
                 })),
-                indexes: remoteTable.indexes.map(i => ({ name: i.name, type: 'added' })),
+                indexes: remoteTable.indexes.map(i => ({
+                    name: i.name,
+                    type: 'added',
+                    after: toIndexInfo(i),
+                })),
+                constraints: remoteTable.constraints.map(c => ({
+                    name: c.name,
+                    type: 'added',
+                    after: toConstraintInfo(c),
+                })),
             });
         }
     }
@@ -258,7 +283,16 @@ function diffTables(local, remote) {
                     type: 'removed',
                     before: normalizedToColumnInfo(c),
                 })),
-                indexes: localTable.indexes.map(i => ({ name: i.name, type: 'removed' })),
+                indexes: localTable.indexes.map(i => ({
+                    name: i.name,
+                    type: 'removed',
+                    before: toIndexInfo(i),
+                })),
+                constraints: localTable.constraints.map(c => ({
+                    name: c.name,
+                    type: 'removed',
+                    before: toConstraintInfo(c),
+                })),
             });
         }
     }
@@ -325,20 +359,31 @@ function compareColumns(local, remote) {
     if (local.isUnique !== remote.isUnique) {
         changes.push({ field: 'unique', from: local.isUnique, to: remote.isUnique });
     }
+    if ((local.comment || undefined) !== (remote.comment || undefined)) {
+        changes.push({ field: 'comment', from: local.comment, to: remote.comment });
+    }
     return changes;
 }
 function diffIndexes(local, remote) {
     const diffs = [];
     const localMap = new Map(local.map(i => [i.name, i]));
     const remoteMap = new Map(remote.map(i => [i.name, i]));
-    for (const [name] of remoteMap) {
+    const toIdxInfo = (i) => ({
+        name: i.name,
+        columns: i.columns,
+        isUnique: i.unique,
+        isPrimary: false,
+        type: i.type || 'btree',
+        trackingId: i.trackingId,
+    });
+    for (const [name, idx] of remoteMap) {
         if (!localMap.has(name)) {
-            diffs.push({ name, type: 'added' });
+            diffs.push({ name, type: 'added', after: toIdxInfo(idx) });
         }
     }
-    for (const [name] of localMap) {
+    for (const [name, idx] of localMap) {
         if (!remoteMap.has(name)) {
-            diffs.push({ name, type: 'removed' });
+            diffs.push({ name, type: 'removed', before: toIdxInfo(idx) });
         }
     }
     return diffs;
@@ -608,6 +653,7 @@ function formatCategorizedSummary(diff) {
     let pkAdded = 0, pkRemoved = 0;
     let checkAdded = 0, checkRemoved = 0;
     let extAdded = 0, extRemoved = 0;
+    let commentsAdded = 0, commentsRemoved = 0, commentsModified = 0;
     for (const table of diff.tables) {
         if (table.type === 'added')
             tablesAdded++;
@@ -616,12 +662,29 @@ function formatCategorizedSummary(diff) {
         else if (table.type === 'modified')
             tablesModified++;
         for (const col of table.columns || []) {
-            if (col.type === 'added')
+            if (col.type === 'added') {
                 colsAdded++;
-            else if (col.type === 'removed')
+                if (col.after?.comment)
+                    commentsAdded++;
+            }
+            else if (col.type === 'removed') {
                 colsRemoved++;
-            else if (col.type === 'modified')
+                if (col.before?.comment)
+                    commentsRemoved++;
+            }
+            else if (col.type === 'modified') {
                 colsModified++;
+                for (const change of col.changes || []) {
+                    if (change.field === 'comment') {
+                        if (change.from && change.to)
+                            commentsModified++;
+                        else if (change.to)
+                            commentsAdded++;
+                        else if (change.from)
+                            commentsRemoved++;
+                    }
+                }
+            }
         }
         for (const idx of table.indexes || []) {
             if (idx.type === 'added')
@@ -706,6 +769,7 @@ function formatCategorizedSummary(diff) {
     fmt('unique constraints', uniqueAdded, uniqueRemoved);
     fmt('foreign keys', fkAdded, fkRemoved);
     fmt('check constraints', checkAdded, checkRemoved);
+    fmt('comments', commentsAdded, commentsRemoved, commentsModified);
     fmt('extensions', extAdded, extRemoved);
     return lines;
 }

package/dist/cjs/cli/utils/schema-hash.cjs

@@ -41,22 +41,14 @@ const crypto = __importStar(require("node:crypto"));
 function normalizeSchema(schema) {
     const userTables = schema.tables.filter(t => !t.name.startsWith('_relq') &&
         !t.name.startsWith('relq_'));
-    const tables = userTables
-        .map(normalizeTable)
-        .sort((a, b) => a.name.localeCompare(b.name));
-    const extensions = [...schema.extensions].sort();
+    const tables = userTables.map(normalizeTable);
+    const extensions = [...schema.extensions];
     return { tables, extensions };
 }
 function normalizeTable(table) {
-    const columns = table.columns
-        .map(normalizeColumn)
-        .sort((a, b) => a.name.localeCompare(b.name));
-    const indexes = (table.indexes || [])
-        .map(normalizeIndex)
-        .sort((a, b) => a.name.localeCompare(b.name));
-    const constraints = (table.constraints || [])
-        .map(normalizeConstraint)
-        .sort((a, b) => a.name.localeCompare(b.name));
+    const columns = table.columns.map(normalizeColumn);
+    const indexes = (table.indexes || []).map(normalizeIndex);
+    const constraints = (table.constraints || []).map(normalizeConstraint);
     return {
         name: table.name,
         columns,
@@ -105,6 +97,7 @@ function normalizeColumn(col) {
         isPrimaryKey: col.isPrimaryKey ?? false,
         isUnique: col.isUnique ?? false,
         length: explicitLength ?? extractedLength,
+        comment: col.comment ?? c.comment ?? undefined,
         trackingId: col.trackingId ?? c.trackingId,
     };
 }
@@ -127,7 +120,18 @@ function normalizeConstraint(con) {
 }
 function generateSchemaHash(schema) {
     const normalized = normalizeSchema(schema);
-    const json = JSON.stringify(normalized, null, 0);
+    const sorted = {
+        tables: [...normalized.tables]
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map(t => ({
+            ...t,
+            columns: [...t.columns].sort((a, b) => a.name.localeCompare(b.name)),
+            indexes: [...t.indexes].sort((a, b) => a.name.localeCompare(b.name)),
+            constraints: [...t.constraints].sort((a, b) => a.name.localeCompare(b.name)),
+        })),
+        extensions: [...normalized.extensions].sort(),
+    };
+    const json = JSON.stringify(sorted, null, 0);
     return crypto
         .createHash('sha1')
         .update(json, 'utf8')