relq 1.0.4 → 1.0.6

package/dist/cjs/cli/utils/change-tracker.cjs

@@ -78,6 +78,8 @@ function generateChangeSQL(change) {
             return generateTableCommentSQL(change);
         case 'COLUMN_COMMENT':
             return generateColumnCommentSQL(change);
+        case 'INDEX_COMMENT':
+            return generateIndexCommentSQL(change);
         case 'VIEW':
             return generateViewSQL(change);
         case 'MATERIALIZED_VIEW':
@@ -222,6 +224,13 @@ function generateColumnSQL(change) {
     else if (change.type === 'DROP') {
         return `ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS "${change.objectName}" CASCADE;`;
     }
+    else if (change.type === 'RENAME' && data) {
+        const before = change.before;
+        if (before?.name) {
+            return `ALTER TABLE "${tableName}" RENAME COLUMN "${before.name}" TO "${data.name}";`;
+        }
+        return '';
+    }
     else if (change.type === 'ALTER' && data) {
         const before = change.before;
         const lines = [];
@@ -262,6 +271,13 @@ function generateIndexSQL(change) {
     else if (change.type === 'DROP') {
         return `DROP INDEX IF EXISTS "${change.objectName}";`;
     }
+    else if (change.type === 'RENAME' && data) {
+        const before = change.before;
+        if (before?.name) {
+            return `ALTER INDEX "${before.name}" RENAME TO "${data.name}";`;
+        }
+        return '';
+    }
     return '';
 }
 function generateConstraintSQL(change) {
@@ -317,6 +333,19 @@ function generateColumnCommentSQL(change) {
     }
     return '';
 }
+function generateIndexCommentSQL(change) {
+    const data = change.after;
+    if ((change.type === 'CREATE' || change.type === 'ALTER') && data) {
+        const escaped = data.comment.replace(/'/g, "''");
+        return `COMMENT ON INDEX "${data.indexName}" IS '${escaped}';`;
+    }
+    else if (change.type === 'DROP') {
+        const beforeData = change.before;
+        const indexName = beforeData?.indexName || change.objectName;
+        return `COMMENT ON INDEX "${indexName}" IS NULL;`;
+    }
+    return '';
+}
 function generateViewSQL(change) {
     const data = change.after;
     if (change.type === 'CREATE' && data) {
@@ -444,7 +473,8 @@ function getChangeDisplayName(change) {
     const prefix = change.type === 'CREATE' ? '+' :
         change.type === 'DROP' ? '-' :
             change.type === 'ALTER' ? '~' :
-                '>';
+                change.type === 'RENAME' ? '→' :
+                    '>';
     if (change.objectType === 'INDEX') {
         const data = change.after;
         const tableName = data?.tableName || change.parentName;
@@ -452,6 +482,14 @@ function getChangeDisplayName(change) {
             return `${prefix} ${change.objectType} ${change.objectName} on ${tableName}`;
         }
     }
+    if (change.objectType === 'INDEX_COMMENT') {
+        const data = (change.after || change.before);
+        const tableName = data?.tableName || change.parentName;
+        if (tableName) {
+            return `${prefix} INDEX COMMENT ${change.objectName} on ${tableName}`;
+        }
+        return `${prefix} INDEX COMMENT ${change.objectName}`;
+    }
     if (change.objectType === 'PARTITION') {
         const data = change.after;
         if (data?.tableName && data?.type && data?.key) {
@@ -481,6 +519,16 @@ function getChangeDisplayName(change) {
         }
         return `${prefix} ${actionWord} ${change.objectType.replace('_', ' ')} ${change.objectName}`;
     }
+    if (change.type === 'RENAME') {
+        const before = change.before;
+        const after = change.after;
+        if (before?.name && after?.name) {
+            if (change.parentName) {
+                return `${prefix} RENAME ${change.objectType} ${change.parentName}.${before.name} → ${after.name}`;
+            }
+            return `${prefix} RENAME ${change.objectType} ${before.name} → ${after.name}`;
+        }
+    }
     if (change.parentName) {
         return `${prefix} ${change.objectType} ${change.parentName}.${change.objectName}`;
     }
@@ -503,6 +551,7 @@ function sortChangesByDependency(changes) {
         'COLUMN': 13,
         'COLUMN_COMMENT': 12,
         'INDEX': 13,
+        'INDEX_COMMENT': 13,
         'CONSTRAINT': 14,
         'PRIMARY_KEY': 14,
         'FOREIGN_KEY': 15,

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

@@ -32,6 +32,9 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.colors = void 0;
 exports.createSpinner = createSpinner;
@@ -46,8 +49,11 @@ exports.formatBytes = formatBytes;
 exports.formatDuration = formatDuration;
 exports.progressBar = progressBar;
 exports.requireInit = requireInit;
+exports.createMultiProgress = createMultiProgress;
 const readline = __importStar(require("readline"));
+const cli_spinners_1 = __importDefault(require("cli-spinners"));
 const isColorSupported = process.stdout.isTTY && !process.env.NO_COLOR;
+const isTTY = process.stdout.isTTY;
 exports.colors = {
     reset: '\x1b[0m',
     red: (s) => isColorSupported ? `\x1b[31m${s}\x1b[0m` : s,
@@ -215,3 +221,148 @@ function requireInit(isInitialized, projectRoot) {
         fatal('not a relq repository (or any of the parent directories): .relq', "run 'relq init' to initialize a repository");
     }
 }
+function createMultiProgress() {
+    const spinner = cli_spinners_1.default.dots;
+    let items = [];
+    let frameIndex = 0;
+    let interval = null;
+    let isRunning = false;
+    let lineCount = 0;
+    let lastPrintedStatus = new Map();
+    const moveCursorUp = (lines) => {
+        if (isTTY && lines > 0) {
+            process.stdout.write(`\x1b[${lines}A`);
+        }
+    };
+    const clearLine = () => {
+        if (isTTY) {
+            process.stdout.write('\x1b[2K\r');
+        }
+    };
+    const padNumber = (n, width = 4) => {
+        return n.toString().padStart(width);
+    };
+    const render = () => {
+        if (!isRunning || !isTTY)
+            return;
+        if (lineCount > 0) {
+            moveCursorUp(lineCount);
+        }
+        const frame = spinner.frames[frameIndex];
+        frameIndex = (frameIndex + 1) % spinner.frames.length;
+        for (const item of items) {
+            clearLine();
+            let prefix;
+            let statusText;
+            let countStr = padNumber(item.count);
+            if (item.status === 'pending') {
+                prefix = exports.colors.gray('[ ]');
+                statusText = exports.colors.gray(`${countStr} ${item.label} waiting`);
+            }
+            else if (item.status === 'fetching') {
+                prefix = exports.colors.cyan(`[${frame}]`);
+                statusText = exports.colors.white(`${countStr} ${item.label} fetching`);
+            }
+            else if (item.status === 'done') {
+                prefix = exports.colors.green('[+]');
+                statusText = exports.colors.green(`${countStr} ${item.label} fetched`);
+            }
+            else {
+                prefix = exports.colors.red('[x]');
+                statusText = exports.colors.red(`${countStr} ${item.label} error`);
+            }
+            process.stdout.write(`${prefix} ${statusText}\n`);
+        }
+        lineCount = items.length;
+    };
+    const printStaticLine = (item) => {
+        let prefix;
+        let statusText;
+        let countStr = padNumber(item.count);
+        if (item.status === 'error') {
+            prefix = '[x]';
+            statusText = `${countStr} ${item.label} error`;
+        }
+        else if (item.status === 'done' && item.count > 0) {
+            prefix = '[+]';
+            statusText = `${countStr} ${item.label} fetched`;
+        }
+        else if (item.status === 'done') {
+            prefix = '[+]';
+            statusText = `${countStr} ${item.label} fetched`;
+        }
+        else if (item.status === 'fetching') {
+            prefix = '[~]';
+            statusText = `${countStr} ${item.label} fetching`;
+        }
+        else {
+            prefix = '[ ]';
+            statusText = `${countStr} ${item.label} waiting`;
+        }
+        console.log(`${prefix} ${statusText}`);
+    };
+    return {
+        setItems(newItems) {
+            items = [...newItems];
+            lastPrintedStatus.clear();
+        },
+        updateItem(id, updates) {
+            const item = items.find(i => i.id === id);
+            if (item) {
+                const prevStatus = item.status;
+                Object.assign(item, updates);
+                if (!isTTY && isRunning) {
+                    const statusKey = `${item.id}:${item.status}:${item.count}`;
+                    if (lastPrintedStatus.get(item.id) !== statusKey) {
+                        printStaticLine(item);
+                        lastPrintedStatus.set(item.id, statusKey);
+                    }
+                }
+            }
+        },
+        start() {
+            if (isRunning)
+                return;
+            isRunning = true;
+            frameIndex = 0;
+            lineCount = 0;
+            lastPrintedStatus.clear();
+            if (isTTY) {
+                interval = setInterval(render, spinner.interval);
+                render();
+            }
+        },
+        stop() {
+            if (interval) {
+                clearInterval(interval);
+                interval = null;
+            }
+            isRunning = false;
+        },
+        complete() {
+            this.stop();
+            if (isTTY && lineCount > 0) {
+                moveCursorUp(lineCount);
+                for (const item of items) {
+                    clearLine();
+                    let prefix;
+                    let statusText;
+                    let countStr = padNumber(item.count);
+                    if (item.status === 'error') {
+                        prefix = exports.colors.red('[x]');
+                        statusText = exports.colors.red(`${countStr} ${item.label} error`);
+                    }
+                    else if (item.status === 'done' && item.count > 0) {
+                        prefix = exports.colors.green('[+]');
+                        statusText = exports.colors.green(`${countStr} ${item.label} fetched`);
+                    }
+                    else {
+                        prefix = exports.colors.dim('[+]');
+                        statusText = exports.colors.dim(`${countStr} ${item.label} fetched`);
+                    }
+                    process.stdout.write(`${prefix} ${statusText}\n`);
+                }
+            }
+        }
+    };
+}

package/dist/cjs/cli/utils/fast-introspect.cjs

@@ -47,7 +47,7 @@ function parseOptionsArray(options) {
     return result;
 }
 async function fastIntrospectDatabase(connection, onProgress, options) {
-    const { includeFunctions = false, includeTriggers = false } = options || {};
+    const { includeFunctions = false, includeTriggers = false, onDetailedProgress } = options || {};
     const { Pool } = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
     onProgress?.('connecting', connection.database);
     const pool = new Pool({
@@ -61,6 +61,7 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
     });
     try {
         onProgress?.('fetching_tables');
+        onDetailedProgress?.({ step: 'tables', count: 0, status: 'fetching' });
         const tablesResult = await pool.query(`
             SELECT 
                 c.relname as table_name,
@@ -68,6 +69,7 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
                 c.reltuples::bigint as row_count,
                 c.relispartition as is_partition,
                 c.relkind = 'p' as is_partitioned,
+                obj_description(c.oid, 'pg_class') as table_comment,
                 CASE 
                     WHEN pt.partstrat = 'l' THEN 'LIST'
                     WHEN pt.partstrat = 'r' THEN 'RANGE'
@@ -88,7 +90,9 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
                 AND NOT c.relispartition
             ORDER BY c.relname;
         `);
+        onDetailedProgress?.({ step: 'tables', count: tablesResult.rows.length, status: 'done' });
         onProgress?.('fetching_columns');
+        onDetailedProgress?.({ step: 'columns', count: 0, status: 'fetching' });
         const columnsResult = await pool.query(`
             SELECT
                 c.table_name,
@@ -110,26 +114,43 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
             WHERE c.table_schema = 'public'
             ORDER BY c.table_name, c.ordinal_position;
         `);
+        onDetailedProgress?.({ step: 'columns', count: columnsResult.rows.length, status: 'done' });
+        onDetailedProgress?.({ step: 'constraints', count: 0, status: 'fetching' });
         const constraintsResult = await pool.query(`
             SELECT
                 tc.table_name,
                 tc.constraint_name,
                 tc.constraint_type,
-                array_agg(DISTINCT kcu.column_name ORDER BY kcu.column_name) as columns,
+                (
+                    SELECT array_agg(kcu.column_name ORDER BY kcu.ordinal_position)
+                    FROM information_schema.key_column_usage kcu
+                    WHERE kcu.constraint_name = tc.constraint_name 
+                      AND kcu.table_schema = tc.table_schema
+                      AND kcu.table_name = tc.table_name
+                ) as columns,
                 ccu.table_name as referenced_table,
-                array_agg(DISTINCT ccu.column_name) as referenced_columns,
+                (
+                    SELECT array_agg(a.attname ORDER BY array_position(con.confkey, a.attnum))
+                    FROM pg_constraint con
+                    JOIN pg_class rel ON con.conrelid = rel.oid
+                    JOIN pg_namespace nsp ON rel.relnamespace = nsp.oid
+                    JOIN pg_attribute a ON a.attrelid = con.confrelid AND a.attnum = ANY(con.confkey)
+                    WHERE con.conname = tc.constraint_name
+                      AND nsp.nspname = tc.table_schema
+                      AND rel.relname = tc.table_name
+                ) as referenced_columns,
                 rc.update_rule as on_update,
                 rc.delete_rule as on_delete
             FROM information_schema.table_constraints tc
-            JOIN information_schema.key_column_usage kcu
-                ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
             LEFT JOIN information_schema.constraint_column_usage ccu
                 ON tc.constraint_name = ccu.constraint_name AND tc.constraint_type = 'FOREIGN KEY'
             LEFT JOIN information_schema.referential_constraints rc
                 ON tc.constraint_name = rc.constraint_name AND tc.table_schema = rc.constraint_schema
             WHERE tc.table_schema = 'public'
-            GROUP BY tc.table_name, tc.constraint_name, tc.constraint_type, ccu.table_name, rc.update_rule, rc.delete_rule;
+            GROUP BY tc.table_schema, tc.table_name, tc.constraint_name, tc.constraint_type, ccu.table_name, rc.update_rule, rc.delete_rule;
         `);
+        onDetailedProgress?.({ step: 'constraints', count: constraintsResult.rows.length, status: 'done' });
+        onDetailedProgress?.({ step: 'indexes', count: 0, status: 'fetching' });
         const indexesResult = await pool.query(`
             SELECT
                 t.relname as table_name,
@@ -140,6 +161,7 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
                 pg_get_indexdef(ix.indexrelid) as index_definition,
                 pg_get_expr(ix.indpred, ix.indrelid) as where_clause,
                 pg_get_expr(ix.indexprs, ix.indrelid) as expression,
+                obj_description(i.oid, 'pg_class') as index_comment,
                 array_agg(a.attname ORDER BY array_position(ix.indkey, a.attnum)) FILTER (WHERE a.attnum > 0) as columns
             FROM pg_index ix
             JOIN pg_class t ON t.oid = ix.indrelid
@@ -149,8 +171,10 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
             LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
             WHERE n.nspname = 'public'
                 AND NOT ix.indisprimary
-            GROUP BY t.relname, i.relname, am.amname, ix.indisunique, ix.indisprimary, ix.indexrelid, ix.indpred, ix.indexprs, ix.indrelid;
+            GROUP BY t.relname, i.relname, i.oid, am.amname, ix.indisunique, ix.indisprimary, ix.indexrelid, ix.indpred, ix.indexprs, ix.indrelid;
         `);
+        onDetailedProgress?.({ step: 'indexes', count: indexesResult.rows.length, status: 'done' });
+        onDetailedProgress?.({ step: 'checks', count: 0, status: 'fetching' });
         const checksResult = await pool.query(`
             SELECT
                 c.relname as table_name,
@@ -161,7 +185,9 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
             JOIN pg_namespace n ON n.oid = c.relnamespace
             WHERE n.nspname = 'public' AND con.contype = 'c';
         `);
+        onDetailedProgress?.({ step: 'checks', count: checksResult.rows.length, status: 'done' });
         onProgress?.('fetching_enums');
+        onDetailedProgress?.({ step: 'enums', count: 0, status: 'fetching' });
         const enumsResult = await pool.query(`
             SELECT
                 t.typname as enum_name,
@@ -174,6 +200,7 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
             GROUP BY t.typname, n.nspname
             ORDER BY t.typname;
         `);
+        onDetailedProgress?.({ step: 'enums', count: enumsResult.rows.length, status: 'done' });
         const enums = enumsResult.rows.map(row => ({
             name: row.enum_name,
             schema: row.enum_schema,
@@ -209,32 +236,46 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
             if (!constraintsByTable.has(con.table_name)) {
                 constraintsByTable.set(con.table_name, new Map());
             }
+            let constraintColumns;
+            if (Array.isArray(con.columns)) {
+                constraintColumns = con.columns;
+            }
+            else if (typeof con.columns === 'string') {
+                constraintColumns = con.columns.replace(/^\{|\}$/g, '').split(',').filter(Boolean);
+            }
+            else {
+                constraintColumns = [];
+            }
             constraintsByTable.get(con.table_name).set(con.constraint_name, {
                 type: con.constraint_type,
-                columns: con.columns,
+                columns: constraintColumns,
+                referenced_table: con.referenced_table,
+                referenced_columns: con.referenced_columns,
+                on_delete: con.on_delete,
+                on_update: con.on_update,
             });
             const columns = columnsByTable.get(con.table_name);
             if (columns) {
-                for (const colName of con.columns) {
-                    const col = columns.find(c => c.name === colName);
+                for (const rawColName of constraintColumns) {
+                    if (!rawColName)
+                        continue;
+                    const normalizedColName = rawColName.replace(/^"|"$/g, '').toLowerCase();
+                    const col = columns.find(c => c.name.toLowerCase() === normalizedColName);
                     if (col) {
                         if (con.constraint_type === 'PRIMARY KEY')
                             col.isPrimaryKey = true;
-                        if (con.constraint_type === 'UNIQUE')
-                            col.isUnique = true;
-                        if (con.constraint_type === 'FOREIGN KEY' && con.referenced_table) {
-                            col.references = {
-                                table: con.referenced_table,
-                                column: con.referenced_columns?.[0] || 'id',
-                                onDelete: con.on_delete || 'NO ACTION',
-                                onUpdate: con.on_update || 'NO ACTION',
-                            };
-                        }
                     }
                 }
             }
         }
         for (const idx of indexesResult.rows) {
+            const tableConstraints = constraintsByTable.get(idx.table_name);
+            if (tableConstraints?.has(idx.index_name)) {
+                const con = tableConstraints.get(idx.index_name);
+                if (con?.type === 'UNIQUE' || con?.type === 'PRIMARY KEY') {
+                    continue;
+                }
+            }
             if (!indexesByTable.has(idx.table_name)) {
                 indexesByTable.set(idx.table_name, []);
             }
@@ -250,6 +291,7 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
                 whereClause: idx.where_clause || null,
                 expression: idx.expression || null,
                 operatorClasses: operatorClasses.length > 0 ? operatorClasses : undefined,
+                comment: idx.index_comment || null,
             });
         }
         for (const chk of checksResult.rows) {
@@ -268,19 +310,87 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
             const tableName = row.table_name;
             if (tableName.startsWith('_relq') || tableName.startsWith('_kuery'))
                 continue;
+            const allConstraints = [
+                ...(checksByTable.get(tableName) || []),
+            ];
+            const tableConstraints = constraintsByTable.get(tableName);
+            if (tableConstraints) {
+                for (const [conName, con] of tableConstraints) {
+                    let cols = [];
+                    if (Array.isArray(con.columns)) {
+                        cols = con.columns;
+                    }
+                    else if (typeof con.columns === 'string') {
+                        cols = con.columns.replace(/^\{|\}$/g, '').split(',').filter(Boolean);
+                    }
+                    if (con.type === 'PRIMARY KEY' && cols.length > 0) {
+                        const colList = cols.map(c => `"${c}"`).join(', ');
+                        allConstraints.push({
+                            name: conName,
+                            type: 'PRIMARY KEY',
+                            columns: cols,
+                            definition: `PRIMARY KEY (${colList})`,
+                        });
+                    }
+                    else if (con.type === 'UNIQUE' && cols.length > 0) {
+                        const colList = cols.map(c => `"${c}"`).join(', ');
+                        allConstraints.push({
+                            name: conName,
+                            type: 'UNIQUE',
+                            columns: cols,
+                            definition: `UNIQUE (${colList})`,
+                        });
+                    }
+                    else if (con.type === 'FOREIGN KEY' && cols.length > 0) {
+                        const refTable = con.referenced_table;
+                        const rawRefCols = con.referenced_columns;
+                        const onDelete = con.on_delete;
+                        const onUpdate = con.on_update;
+                        let refCols = [];
+                        if (Array.isArray(rawRefCols)) {
+                            refCols = rawRefCols;
+                        }
+                        else if (typeof rawRefCols === 'string') {
+                            refCols = rawRefCols.replace(/^\{|\}$/g, '').split(',').filter(Boolean);
+                        }
+                        const colList = cols.map(c => `"${c}"`).join(', ');
+                        const refColList = refCols.map((c) => `"${c}"`).join(', ');
+                        let definition = `FOREIGN KEY (${colList}) REFERENCES "${refTable}" (${refColList})`;
+                        if (onDelete && onDelete !== 'NO ACTION')
+                            definition += ` ON DELETE ${onDelete}`;
+                        if (onUpdate && onUpdate !== 'NO ACTION')
+                            definition += ` ON UPDATE ${onUpdate}`;
+                        allConstraints.push({
+                            name: conName,
+                            type: 'FOREIGN KEY',
+                            columns: cols,
+                            definition,
+                        });
+                    }
+                }
+            }
+            let partitionKey = [];
+            if (Array.isArray(row.partition_key)) {
+                partitionKey = row.partition_key;
+            }
+            else if (typeof row.partition_key === 'string') {
+                partitionKey = row.partition_key.replace(/^\{|\}$/g, '').split(',').filter(Boolean);
+            }
             tables.push({
                 name: tableName,
                 schema: row.table_schema,
                 columns: columnsByTable.get(tableName) || [],
                 indexes: indexesByTable.get(tableName) || [],
-                constraints: checksByTable.get(tableName) || [],
+                constraints: allConstraints,
                 rowCount: parseInt(row.row_count) || 0,
                 isPartitioned: row.is_partitioned || false,
                 partitionType: row.partition_type,
-                partitionKey: row.partition_key || [],
+                partitionKey: partitionKey,
+                comment: row.table_comment || null,
             });
         }
         onProgress?.('fetching_partitions');
+        onDetailedProgress?.({ step: 'partitions', count: 0, status: 'fetching' });
         const partitionsResult = await pool.query(`
             SELECT 
                 child.relname as partition_name,
@@ -308,19 +418,26 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
             }
             partitionsByParent.get(partition.parentTable).push(partition);
         }
+        let attachedPartitionCount = 0;
         for (const table of tables) {
             if (table.isPartitioned) {
-                table.childPartitions = partitionsByParent.get(table.name) || [];
+                const childPartitions = partitionsByParent.get(table.name) || [];
+                table.childPartitions = childPartitions;
+                attachedPartitionCount += childPartitions.length;
             }
         }
+        onDetailedProgress?.({ step: 'partitions', count: attachedPartitionCount, status: 'done' });
         onProgress?.('fetching_extensions');
+        onDetailedProgress?.({ step: 'extensions', count: 0, status: 'fetching' });
         const extensionsResult = await pool.query(`
             SELECT extname FROM pg_extension WHERE extname != 'plpgsql';
         `);
         const extensions = extensionsResult.rows.map(r => r.extname);
+        onDetailedProgress?.({ step: 'extensions', count: extensions.length, status: 'done' });
         let functions = [];
         if (includeFunctions) {
             onProgress?.('fetching_functions');
+            onDetailedProgress?.({ step: 'functions', count: 0, status: 'fetching' });
             const functionsResult = await pool.query(`
                 SELECT 
                     p.proname as name,
@@ -348,10 +465,12 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
                 isAggregate: f.is_aggregate || false,
                 volatility: f.volatility === 'i' ? 'IMMUTABLE' : f.volatility === 's' ? 'STABLE' : 'VOLATILE',
             }));
+            onDetailedProgress?.({ step: 'functions', count: functions.length, status: 'done' });
         }
         let triggers = [];
         if (includeTriggers) {
             onProgress?.('fetching_triggers');
+            onDetailedProgress?.({ step: 'triggers', count: 0, status: 'fetching' });
             const triggersResult = await pool.query(`
                 SELECT
                     t.tgname as name,
@@ -387,8 +506,10 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
                 definition: t.definition || '',
                 isEnabled: t.is_enabled,
             }));
+            onDetailedProgress?.({ step: 'triggers', count: triggers.length, status: 'done' });
         }
         onProgress?.('fetching_collations');
+        onDetailedProgress?.({ step: 'collations', count: 0, status: 'fetching' });
         const collationsResult = await pool.query(`
             SELECT 
                 c.collname as name,
@@ -410,7 +531,9 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
             lcCtype: c.lc_ctype,
             deterministic: c.deterministic,
         }));
+        onDetailedProgress?.({ step: 'collations', count: collations.length, status: 'done' });
         onProgress?.('fetching_foreign_servers');
+        onDetailedProgress?.({ step: 'foreign_servers', count: 0, status: 'fetching' });
         const foreignServersResult = await pool.query(`
             SELECT 
                 s.srvname as name,
@@ -425,7 +548,9 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
             foreignDataWrapper: s.fdw,
             options: parseOptionsArray(s.options),
         }));
+        onDetailedProgress?.({ step: 'foreign_servers', count: foreignServers.length, status: 'done' });
         onProgress?.('fetching_foreign_tables');
+        onDetailedProgress?.({ step: 'foreign_tables', count: 0, status: 'fetching' });
         const foreignTablesResult = await pool.query(`
             SELECT 
                 c.relname as name,
@@ -481,6 +606,7 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
             })),
             options: parseOptionsArray(t.options),
         }));
+        onDetailedProgress?.({ step: 'foreign_tables', count: foreignTables.length, status: 'done' });
         onProgress?.('complete');
         return {
             tables,

package/dist/cjs/cli/utils/pg-parser.cjs

@@ -0,0 +1 @@
+"use strict";