supatool 0.6.1 → 0.6.3

package/dist/bin/helptext.js

@@ -25,6 +25,7 @@ Common Options:
   -c, --connection <string>    Connection string (postgresql:// or postgres://)
   -o, --output-dir <path>      Output directory
   --schema <schemas>           Target schemas (comma-separated, default: public)
+  --schema-only                Regenerate only the specified schema files; skip index files
   --config <path>              Configuration file path
   -f, --force                  Force overwrite
 

package/dist/bin/supatool.js

@@ -77,6 +77,7 @@ program
     .option('--schema <schemas>', 'Target schemas, comma-separated (default: public)')
     .option('--all-schemas', 'Target all schemas in the DB (use with -e to exclude some)')
     .option('-e, --exclude-schema <schemas>', 'Schemas to exclude, comma-separated. Without --schema, targets all schemas automatically.')
+    .option('--schema-only', 'Regenerate only the specified schema files; do not touch other schemas or index files (llms.txt, schema_index.json, etc.)')
     .option('--config <path>', 'Configuration file path')
     .option('-f, --force', 'Force overwrite without confirmation')
     .action(async (options) => {
@@ -86,6 +87,18 @@ program
     if (!config.connectionString)
         connectionRequiredError();
     try {
+        if (options.schemaOnly && !options.schema) {
+            console.error('⚠️  --schema-only requires --schema to be specified.');
+            process.exit(1);
+        }
+        if (options.schemaOnly && options.all) {
+            console.error('⚠️  --schema-only cannot be combined with --all. Use --schema-only without --all to regenerate only the specified schema files.');
+            process.exit(1);
+        }
+        if (options.schemaOnly && options.allSchemas) {
+            console.error('⚠️  --schema-only cannot be combined with --all-schemas.');
+            process.exit(1);
+        }
         let schemas = ['public'];
         if (options.schema) {
             schemas = options.schema.split(',').map((s) => s.trim());
@@ -106,6 +119,7 @@ program
             allSchemas: options.allSchemas || false,
             excludeSchemas,
             schemasExplicit: !!options.schema,
+            schemaOnly: options.schemaOnly || false,
             version: package_json_1.version
         });
     }

package/dist/sync/definitionExtractor.js

@@ -257,12 +257,11 @@ async function fetchRelationList(client, schemas = ['public']) {
  */
 async function fetchAllSchemas(client) {
     const result = await client.query(`
-    SELECT schema_name
-    FROM information_schema.schemata
-    WHERE schema_name NOT LIKE 'pg_%'
-      AND schema_name != 'information_schema'
-      AND schema_name != 'pg_catalog'
-    ORDER BY schema_name
+    SELECT nspname AS schema_name
+    FROM pg_catalog.pg_namespace
+    WHERE nspname NOT LIKE 'pg_%'
+      AND nspname != 'information_schema'
+    ORDER BY nspname
   `);
     return result.rows.map((r) => r.schema_name);
 }
@@ -928,23 +927,30 @@ async function generateCreateTableDDL(client, tableName, schemaName = 'public')
       ORDER BY tc.constraint_name
     `, [schemaName, tableName]),
         // Get FOREIGN KEY constraints
+        // Use pg_constraint directly to avoid the N² row explosion that occurs when
+        // joining kcu × ccu on constraint_name alone for composite FKs.
         client.query(`
-      SELECT 
-        tc.constraint_name,
-        string_agg(kcu.column_name, ', ' ORDER BY kcu.ordinal_position) as columns,
-        ccu.table_schema AS foreign_table_schema,
-        ccu.table_name AS foreign_table_name,
-        string_agg(ccu.column_name, ', ' ORDER BY kcu.ordinal_position) as foreign_columns
-      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
-      JOIN information_schema.constraint_column_usage ccu 
-        ON tc.constraint_name = ccu.constraint_name AND tc.table_schema = ccu.table_schema
-      WHERE tc.table_schema = $1
-        AND tc.table_name = $2
-        AND tc.constraint_type = 'FOREIGN KEY'
-      GROUP BY tc.constraint_name, ccu.table_schema, ccu.table_name
-      ORDER BY tc.constraint_name
+      SELECT
+        c.conname AS constraint_name,
+        (SELECT string_agg(a.attname, ', ' ORDER BY u.ord)
+         FROM unnest(c.conkey) WITH ORDINALITY AS u(attnum, ord)
+         JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = u.attnum
+        ) AS columns,
+        fn.nspname AS foreign_table_schema,
+        fc.relname AS foreign_table_name,
+        (SELECT string_agg(a.attname, ', ' ORDER BY u.ord)
+         FROM unnest(c.confkey) WITH ORDINALITY AS u(attnum, ord)
+         JOIN pg_attribute a ON a.attrelid = c.confrelid AND a.attnum = u.attnum
+        ) AS foreign_columns
+      FROM pg_constraint c
+      JOIN pg_class rel ON rel.oid = c.conrelid
+      JOIN pg_namespace nsp ON nsp.oid = rel.relnamespace
+      JOIN pg_class fc ON fc.oid = c.confrelid
+      JOIN pg_namespace fn ON fn.oid = fc.relnamespace
+      WHERE c.contype = 'f'
+        AND nsp.nspname = $1
+        AND rel.relname = $2
+      ORDER BY c.conname
     `, [schemaName, tableName])
     ]);
     const columnComments = new Map();
@@ -1039,7 +1045,7 @@ async function generateCreateTableDDL(client, tableName, schemaName = 'public')
 /**
  * Save definitions to files (merge RLS/triggers into table/view; schema folders when multi-schema)
  */
-async function saveDefinitionsByType(definitions, outputDir, separateDirectories = true, schemas = ['public'], relations = [], rpcTables = [], allSchemas = [], version, tableRlsStatus = [], force = false) {
+async function saveDefinitionsByType(definitions, outputDir, separateDirectories = true, schemas = ['public'], relations = [], rpcTables = [], allSchemas = [], version, tableRlsStatus = [], force = false, schemaOnly = false) {
     const fs = await Promise.resolve().then(() => __importStar(require('fs')));
     const path = await Promise.resolve().then(() => __importStar(require('path')));
     const outputDate = new Date().toLocaleDateString('en-CA', { year: 'numeric', month: '2-digit', day: '2-digit' });
@@ -1116,7 +1122,10 @@ async function saveDefinitionsByType(definitions, outputDir, separateDirectories
         ...cronJobs,
         ...customTypes
     ];
-    const multiSchema = schemas.length > 1;
+    // schemaOnly always uses schema subdirectories (outputDir/<schema>/type/)
+    // so that single-schema --schema-only runs write to the correct location
+    // and don't interfere with other schemas already on disk.
+    const multiSchema = schemas.length > 1 || schemaOnly;
     const typeDirNames = {
         table: 'tables',
         view: 'views',
@@ -1153,7 +1162,8 @@ async function saveDefinitionsByType(definitions, outputDir, separateDirectories
         }
         await fsPromises.writeFile(filePath, newContent);
     }
-    // When force: delete SQL files that no longer correspond to any extracted object
+    // When force: delete SQL files that no longer correspond to any extracted object.
+    // With schemaOnly: restrict deletion to the target schema directories only.
     if (force && fs.existsSync(outputDir)) {
         const deleteStaleSqlFiles = (dir) => {
             for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
@@ -1166,10 +1176,41 @@ async function saveDefinitionsByType(definitions, outputDir, separateDirectories
                 }
             }
         };
-        deleteStaleSqlFiles(outputDir);
+        if (schemaOnly) {
+            // Only scan within the target schema directories
+            for (const schemaName of schemas) {
+                const schemaDir = path.join(outputDir, schemaName);
+                if (fs.existsSync(schemaDir)) {
+                    deleteStaleSqlFiles(schemaDir);
+                }
+            }
+        }
+        else {
+            deleteStaleSqlFiles(outputDir);
+        }
+    }
+    // When schemaOnly: skip index file regeneration to avoid overwriting
+    // shared index files (llms.txt, schema_index.json, etc.) with partial data.
+    if (schemaOnly) {
+        return;
     }
     await generateIndexFile(toWrite, outputDir, separateDirectories, multiSchema, relations, rpcTables, allSchemas, schemas, version, tableRlsStatus);
 }
+/**
+ * Write a file only when content has changed, to avoid unnecessary Git diffs.
+ * When skipFirstLine is true, the first line (typically a date-bearing header) is
+ * excluded from the comparison so that daily date changes don't trigger writes.
+ */
+function writeFileIfChanged(filePath, newContent, skipFirstLine = false) {
+    const fs = require('fs');
+    if (fs.existsSync(filePath)) {
+        const existing = fs.readFileSync(filePath, 'utf8');
+        const strip = (c) => skipFirstLine ? c.split('\n').slice(1).join('\n') : c;
+        if (strip(existing) === strip(newContent))
+            return;
+    }
+    fs.writeFileSync(filePath, newContent, 'utf8');
+}
 /**
  * Generate index file for DB objects (RLS/triggers already merged into table/view)
  */
@@ -1291,8 +1332,8 @@ async function generateIndexFile(definitions, outputDir, separateDirectories = t
     }
     const readmePath = path.join(outputDir, 'README.md');
     const llmsPath = path.join(outputDir, 'llms.txt');
-    fs.writeFileSync(readmePath, readmeContent);
-    fs.writeFileSync(llmsPath, llmsContent);
+    writeFileIfChanged(readmePath, readmeContent, true);
+    writeFileIfChanged(llmsPath, llmsContent, true);
     // schema_index.json (same data for agents that parse JSON)
     const schemaIndex = {
         objects: definitions.map(def => {
@@ -1319,7 +1360,7 @@ async function generateIndexFile(definitions, outputDir, separateDirectories = t
             }
             : undefined
     };
-    fs.writeFileSync(path.join(outputDir, 'schema_index.json'), JSON.stringify(schemaIndex, null, 2), 'utf8');
+    writeFileIfChanged(path.join(outputDir, 'schema_index.json'), JSON.stringify(schemaIndex, null, 2) + '\n');
     // schema_summary.md (one-file overview for AI) — include RLS status per table
     let summaryMd = '# Schema summary\n\n';
     const tableDefs = definitions.filter(d => d.type === 'table' || d.type === 'view');
@@ -1352,7 +1393,7 @@ async function generateIndexFile(definitions, outputDir, separateDirectories = t
         summaryMd += `- Extracted: ${allSchemas.filter(s => extractedSet.has(s)).join(', ') || '(none)'}\n`;
         summaryMd += `- Not extracted: ${allSchemas.filter(s => !extractedSet.has(s)).join(', ') || '(none)'}\n`;
     }
-    fs.writeFileSync(path.join(outputDir, 'schema_summary.md'), summaryMd, 'utf8');
+    writeFileIfChanged(path.join(outputDir, 'schema_summary.md'), summaryMd);
     // RLS disabled tables warning doc (tables only; RLS enabled with 0 policies is not warned)
     const rlsNotEnabled = tableRlsStatus.filter(s => !s.rlsEnabled);
     if (rlsNotEnabled.length > 0) {
@@ -1363,14 +1404,14 @@ async function generateIndexFile(definitions, outputDir, separateDirectories = t
         rlsNotEnabled.forEach(s => {
             warnMd += `| ${s.schema} | ${s.table} |\n`;
         });
-        fs.writeFileSync(path.join(outputDir, 'rls_warnings.md'), warnMd, 'utf8');
+        writeFileIfChanged(path.join(outputDir, 'rls_warnings.md'), warnMd);
     }
 }
 /**
  * Classify and output definitions
  */
 async function extractDefinitions(options) {
-    const { connectionString, outputDir, separateDirectories = true, tablesOnly = false, viewsOnly = false, all = false, tablePattern = '*', force = false, schemas: schemasOption = ['public'], excludeSchemas = [], allSchemas: useAllSchemas = false, schemasExplicit = false, version } = options;
+    const { connectionString, outputDir, separateDirectories = true, tablesOnly = false, viewsOnly = false, all = false, tablePattern = '*', force = false, schemas: schemasOption = ['public'], excludeSchemas = [], allSchemas: useAllSchemas = false, schemasExplicit = false, schemaOnly = false, version } = options;
     // schemas will be resolved after DB connect when useAllSchemas is true
     let schemas = schemasOption;
     // Disable Node.js SSL certificate verification
@@ -1390,18 +1431,13 @@ async function extractDefinitions(options) {
     }
     // URL encode password part
     let encodedConnectionString = connectionString;
-    console.log('🔍 Original connection string:', connectionString);
     try {
         // Special handling when password contains @
         if (connectionString.includes('@') && connectionString.split('@').length > 2) {
-            console.log('⚠️ Password contains @, executing special handling');
             // Use last @ as delimiter
             const parts = connectionString.split('@');
             const lastPart = parts.pop(); // Last part (host:port/database)
             const firstParts = parts.join('@'); // First part (postgresql://user:password)
-            console.log('   Split result:');
-            console.log('   First part:', firstParts);
-            console.log('   Last part:', lastPart);
             // Encode password part
             const colonIndex = firstParts.lastIndexOf(':');
             if (colonIndex > 0) {
@@ -1409,50 +1445,40 @@ async function extractDefinitions(options) {
                 const password = firstParts.substring(colonIndex + 1);
                 const encodedPassword = encodeURIComponent(password);
                 encodedConnectionString = `${protocolAndUser}:${encodedPassword}@${lastPart}`;
-                console.log('   Encode result:');
-                console.log('   Protocol+User:', protocolAndUser);
-                console.log('   Original password:', password);
-                console.log('   Encoded password:', encodedPassword);
-                console.log('   Final connection string:', encodedConnectionString);
             }
         }
         else {
-            console.log('✅ Executing normal URL parsing');
             // Normal URL parsing
             const url = new URL(connectionString);
-            // Handle username containing dots
-            if (url.username && url.username.includes('.')) {
-                console.log(`Username (with dots): ${url.username}`);
-            }
             if (url.password) {
                 // Encode only password part
                 const encodedPassword = encodeURIComponent(url.password);
                 url.password = encodedPassword;
                 encodedConnectionString = url.toString();
-                console.log('   Password encoded:', encodedPassword);
             }
         }
         // Add SSL settings for Supabase connection
         if (!encodedConnectionString.includes('sslmode=')) {
             const separator = encodedConnectionString.includes('?') ? '&' : '?';
             encodedConnectionString += `${separator}sslmode=require`;
-            console.log('   SSL setting added:', encodedConnectionString);
         }
-        // Display debug info (password hidden)
-        const debugUrl = new URL(encodedConnectionString);
-        const maskedPassword = debugUrl.password ? '*'.repeat(debugUrl.password.length) : '';
-        debugUrl.password = maskedPassword;
-        console.log('🔍 Connection info:');
-        console.log(`   Host: ${debugUrl.hostname}`);
-        console.log(`   Port: ${debugUrl.port}`);
-        console.log(`   Database: ${debugUrl.pathname.slice(1)}`);
-        console.log(`   User: ${debugUrl.username}`);
-        console.log(`   SSL: ${debugUrl.searchParams.get('sslmode') || 'require'}`);
+        // Debug-only: connection info (no credentials)
+        if (process.env.SUPATOOL_DEBUG) {
+            const debugUrl = new URL(encodedConnectionString);
+            console.log('🔍 Connection info:');
+            console.log(`   Host: ${debugUrl.hostname}`);
+            console.log(`   Port: ${debugUrl.port}`);
+            console.log(`   Database: ${debugUrl.pathname.slice(1)}`);
+            console.log(`   User: ${debugUrl.username}`);
+            console.log(`   SSL: ${debugUrl.searchParams.get('sslmode') || 'require'}`);
+        }
     }
     catch (error) {
         // Use original string if URL parsing fails
-        console.warn('Failed to parse connection string URL. May contain special characters.');
-        console.warn('Error details:', error instanceof Error ? error.message : String(error));
+        if (process.env.SUPATOOL_DEBUG) {
+            console.warn('Failed to parse connection string URL. May contain special characters.');
+            console.warn('Error details:', error instanceof Error ? error.message : String(error));
+        }
     }
     const fs = await Promise.resolve().then(() => __importStar(require('fs')));
     const readline = await Promise.resolve().then(() => __importStar(require('readline')));
@@ -1485,10 +1511,6 @@ async function extractDefinitions(options) {
         }
     });
     try {
-        // Debug before connect
-        console.log('🔧 Connection settings:');
-        console.log(`   SSL: rejectUnauthorized=false`);
-        console.log(`   Connection string length: ${encodedConnectionString.length}`);
         await client.connect();
         spinner.text = 'Connected to database';
         // Resolve schemas: --all-schemas or -e alone (without explicit --schema) → fetch all from DB and subtract excludeSchemas
@@ -1653,7 +1675,7 @@ async function extractDefinitions(options) {
         }
         // Save definitions (table+RLS+triggers merged, schema folders)
         spinner.text = 'Saving definitions to files...';
-        await saveDefinitionsByType(allDefinitions, outputDir, separateDirectories, schemas, relations, rpcTables, allSchemas, version, tableRlsStatus, force);
+        await saveDefinitionsByType(allDefinitions, outputDir, separateDirectories, schemas, relations, rpcTables, allSchemas, version, tableRlsStatus, force, schemaOnly);
         // Warn at extract time when any table has RLS disabled
         const rlsNotEnabled = tableRlsStatus.filter(s => !s.rlsEnabled);
         if (rlsNotEnabled.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supatool",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "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",