supatool 0.4.3 → 0.6.0

package/dist/sync/config.js

@@ -72,27 +72,86 @@ function loadConfig(configPath) {
  */
 function resolveConfig(options, configPath) {
     const fileConfig = loadConfig(configPath);
+    const connectionString = options.connectionString ||
+        process.env.DB_CONNECTION_STRING ||
+        process.env.SUPABASE_CONNECTION_STRING ||
+        process.env.DATABASE_URL ||
+        fileConfig.connectionString;
     return {
-        connectionString: options.connectionString ||
-            process.env.SUPABASE_CONNECTION_STRING ||
-            process.env.DATABASE_URL ||
-            fileConfig.connectionString,
-        schemaDir: options.schemaDir || fileConfig.schemaDir || './supabase/schemas',
-        tablePattern: options.tablePattern || fileConfig.tablePattern || '*'
+        connectionString,
+        schemaDir: options.schemaDir || fileConfig.schemaDir || './db/schemas',
+        tablePattern: options.tablePattern || fileConfig.tablePattern || '*',
+        migration: fileConfig.migration
     };
 }
 /**
- * Generate config file template
+ * Generate config file template (no connection string — use .env.local)
  */
 function createConfigTemplate(outputPath) {
     const template = {
-        connectionString: "postgresql://user:password@host:port/database",
-        schemaDir: "./supabase/schemas",
+        schemaDir: "./db/schemas",
         tablePattern: "*",
-        "_comment": "It is recommended to set connection string in .env or .env.local file using SUPABASE_CONNECTION_STRING or DATABASE_URL"
+        migration: {
+            naming: "timestamp",
+            "_naming_comment": "Use 'sequential' for NNN_description.sql format, 'timestamp' for YYYYMMDDHHMMSS_description.sql",
+            dir: "db/migrations"
+        },
+        "_comment": "Set credentials in .env.local — never put secrets in this file."
     };
     fs.writeFileSync(outputPath, JSON.stringify(template, null, 2), 'utf-8');
-    console.log(`Configuration template generated: ${outputPath}`);
-    console.log('⚠️  Remember to add the configuration file to .gitignore!');
-    console.log('💡 Manage connection string in .env or .env.local file');
+    console.log(`Config template generated: ${outputPath}`);
+    ensureEnvLocalTemplate();
+    checkGitignore(outputPath);
+}
+/**
+ * Write .env.local template if it doesn't exist yet.
+ */
+function ensureEnvLocalTemplate() {
+    const envLocalPath = path.join(process.cwd(), '.env.local');
+    if (fs.existsSync(envLocalPath))
+        return;
+    const template = [
+        '# supatool credentials — never commit this file',
+        '# PostgreSQL connection string (Cloud SQL, Supabase, or any PostgreSQL)',
+        'DB_CONNECTION_STRING=postgresql://user:password@host:port/database',
+        '',
+        '# Legacy aliases (still accepted for backward compatibility)',
+        '# SUPABASE_CONNECTION_STRING=postgresql://user:password@host:port/database',
+        '# DATABASE_URL=postgresql://user:password@host:port/database',
+    ].join('\n') + '\n';
+    fs.writeFileSync(envLocalPath, template, 'utf-8');
+    console.log('.env.local template created — fill in your credentials.');
+}
+/**
+ * Warn if the config file or .env.local are not covered by .gitignore.
+ */
+function checkGitignore(configPath) {
+    const gitignorePath = path.join(process.cwd(), '.gitignore');
+    if (!fs.existsSync(gitignorePath)) {
+        console.warn('Warning: .gitignore not found. Make sure to exclude .env.local and supatool.config.json.');
+        return;
+    }
+    const content = fs.readFileSync(gitignorePath, 'utf-8');
+    const lines = content.split('\n').map(l => l.trim());
+    const missing = [];
+    const configFile = path.basename(configPath);
+    if (!lines.some(l => l === configFile || l === `/${configFile}`)) {
+        missing.push(configFile);
+    }
+    if (!lines.some(l => l === '.env.local' || l === '*.local')) {
+        missing.push('.env.local');
+    }
+    if (missing.length > 0) {
+        console.warn(`\nWarning: The following are NOT in .gitignore — add them to avoid committing secrets:`);
+        for (const f of missing) {
+            console.warn(`  ${f}`);
+        }
+        // Auto-append to .gitignore
+        const toAdd = missing.map(f => f).join('\n') + '\n';
+        fs.appendFileSync(gitignorePath, '\n# supatool\n' + toAdd);
+        console.log(`Auto-added to .gitignore: ${missing.join(', ')}`);
+    }
+    else {
+        console.log('.gitignore OK — credentials files are excluded.');
+    }
 }

package/dist/sync/definitionExtractor.js

@@ -1344,7 +1344,9 @@ async function generateIndexFile(definitions, outputDir, separateDirectories = t
  * Classify and output definitions
  */
 async function extractDefinitions(options) {
-    const { connectionString, outputDir, separateDirectories = true, tablesOnly = false, viewsOnly = false, all = false, tablePattern = '*', force = false, schemas = ['public'], version } = options;
+    const { connectionString, outputDir, separateDirectories = true, tablesOnly = false, viewsOnly = false, all = false, tablePattern = '*', force = false, schemas: schemasOption = ['public'], excludeSchemas = [], allSchemas: useAllSchemas = false, version } = options;
+    // schemas will be resolved after DB connect when useAllSchemas is true
+    let schemas = schemasOption;
     // Disable Node.js SSL certificate verification
     process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
     // Connection string validation
@@ -1463,6 +1465,17 @@ async function extractDefinitions(options) {
         console.log(`   Connection string length: ${encodedConnectionString.length}`);
         await client.connect();
         spinner.text = 'Connected to database';
+        // Resolve schemas: when --all-schemas, fetch all from DB and subtract excludeSchemas
+        if (useAllSchemas) {
+            const SYSTEM_SCHEMAS = ['information_schema', 'pg_catalog', 'pg_toast', 'pg_temp_1', 'pg_toast_temp_1'];
+            const discovered = await fetchAllSchemas(client);
+            schemas = discovered.filter(s => !SYSTEM_SCHEMAS.includes(s) && !excludeSchemas.includes(s));
+            console.log(`Schemas (all minus excluded): ${schemas.join(', ')}`);
+        }
+        else if (excludeSchemas.length > 0) {
+            schemas = schemas.filter(s => !excludeSchemas.includes(s));
+            console.log(`Schemas (filtered): ${schemas.join(', ')}`);
+        }
         let allDefinitions = [];
         // Initialize progress tracker
         const progress = {

package/dist/sync/fetchRemoteSchemas.js

@@ -56,8 +56,10 @@ async function fetchRemoteSchemas(connectionString, targetTableNames) {
     // console.log('Connecting to database...');
     try {
         // Basic connection string check
-        if (!connectionString || !connectionString.startsWith('postgresql://')) {
-            throw new Error('Invalid connection string. Please specify a valid postgresql:// format.');
+        if (!connectionString ||
+            (!connectionString.startsWith('postgresql://') &&
+                !connectionString.startsWith('postgres://'))) {
+            throw new Error('Invalid connection string. Please specify a valid postgresql:// or postgres:// format.');
         }
         // Parse URL and display connection info
         const url = new URL(connectionString);

package/dist/sync/generateMigration.js

@@ -34,9 +34,36 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateMigrationFile = generateMigrationFile;
+exports.generateRenameTableMigrationFile = generateRenameTableMigrationFile;
+exports.generateFunctionMigrationFile = generateFunctionMigrationFile;
+exports.generateRlsMigrationFile = generateRlsMigrationFile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const diff_1 = require("diff");
+/**
+ * Resolve migration filename based on naming config
+ */
+function resolveMigrationFilename(migrationDir, description, naming = 'timestamp') {
+    if (naming === 'sequential') {
+        // Find max NNN from existing files
+        let max = 0;
+        if (fs.existsSync(migrationDir)) {
+            for (const f of fs.readdirSync(migrationDir)) {
+                const m = f.match(/^(\d+)_/);
+                if (m)
+                    max = Math.max(max, parseInt(m[1], 10));
+            }
+        }
+        const next = String(max + 1).padStart(3, '0');
+        return `${next}_${description}.sql`;
+    }
+    // Default: timestamp
+    const ts = new Date().toISOString()
+        .replace(/[-:]/g, '')
+        .replace(/\..+/, '')
+        .replace('T', '');
+    return `${ts}_${description}.sql`;
+}
 /**
  * Generate ALTER TABLE statements from DDL diff
  */
@@ -112,8 +139,8 @@ function generateAlterStatements(tableName, fromDdl, toDdl) {
 /**
  * Generate migration file
  */
-async function generateMigrationFile(tableName, fromDdl, toDdl, projectDir = '.') {
-    const migrationDir = path.join(projectDir, 'supabase', 'migrations');
+async function generateMigrationFile(tableName, fromDdl, toDdl, projectDir = '.', migrationConfig) {
+    const migrationDir = path.join(projectDir, migrationConfig?.dir ?? 'db/migrations');
     // Create migrations directory
     if (!fs.existsSync(migrationDir)) {
         fs.mkdirSync(migrationDir, { recursive: true });
@@ -121,20 +148,14 @@ async function generateMigrationFile(tableName, fromDdl, toDdl, projectDir = '.'
     // Generate ALTER TABLE statements
     const alterStatements = generateAlterStatements(tableName, fromDdl, toDdl);
     if (alterStatements.length === 0) {
-        return await generateManualMigrationTemplate(tableName, fromDdl, toDdl, projectDir);
+        return await generateManualMigrationTemplate(tableName, fromDdl, toDdl, projectDir, migrationConfig);
     }
-    // Generate filename from timestamp
-    const now = new Date();
-    const timestamp = now.toISOString()
-        .replace(/[-:]/g, '')
-        .replace(/\..+/, '')
-        .replace('T', '');
-    const filename = `${timestamp}_update_${tableName}.sql`;
+    const filename = resolveMigrationFilename(migrationDir, `update_${tableName}`, migrationConfig?.naming);
     const filepath = path.join(migrationDir, filename);
     // Build migration file content
     const content = `-- Migration generated by supatool
 -- Table: ${tableName}
--- Generated at: ${now.toISOString()}
+-- Generated at: ${new Date().toISOString()}
 
 ${alterStatements.join('\n')}
 `;
@@ -187,20 +208,14 @@ function analyzeDiffForTemplate(fromDdl, toDdl) {
 /**
  * Generate manual migration template
  */
-async function generateManualMigrationTemplate(tableName, fromDdl, toDdl, projectDir) {
-    const migrationDir = path.join(projectDir, 'supabase', 'migrations');
+async function generateManualMigrationTemplate(tableName, fromDdl, toDdl, projectDir, migrationConfig) {
+    const migrationDir = path.join(projectDir, migrationConfig?.dir ?? 'db/migrations');
     if (!fs.existsSync(migrationDir)) {
         fs.mkdirSync(migrationDir, { recursive: true });
     }
     // Analyze diff
     const { removedColumns, addedColumns } = analyzeDiffForTemplate(fromDdl, toDdl);
-    // Generate filename from timestamp
-    const now = new Date();
-    const timestamp = now.toISOString()
-        .replace(/[-:]/g, '')
-        .replace(/\..+/, '')
-        .replace('T', '');
-    const filename = `${timestamp}_manual_update_${tableName}.sql`;
+    const filename = resolveMigrationFilename(migrationDir, `manual_update_${tableName}`, migrationConfig?.naming);
     const filepath = path.join(migrationDir, filename);
     // Build template from actual changes
     let migrationStatements = [];
@@ -263,14 +278,100 @@ ${migrationStatements.join('\n')}
     return filepath;
 }
 /**
- * Advanced diff analysis (detect column changes)
+ * Generate a RENAME TABLE migration when a table appears renamed.
+ * (old exists on remote, new exists on local, columns are highly similar)
+ */
+async function generateRenameTableMigrationFile(schema, oldName, newName, projectDir = '.', migrationConfig) {
+    const migrationDir = path.join(projectDir, migrationConfig?.dir ?? 'db/migrations');
+    if (!fs.existsSync(migrationDir)) {
+        fs.mkdirSync(migrationDir, { recursive: true });
+    }
+    const filename = resolveMigrationFilename(migrationDir, `rename_${schema}_${oldName}_to_${newName}`, migrationConfig?.naming);
+    const filepath = path.join(migrationDir, filename);
+    const content = `-- Migration generated by supatool
+-- Rename table: ${schema}.${oldName} → ${schema}.${newName}
+-- Generated at: ${new Date().toISOString()}
+-- WARNING: Review carefully before applying. supatool detected this as a rename
+--          based on column similarity, but it may be an unrelated add/drop pair.
+
+ALTER TABLE ${schema === 'public' ? '' : schema + '.'}${oldName} RENAME TO ${newName};
+`;
+    fs.writeFileSync(filepath, content, 'utf-8');
+    console.log(`Rename migration generated: ${filename}`);
+    return filepath;
+}
+/**
+ * Normalize function DDL for comparison (strip supatool header comment, trailing whitespace)
  */
-function analyzeColumnChanges(tableName, localDdl, remoteDdl) {
+function normalizeFunctionDdl(ddl) {
+    return ddl
+        .split('\n')
+        .filter(line => !line.startsWith('-- Generated by supatool'))
+        .join('\n')
+        .replace(/\s+$/, '')
+        .trim();
+}
+/**
+ * Generate a migration file for a changed function.
+ * localDdl is used as-is (must be valid CREATE OR REPLACE FUNCTION DDL).
+ */
+async function generateFunctionMigrationFile(schema, funcName, localDdl, remoteDdl, projectDir = '.', migrationConfig) {
+    const normalizedLocal = normalizeFunctionDdl(localDdl);
+    const normalizedRemote = normalizeFunctionDdl(remoteDdl);
+    if (normalizedLocal === normalizedRemote)
+        return null;
+    const migrationDir = path.join(projectDir, migrationConfig?.dir ?? 'db/migrations');
+    if (!fs.existsSync(migrationDir)) {
+        fs.mkdirSync(migrationDir, { recursive: true });
+    }
+    const filename = resolveMigrationFilename(migrationDir, `update_fn_${schema}_${funcName}`, migrationConfig?.naming);
+    const filepath = path.join(migrationDir, filename);
+    const content = `-- Migration generated by supatool
+-- Function: ${schema}.${funcName}
+-- Generated at: ${new Date().toISOString()}
+
+${normalizedLocal.endsWith(';') ? normalizedLocal : normalizedLocal + ';'}
+`;
+    fs.writeFileSync(filepath, content, 'utf-8');
+    console.log(`Function migration generated: ${filename}`);
+    return filepath;
+}
+/**
+ * Generate DROP POLICY IF EXISTS + CREATE POLICY statements for changed policies.
+ */
+async function generateRlsMigrationFile(changedPolicies, droppedPolicies, projectDir = '.', migrationConfig) {
+    if (changedPolicies.length === 0 && droppedPolicies.length === 0)
+        return null;
+    const migrationDir = path.join(projectDir, migrationConfig?.dir ?? 'db/migrations');
+    if (!fs.existsSync(migrationDir)) {
+        fs.mkdirSync(migrationDir, { recursive: true });
+    }
     const statements = [];
-    // Simple case: detect column name change
-    const localLines = localDdl.split('\n').map(line => line.trim()).filter(line => line);
-    const remoteLines = remoteDdl.split('\n').map(line => line.trim()).filter(line => line);
-    // Advanced detection (type change, default change) to be implemented later
-    // Currently only basic add/remove
-    return statements;
+    for (const p of droppedPolicies) {
+        statements.push(`DROP POLICY IF EXISTS "${p.policyName}" ON ${p.tableName};`);
+    }
+    for (const p of changedPolicies) {
+        statements.push(`DROP POLICY IF EXISTS "${p.policyName}" ON ${p.tableName};`);
+        const permissive = p.permissive ? 'PERMISSIVE' : 'RESTRICTIVE';
+        const roles = p.roles || 'public';
+        let sql = `CREATE POLICY "${p.policyName}" ON ${p.tableName}\n` +
+            `  AS ${permissive} FOR ${p.cmd} TO ${roles}`;
+        if (p.qual)
+            sql += `\n  USING (${p.qual})`;
+        if (p.withCheck)
+            sql += `\n  WITH CHECK (${p.withCheck})`;
+        sql += ';';
+        statements.push(sql);
+    }
+    const filename = resolveMigrationFilename(migrationDir, 'update_rls', migrationConfig?.naming);
+    const filepath = path.join(migrationDir, filename);
+    const content = `-- Migration generated by supatool
+-- RLS policies: ${changedPolicies.length} changed, ${droppedPolicies.length} dropped
+-- Generated at: ${new Date().toISOString()}
+
+${statements.join('\n\n')}
+`;
+    fs.writeFileSync(filepath, content, 'utf-8');
+    console.log(`RLS migration generated: ${filename}`);
+    return filepath;
 }

package/dist/sync/migrateRemote.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateRemote = migrateRemote;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const pg_1 = require("pg");
+const MIGRATIONS_TABLE = '_supatool_migrations';
+/**
+ * Apply pending SQL migration files to remote DB.
+ *
+ * Tracks applied migrations in _supatool_migrations table.
+ * Files are applied in alphabetical order (timestamp or sequential naming).
+ */
+async function migrateRemote(options) {
+    const { connectionString, migrationsDir, dryRun = false } = options;
+    // Collect .sql files
+    if (!fs.existsSync(migrationsDir)) {
+        console.error(`❌ Migrations directory not found: ${migrationsDir}`);
+        process.exit(1);
+    }
+    const allFiles = fs.readdirSync(migrationsDir)
+        .filter(f => f.endsWith('.sql'))
+        .sort();
+    if (allFiles.length === 0) {
+        console.log('No migration files found.');
+        return;
+    }
+    const client = new pg_1.Client({
+        connectionString,
+        ssl: { rejectUnauthorized: false }
+    });
+    try {
+        await client.connect();
+        // Ensure tracking table exists
+        await client.query(`
+      CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
+        id         SERIAL PRIMARY KEY,
+        filename   TEXT NOT NULL UNIQUE,
+        applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
+      )
+    `);
+        // Get already-applied migrations
+        const applied = await client.query(`SELECT filename FROM ${MIGRATIONS_TABLE} ORDER BY filename`);
+        const appliedSet = new Set(applied.rows.map(r => r.filename));
+        const pending = allFiles.filter(f => !appliedSet.has(f));
+        if (pending.length === 0) {
+            console.log('✅ All migrations already applied.');
+            return;
+        }
+        console.log(`Pending migrations: ${pending.length}`);
+        for (const f of pending) {
+            console.log(`  • ${f}`);
+        }
+        if (dryRun) {
+            console.log('\n(dry-run) No changes applied.');
+            return;
+        }
+        // Apply each pending migration in a transaction
+        for (const filename of pending) {
+            const filepath = path.join(migrationsDir, filename);
+            const sql = fs.readFileSync(filepath, 'utf-8');
+            process.stdout.write(`Applying ${filename}... `);
+            await client.query('BEGIN');
+            try {
+                await client.query(sql);
+                await client.query(`INSERT INTO ${MIGRATIONS_TABLE} (filename) VALUES ($1)`, [filename]);
+                await client.query('COMMIT');
+                console.log('✅');
+            }
+            catch (err) {
+                await client.query('ROLLBACK');
+                console.log('❌');
+                throw err;
+            }
+        }
+        console.log(`\n✅ Applied ${pending.length} migration(s).`);
+    }
+    finally {
+        await client.end();
+    }
+}

package/dist/sync/seedGenerator.js

@@ -56,6 +56,7 @@ function parseTablesYaml(yamlPath) {
  * @param options SeedGenOptions
  */
 async function generateSeedsFromRemote(options) {
+    process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
     const tables = parseTablesYaml(options.tablesYamlPath);
     // Generate datetime subdir name (e.g. 20250705_1116_supatool)
     const now = new Date();
@@ -67,7 +68,10 @@ async function generateSeedsFromRemote(options) {
     const folderName = `${y}${m}${d}_${hh}${mm}_supatool`;
     const outDir = path_1.default.join(options.outputDir, folderName);
     // DB connection
-    const client = new pg_1.Client({ connectionString: options.connectionString });
+    const client = new pg_1.Client({
+        connectionString: options.connectionString,
+        ssl: { rejectUnauthorized: false }
+    });
     await client.connect();
     const processedFiles = [];
     for (const { schema, table } of tables) {
@@ -77,8 +81,15 @@ async function generateSeedsFromRemote(options) {
             fs_1.default.mkdirSync(schemaDir, { recursive: true });
         }
         // Fetch data
-        const res = await client.query(`SELECT * FROM "${schema}"."${table}"`);
-        const rows = res.rows;
+        let rows;
+        try {
+            const res = await client.query(`SELECT * FROM "${schema}"."${table}"`);
+            rows = res.rows;
+        }
+        catch (err) {
+            console.warn(`⚠️  Skip: ${schema}.${table} — ${err.message}`);
+            continue;
+        }
         // Output JSON
         const fileName = `${table}_seed.json`;
         const filePath = path_1.default.join(schemaDir, fileName);
@@ -118,7 +129,7 @@ async function generateSeedsFromRemote(options) {
 }
 /** Utility to get table comment */
 async function getTableComment(connectionString, schema, table) {
-    const client = new pg_1.Client({ connectionString });
+    const client = new pg_1.Client({ connectionString, ssl: { rejectUnauthorized: false } });
     await client.connect();
     try {
         const res = await client.query(`SELECT obj_description(c.oid) as 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'`, [table, schema]);