supatool 0.6.5 → 0.6.6

package/dist/sync/definitionExtractor.js

@@ -33,9 +33,33 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveMaxConcurrent = resolveMaxConcurrent;
+exports.resolveConnectionTimeoutMs = resolveConnectionTimeoutMs;
+exports.resolveQueryTimeoutMs = resolveQueryTimeoutMs;
 exports.extractDefinitions = extractDefinitions;
+exports.fetchTableDefinitions = fetchTableDefinitions;
 exports.generateCreateTableDDL = generateCreateTableDDL;
 const pg_1 = require("pg");
+const DEFAULT_MAX_CONCURRENT = 5;
+const DEFAULT_CONNECTION_TIMEOUT_MS = 15000;
+const DEFAULT_QUERY_TIMEOUT_MS = 60000;
+function resolveBoundedPositiveInteger(rawValue, fallback, maximum) {
+    if (rawValue === undefined || rawValue.trim() === '')
+        return fallback;
+    const parsed = Number(rawValue);
+    if (!Number.isInteger(parsed) || parsed < 1)
+        return fallback;
+    return Math.min(maximum, parsed);
+}
+function resolveMaxConcurrent(rawValue = process.env.SUPATOOL_MAX_CONCURRENT) {
+    return resolveBoundedPositiveInteger(rawValue, DEFAULT_MAX_CONCURRENT, 50);
+}
+function resolveConnectionTimeoutMs(rawValue = process.env.SUPATOOL_CONNECTION_TIMEOUT_MS) {
+    return resolveBoundedPositiveInteger(rawValue, DEFAULT_CONNECTION_TIMEOUT_MS, 300000);
+}
+function resolveQueryTimeoutMs(rawValue = process.env.SUPATOOL_QUERY_TIMEOUT_MS) {
+    return resolveBoundedPositiveInteger(rawValue, DEFAULT_QUERY_TIMEOUT_MS, 300000);
+}
 /**
  * Display progress
  */
@@ -100,9 +124,8 @@ function stopProgressDisplay() {
  */
 async function fetchRlsPolicies(client, spinner, progress, schemas = ['public']) {
     const policies = [];
-    try {
-        const schemaPlaceholders = schemas.map((_, index) => `$${index + 1}`).join(', ');
-        const result = await client.query(`
+    const schemaPlaceholders = schemas.map((_, index) => `$${index + 1}`).join(', ');
+    const result = await client.query(`
       SELECT 
         schemaname,
         tablename,
@@ -116,78 +139,73 @@ async function fetchRlsPolicies(client, spinner, progress, schemas = ['public'])
       WHERE schemaname IN (${schemaPlaceholders})
       ORDER BY schemaname, tablename, policyname
     `, schemas);
-        const groupedPolicies = {};
-        for (const row of result.rows) {
-            const tableKey = `${row.schemaname}.${row.tablename}`;
-            if (!groupedPolicies[tableKey]) {
-                groupedPolicies[tableKey] = [];
-            }
-            groupedPolicies[tableKey].push(row);
+    const groupedPolicies = {};
+    for (const row of result.rows) {
+        const tableKey = `${row.schemaname}.${row.tablename}`;
+        if (!groupedPolicies[tableKey]) {
+            groupedPolicies[tableKey] = [];
         }
-        const tableKeys = Object.keys(groupedPolicies);
-        // Initialize progress
-        if (progress) {
-            progress.rls.total = tableKeys.length;
+        groupedPolicies[tableKey].push(row);
+    }
+    const tableKeys = Object.keys(groupedPolicies);
+    // Initialize progress
+    if (progress) {
+        progress.rls.total = tableKeys.length;
+    }
+    for (let i = 0; i < tableKeys.length; i++) {
+        const tableKey = tableKeys[i];
+        const tablePolicies = groupedPolicies[tableKey];
+        const firstPolicy = tablePolicies[0];
+        const schemaName = firstPolicy.schemaname;
+        const tableName = firstPolicy.tablename;
+        // Update progress
+        if (progress && spinner) {
+            progress.rls.current = i + 1;
+            displayProgress(progress, spinner);
         }
-        for (let i = 0; i < tableKeys.length; i++) {
-            const tableKey = tableKeys[i];
-            const tablePolicies = groupedPolicies[tableKey];
-            const firstPolicy = tablePolicies[0];
-            const schemaName = firstPolicy.schemaname;
-            const tableName = firstPolicy.tablename;
-            // Update progress
-            if (progress && spinner) {
-                progress.rls.current = i + 1;
-                displayProgress(progress, spinner);
-            }
-            // Add RLS policy description at top
-            let ddl = `-- RLS Policies for ${schemaName}.${tableName}\n`;
-            ddl += `-- Row Level Security policies to control data access at the row level\n\n`;
-            ddl += `ALTER TABLE ${schemaName}.${tableName} ENABLE ROW LEVEL SECURITY;\n\n`;
-            for (const policy of tablePolicies) {
-                ddl += `CREATE POLICY ${policy.policyname}\n`;
-                ddl += `  ON ${schemaName}.${tableName}\n`;
-                ddl += `  AS ${policy.permissive || 'PERMISSIVE'}\n`;
-                ddl += `  FOR ${policy.cmd || 'ALL'}\n`;
-                if (policy.roles) {
-                    // Handle roles as array or string
-                    let roles;
-                    if (Array.isArray(policy.roles)) {
-                        roles = policy.roles.join(', ');
-                    }
-                    else {
-                        // Handle PostgreSQL array literal "{role1,role2}" or plain string
-                        roles = String(policy.roles)
-                            .replace(/[{}]/g, '') // Remove braces
-                            .replace(/"/g, ''); // Remove double quotes
-                    }
-                    if (roles && roles.trim() !== '') {
-                        ddl += `  TO ${roles}\n`;
-                    }
+        // Add RLS policy description at top
+        let ddl = `-- RLS Policies for ${schemaName}.${tableName}\n`;
+        ddl += `-- Row Level Security policies to control data access at the row level\n\n`;
+        ddl += `ALTER TABLE ${schemaName}.${tableName} ENABLE ROW LEVEL SECURITY;\n\n`;
+        for (const policy of tablePolicies) {
+            ddl += `CREATE POLICY ${policy.policyname}\n`;
+            ddl += `  ON ${schemaName}.${tableName}\n`;
+            ddl += `  AS ${policy.permissive || 'PERMISSIVE'}\n`;
+            ddl += `  FOR ${policy.cmd || 'ALL'}\n`;
+            if (policy.roles) {
+                // Handle roles as array or string
+                let roles;
+                if (Array.isArray(policy.roles)) {
+                    roles = policy.roles.join(', ');
                 }
-                if (policy.qual) {
-                    ddl += `  USING (${policy.qual})\n`;
+                else {
+                    // Handle PostgreSQL array literal "{role1,role2}" or plain string
+                    roles = String(policy.roles)
+                        .replace(/[{}]/g, '') // Remove braces
+                        .replace(/"/g, ''); // Remove double quotes
                 }
-                if (policy.with_check) {
-                    ddl += `  WITH CHECK (${policy.with_check})\n`;
+                if (roles && roles.trim() !== '') {
+                    ddl += `  TO ${roles}\n`;
                 }
-                ddl += ';\n\n';
             }
-            policies.push({
-                name: `${schemaName}_${tableName}_policies`,
-                type: 'rls',
-                category: `${schemaName}.${tableName}`,
-                schema: schemaName,
-                ddl,
-                timestamp: Math.floor(Date.now() / 1000)
-            });
+            if (policy.qual) {
+                ddl += `  USING (${policy.qual})\n`;
+            }
+            if (policy.with_check) {
+                ddl += `  WITH CHECK (${policy.with_check})\n`;
+            }
+            ddl += ';\n\n';
         }
-        return policies;
-    }
-    catch (error) {
-        console.warn('Skipping RLS policies extraction:', error instanceof Error ? error.message : String(error));
-        return [];
+        policies.push({
+            name: `${schemaName}_${tableName}_policies`,
+            type: 'rls',
+            category: `${schemaName}.${tableName}`,
+            schema: schemaName,
+            ddl,
+            timestamp: Math.floor(Date.now() / 1000)
+        });
     }
+    return policies;
 }
 /**
  * Fetch RLS enabled flag and policy count for all tables (pg_class.relrowsecurity + pg_policies)
@@ -463,7 +481,13 @@ async function fetchCronJobs(client, spinner, progress) {
         }
     }
     catch (error) {
-        // Skip when pg_cron extension is not present
+        // pg_cron is optional. Only its absence is safe to skip; timeouts,
+        // permission failures, and other catalog errors must fail closed.
+        const code = typeof error === 'object' && error !== null && 'code' in error
+            ? String(error.code)
+            : undefined;
+        if (code !== '42P01')
+            throw error;
     }
     return cronJobs;
 }
@@ -655,12 +679,9 @@ async function fetchTableDefinitions(client, spinner, progress, schemas = ['publ
         progress.tables.total = tableCount;
         progress.views.total = viewCount;
     }
-    // Process tables/views with limited concurrency (cap connection count)
-    // Max configurable via env (default 20, max 50)
-    const envValue = process.env.SUPATOOL_MAX_CONCURRENT || '20';
-    const MAX_CONCURRENT = Math.min(50, parseInt(envValue));
-    // Use env value (capped at minimum 5)
-    const CONCURRENT_LIMIT = Math.max(5, MAX_CONCURRENT);
+    // The client serializes queries on one connection. Keep the queue bounded and
+    // honour a requested value of 1 for constrained production catalog reads.
+    const CONCURRENT_LIMIT = resolveMaxConcurrent();
     // Debug log (development only)
     if (process.env.NODE_ENV === 'development' || process.env.SUPATOOL_DEBUG) {
         console.log(`Processing ${allObjects.length} objects with ${CONCURRENT_LIMIT} concurrent operations`);
@@ -675,126 +696,107 @@ async function fetchTableDefinitions(client, spinner, progress, schemas = ['publ
         let comment = '';
         let timestamp = Math.floor(new Date('2020-01-01').getTime() / 1000);
         if (type === 'table') {
-            // Table case
-            try {
-                // Get table last updated time
-                const tableStatsResult = await client.query(`
-          SELECT 
-            EXTRACT(EPOCH FROM GREATEST(
-              COALESCE(last_vacuum, '1970-01-01'::timestamp),
-              COALESCE(last_autovacuum, '1970-01-01'::timestamp),
-              COALESCE(last_analyze, '1970-01-01'::timestamp),
-              COALESCE(last_autoanalyze, '1970-01-01'::timestamp)
-            ))::bigint as last_updated
-          FROM pg_stat_user_tables 
-          WHERE relname = $1 AND schemaname = $2
-        `, [name, schemaName]);
-                if (tableStatsResult.rows.length > 0 && tableStatsResult.rows[0].last_updated > 0) {
-                    timestamp = tableStatsResult.rows[0].last_updated;
-                }
-            }
-            catch (error) {
-                // On error use default timestamp
+            // Get table last updated time. Catalog errors must abort extraction so
+            // an incomplete definition set is never written.
+            const tableStatsResult = await client.query(`
+        SELECT
+          EXTRACT(EPOCH FROM GREATEST(
+            COALESCE(last_vacuum, '1970-01-01'::timestamp),
+            COALESCE(last_autovacuum, '1970-01-01'::timestamp),
+            COALESCE(last_analyze, '1970-01-01'::timestamp),
+            COALESCE(last_autoanalyze, '1970-01-01'::timestamp)
+          ))::bigint as last_updated
+        FROM pg_stat_user_tables
+        WHERE relname = $1 AND schemaname = $2
+      `, [name, schemaName]);
+            if (tableStatsResult.rows.length > 0 && tableStatsResult.rows[0].last_updated > 0) {
+                timestamp = tableStatsResult.rows[0].last_updated;
             }
             // Generate CREATE TABLE statement
             ddl = await generateCreateTableDDL(client, name, schemaName);
             // Get table comment
-            try {
-                const tableCommentResult = await client.query(`
-          SELECT obj_description(c.oid) as table_comment
-          FROM pg_class c
-          JOIN pg_namespace n ON c.relnamespace = n.oid
-          WHERE c.relname = $1 AND n.nspname = $2 AND c.relkind = 'r'
-        `, [name, schemaName]);
-                if (tableCommentResult.rows.length > 0 && tableCommentResult.rows[0].table_comment) {
-                    comment = tableCommentResult.rows[0].table_comment;
-                }
-            }
-            catch (error) {
-                // On error no comment
+            const tableCommentResult = await client.query(`
+        SELECT obj_description(c.oid) as table_comment
+        FROM pg_class c
+        JOIN pg_namespace n ON c.relnamespace = n.oid
+        WHERE c.relname = $1 AND n.nspname = $2 AND c.relkind = 'r'
+      `, [name, schemaName]);
+            if (tableCommentResult.rows.length > 0 && tableCommentResult.rows[0].table_comment) {
+                comment = tableCommentResult.rows[0].table_comment;
             }
         }
         else {
             // View case
-            try {
-                // Get view definition and security_invoker setting
-                const viewResult = await client.query(`
-          SELECT 
-            pv.definition,
-            c.relname,
-            c.reloptions
-          FROM pg_views pv
-          JOIN pg_class c ON c.relname = pv.viewname
-          JOIN pg_namespace n ON c.relnamespace = n.oid
-          WHERE pv.schemaname = $1 
-            AND pv.viewname = $2
-            AND n.nspname = $1
-            AND c.relkind = 'v'
-        `, [schemaName, name]);
-                if (viewResult.rows.length > 0) {
-                    const view = viewResult.rows[0];
-                    // Get view comment
-                    const viewCommentResult = await client.query(`
-            SELECT obj_description(c.oid) as view_comment
-            FROM pg_class c
-            JOIN pg_namespace n ON c.relnamespace = n.oid
-            WHERE c.relname = $1 AND n.nspname = $2 AND c.relkind = 'v'
-          `, [name, schemaName]);
-                    // Add view comment at top
-                    if (viewCommentResult.rows.length > 0 && viewCommentResult.rows[0].view_comment) {
-                        comment = viewCommentResult.rows[0].view_comment;
-                        ddl = `-- ${comment}\n`;
-                    }
-                    else {
-                        ddl = `-- View: ${name}\n`;
-                    }
-                    // Add view definition
-                    let ddlStart = `CREATE OR REPLACE VIEW ${schemaName}.${name}`;
-                    // Check security_invoker setting
-                    if (view.reloptions) {
-                        for (const option of view.reloptions) {
-                            if (option.startsWith('security_invoker=')) {
-                                const value = option.split('=')[1];
-                                if (value === 'on' || value === 'true') {
-                                    ddlStart += ' WITH (security_invoker = on)';
-                                }
-                                else if (value === 'off' || value === 'false') {
-                                    ddlStart += ' WITH (security_invoker = off)';
-                                }
-                                break;
-                            }
+            // Get view definition and security_invoker setting
+            const viewResult = await client.query(`
+        SELECT
+          pv.definition,
+          c.relname,
+          c.reloptions
+        FROM pg_views pv
+        JOIN pg_class c ON c.relname = pv.viewname
+        JOIN pg_namespace n ON c.relnamespace = n.oid
+        WHERE pv.schemaname = $1
+          AND pv.viewname = $2
+          AND n.nspname = $1
+          AND c.relkind = 'v'
+      `, [schemaName, name]);
+            if (viewResult.rows.length === 0) {
+                throw new Error(`View definition not found for ${schemaName}.${name}`);
+            }
+            const view = viewResult.rows[0];
+            // Get view comment
+            const viewCommentResult = await client.query(`
+        SELECT obj_description(c.oid) as view_comment
+        FROM pg_class c
+        JOIN pg_namespace n ON c.relnamespace = n.oid
+        WHERE c.relname = $1 AND n.nspname = $2 AND c.relkind = 'v'
+      `, [name, schemaName]);
+            // Add view comment at top
+            if (viewCommentResult.rows.length > 0 && viewCommentResult.rows[0].view_comment) {
+                comment = viewCommentResult.rows[0].view_comment;
+                ddl = `-- ${comment}\n`;
+            }
+            else {
+                ddl = `-- View: ${name}\n`;
+            }
+            // Add view definition
+            let ddlStart = `CREATE OR REPLACE VIEW ${schemaName}.${name}`;
+            // Check security_invoker setting
+            if (view.reloptions) {
+                for (const option of view.reloptions) {
+                    if (option.startsWith('security_invoker=')) {
+                        const value = option.split('=')[1];
+                        if (value === 'on' || value === 'true') {
+                            ddlStart += ' WITH (security_invoker = on)';
                         }
-                    }
-                    ddl += ddlStart + ' AS\n' + view.definition + ';\n\n';
-                    // Add COMMENT ON statement
-                    if (viewCommentResult.rows.length > 0 && viewCommentResult.rows[0].view_comment) {
-                        ddl += `COMMENT ON VIEW ${schemaName}.${name} IS '${comment}';\n\n`;
-                    }
-                    else {
-                        ddl += `-- COMMENT ON VIEW ${schemaName}.${name} IS '_your_comment_here_';\n\n`;
-                    }
-                    // Get view creation time (if available)
-                    try {
-                        const viewStatsResult = await client.query(`
-              SELECT EXTRACT(EPOCH FROM GREATEST(
-                COALESCE(pg_stat_get_last_vacuum_time(c.oid), '1970-01-01'::timestamp),
-                COALESCE(pg_stat_get_last_analyze_time(c.oid), '1970-01-01'::timestamp)
-              ))::bigint as last_updated
-              FROM pg_class c
-              JOIN pg_namespace n ON c.relnamespace = n.oid
-              WHERE c.relname = $1 AND n.nspname = $2 AND c.relkind = 'v'
-            `, [name, schemaName]);
-                        if (viewStatsResult.rows.length > 0 && viewStatsResult.rows[0].last_updated > 0) {
-                            timestamp = viewStatsResult.rows[0].last_updated;
+                        else if (value === 'off' || value === 'false') {
+                            ddlStart += ' WITH (security_invoker = off)';
                         }
-                    }
-                    catch (error) {
-                        // On error use default timestamp
+                        break;
                     }
                 }
             }
-            catch (error) {
-                // On error no comment
+            ddl += ddlStart + ' AS\n' + view.definition + ';\n\n';
+            // Add COMMENT ON statement
+            if (viewCommentResult.rows.length > 0 && viewCommentResult.rows[0].view_comment) {
+                ddl += `COMMENT ON VIEW ${schemaName}.${name} IS '${comment}';\n\n`;
+            }
+            else {
+                ddl += `-- COMMENT ON VIEW ${schemaName}.${name} IS '_your_comment_here_';\n\n`;
+            }
+            // Get view creation time (if available)
+            const viewStatsResult = await client.query(`
+        SELECT EXTRACT(EPOCH FROM GREATEST(
+          COALESCE(pg_stat_get_last_vacuum_time(c.oid), '1970-01-01'::timestamp),
+          COALESCE(pg_stat_get_last_analyze_time(c.oid), '1970-01-01'::timestamp)
+        ))::bigint as last_updated
+        FROM pg_class c
+        JOIN pg_namespace n ON c.relnamespace = n.oid
+        WHERE c.relname = $1 AND n.nspname = $2 AND c.relkind = 'v'
+      `, [name, schemaName]);
+            if (viewStatsResult.rows.length > 0 && viewStatsResult.rows[0].last_updated > 0) {
+                timestamp = viewStatsResult.rows[0].last_updated;
             }
         }
         return {
@@ -837,20 +839,18 @@ async function fetchTableDefinitions(client, spinner, progress, schemas = ['publ
                 return result;
             }
             catch (error) {
-                console.error(`Error processing ${obj.type} ${obj.tablename}:`, error);
-                return null;
+                const detail = error instanceof Error ? error.message : String(error);
+                throw new Error(`Failed to extract ${obj.schemaname}.${obj.tablename} (${obj.type}): ${detail}`);
             }
         });
         // Wait for batch to complete
         const batchResults = await Promise.all(batchPromises);
         processedResults.push(...batchResults);
     }
-    // Add to definitions excluding nulls
+    // Add to definitions
     for (const result of processedResults) {
-        if (result) {
-            const { isTable, ...definition } = result;
-            definitions.push(definition);
-        }
+        const { isTable, ...definition } = result;
+        definitions.push(definition);
     }
     return definitions;
 }
@@ -880,18 +880,19 @@ async function generateCreateTableDDL(client, tableName, schemaName = 'public')
         AND c.table_name = $2
       ORDER BY c.ordinal_position
     `, [schemaName, tableName]),
-        // Get primary key info
+        // Get primary key info directly from pg_catalog. information_schema's
+        // constraint views are substantially more expensive on large catalogs.
         client.query(`
-      SELECT column_name
-      FROM information_schema.table_constraints tc
-      JOIN information_schema.key_column_usage kcu 
-        ON tc.constraint_catalog = kcu.constraint_catalog
-        AND tc.constraint_schema = kcu.constraint_schema
-        AND tc.constraint_name = kcu.constraint_name
-      WHERE tc.table_schema = $1
-        AND tc.table_name = $2
-        AND tc.constraint_type = 'PRIMARY KEY'
-      ORDER BY kcu.ordinal_position
+      SELECT a.attname AS column_name
+      FROM pg_constraint con
+      JOIN pg_class rel ON rel.oid = con.conrelid
+      JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+      CROSS JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS keys(attnum, ord)
+      JOIN pg_attribute a ON a.attrelid = con.conrelid AND a.attnum = keys.attnum
+      WHERE con.contype = 'p'
+        AND nsp.nspname = $1
+        AND rel.relname = $2
+      ORDER BY keys.ord
     `, [schemaName, tableName]),
         // Get table comment
         client.query(`
@@ -914,21 +915,21 @@ async function generateCreateTableDDL(client, tableName, schemaName = 'public')
         AND pgn.nspname = $1
       ORDER BY c.ordinal_position
     `, [schemaName, tableName]),
-        // Get UNIQUE constraints
+        // Get UNIQUE constraints directly from pg_catalog for the same reason.
         client.query(`
-      SELECT 
-        tc.constraint_name,
-        string_agg(kcu.column_name, ', ' ORDER BY kcu.ordinal_position) as columns
-      FROM information_schema.table_constraints tc
-      JOIN information_schema.key_column_usage kcu 
-        ON tc.constraint_catalog = kcu.constraint_catalog
-        AND tc.constraint_schema = kcu.constraint_schema
-        AND tc.constraint_name = kcu.constraint_name
-      WHERE tc.table_schema = $1
-        AND tc.table_name = $2
-        AND tc.constraint_type = 'UNIQUE'
-      GROUP BY tc.constraint_name
-      ORDER BY tc.constraint_name
+      SELECT
+        con.conname AS constraint_name,
+        string_agg(a.attname, ', ' ORDER BY keys.ord) AS columns
+      FROM pg_constraint con
+      JOIN pg_class rel ON rel.oid = con.conrelid
+      JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+      CROSS JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS keys(attnum, ord)
+      JOIN pg_attribute a ON a.attrelid = con.conrelid AND a.attnum = keys.attnum
+      WHERE con.contype = 'u'
+        AND nsp.nspname = $1
+        AND rel.relname = $2
+      GROUP BY con.oid, con.conname
+      ORDER BY con.conname
     `, [schemaName, tableName]),
         // Get FOREIGN KEY constraints
         // Use pg_constraint directly to avoid the N² row explosion that occurs when
@@ -1514,6 +1515,9 @@ async function extractDefinitions(options) {
     const spinner = ora('Connecting to database...').start();
     const client = new pg_1.Client({
         connectionString: encodedConnectionString,
+        connectionTimeoutMillis: resolveConnectionTimeoutMs(),
+        query_timeout: resolveQueryTimeoutMs(),
+        statement_timeout: resolveQueryTimeoutMs(),
         ssl: {
             rejectUnauthorized: false,
             ca: undefined
@@ -1557,17 +1561,12 @@ async function extractDefinitions(options) {
             progress.tables.total = parseInt(tablesCountResult.rows[0].count);
             progress.views.total = parseInt(viewsCountResult.rows[0].count);
             // Get total RLS policy count (per table)
-            try {
-                const rlsCountResult = await client.query(`
-          SELECT COUNT(DISTINCT tablename) as count 
-          FROM pg_policies 
-          WHERE schemaname = 'public'
-        `);
-                progress.rls.total = parseInt(rlsCountResult.rows[0].count);
-            }
-            catch (error) {
-                progress.rls.total = 0;
-            }
+            const rlsCountResult = await client.query(`
+        SELECT COUNT(DISTINCT tablename) as count
+        FROM pg_policies
+        WHERE schemaname = 'public'
+      `);
+            progress.rls.total = parseInt(rlsCountResult.rows[0].count);
             // Get total functions count
             const functionsCountResult = await client.query(`
         SELECT COUNT(*) as count 
@@ -1591,6 +1590,11 @@ async function extractDefinitions(options) {
                 progress.cronJobs.total = parseInt(cronCountResult.rows[0].count);
             }
             catch (error) {
+                const code = typeof error === 'object' && error !== null && 'code' in error
+                    ? String(error.code)
+                    : undefined;
+                if (code !== '42P01')
+                    throw error;
                 progress.cronJobs.total = 0;
             }
             // Get total custom types count
@@ -1653,37 +1657,23 @@ async function extractDefinitions(options) {
         let relations = [];
         let rpcTables = [];
         let allSchemas = [];
-        try {
-            allSchemas = await fetchAllSchemas(client);
-            relations = await fetchRelationList(client, schemas);
-            const funcDefs = allDefinitions.filter(d => d.type === 'function');
-            for (const f of funcDefs) {
-                const tables = extractTableRefsFromFunctionDdl(f.ddl, f.schema ?? 'public');
-                if (tables.length > 0) {
-                    rpcTables.push({
-                        rpc: f.schema ? `${f.schema}.${f.name}` : f.name,
-                        tables
-                    });
-                }
-            }
-        }
-        catch (err) {
-            if (process.env.SUPATOOL_DEBUG) {
-                console.warn('RELATIONS/RPC_TABLES extraction skipped:', err);
+        allSchemas = await fetchAllSchemas(client);
+        relations = await fetchRelationList(client, schemas);
+        const funcDefs = allDefinitions.filter(d => d.type === 'function');
+        for (const f of funcDefs) {
+            const tables = extractTableRefsFromFunctionDdl(f.ddl, f.schema ?? 'public');
+            if (tables.length > 0) {
+                rpcTables.push({
+                    rpc: f.schema ? `${f.schema}.${f.name}` : f.name,
+                    tables
+                });
             }
         }
         // RLS status (for Tables docs, rls_warnings.md, and extract-time warning)
         let tableRlsStatus = [];
-        try {
-            const tableDefs = allDefinitions.filter(d => d.type === 'table');
-            if (tableDefs.length > 0) {
-                tableRlsStatus = await fetchTableRlsStatus(client, schemas);
-            }
-        }
-        catch (err) {
-            if (process.env.SUPATOOL_DEBUG) {
-                console.warn('RLS status fetch skipped:', err);
-            }
+        const tableDefs = allDefinitions.filter(d => d.type === 'table');
+        if (tableDefs.length > 0) {
+            tableRlsStatus = await fetchTableRlsStatus(client, schemas);
         }
         // Save definitions (table+RLS+triggers merged, schema folders)
         spinner.text = 'Saving definitions to files...';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supatool",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "description": "CLI for PostgreSQL (Cloud SQL / Supabase): extract schema to files, deploy schema diffs, apply migrations, seed export.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",