smoonb 0.0.11 → 0.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoonb",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "Complete Supabase backup and migration tool - EXPERIMENTAL VERSION - USE AT YOUR OWN RISK",
   "main": "index.js",
   "bin": {

package/src/commands/backup.js

@@ -1,10 +1,10 @@
 const chalk = require('chalk');
 const path = require('path');
+const fs = require('fs');
 const { ensureBin, runCommand } = require('../utils/cli');
 const { ensureDir, writeJson, copyDir } = require('../utils/fsx');
 const { sha256 } = require('../utils/hash');
 const { readConfig, validateFor } = require('../utils/config');
-const { IntrospectionService } = require('../services/introspect');
 const { showBetaBanner } = require('../utils/banner');
 
 // Exportar FUNÇÃO em vez de objeto Command
@@ -12,13 +12,12 @@ module.exports = async (options) => {
   showBetaBanner();
   
   try {
-    // Verificar se Supabase CLI está disponível
-    const supabasePath = await ensureBin('supabase');
-    if (!supabasePath) {
-      console.error(chalk.red('❌ Supabase CLI não encontrado'));
-      console.log(chalk.yellow('💡 Instale o Supabase CLI:'));
-      console.log(chalk.yellow('  npm install -g supabase'));
-      console.log(chalk.yellow('  ou visite: https://supabase.com/docs/guides/cli'));
+    // Verificar se pg_dump está disponível
+    const pgDumpPath = await findPgDumpPath();
+    if (!pgDumpPath) {
+      console.error(chalk.red('❌ pg_dump não encontrado'));
+      console.log(chalk.yellow('💡 Instale PostgreSQL:'));
+      console.log(chalk.yellow('  https://www.postgresql.org/download/'));
       process.exit(1);
     }
 
@@ -43,24 +42,40 @@ module.exports = async (options) => {
 
     console.log(chalk.blue(`🚀 Iniciando backup do projeto: ${config.supabase.projectId}`));
     console.log(chalk.blue(`📁 Diretório: ${backupDir}`));
+    console.log(chalk.gray(`🔧 Usando pg_dump: ${pgDumpPath}`));
 
-    // 1. Backup da Database usando Supabase CLI
-    console.log(chalk.blue('\n📊 1/3 - Backup da Database PostgreSQL...'));
-    await backupDatabaseWithSupabaseCLI(databaseUrl, backupDir);
-
-    // 2. Gerar inventário real
-    console.log(chalk.blue('\n🔍 2/3 - Gerando inventário completo...'));
-    await generateInventory(config, backupDir);
+    // 1. Backup da Database usando APENAS pg_dump/pg_dumpall
+    console.log(chalk.blue('\n📊 1/2 - Backup da Database PostgreSQL...'));
+    const dbBackupResult = await backupDatabaseWithPgDump(databaseUrl, backupDir, pgDumpPath);
+    
+    if (!dbBackupResult.success) {
+      console.error(chalk.red('❌ Falha crítica no backup da database'));
+      console.log(chalk.yellow('💡 Verifique:'));
+      console.log(chalk.yellow('  - Se DATABASE_URL está correta'));
+      console.log(chalk.yellow('  - Se as credenciais estão corretas'));
+      console.log(chalk.yellow('  - Se o banco está acessível'));
+      process.exit(1);
+    }
 
-    // 3. Backup das Edge Functions locais
-    console.log(chalk.blue('\n⚡ 3/3 - Backup das Edge Functions locais...'));
+    // 2. Backup das Edge Functions locais (se existirem)
+    console.log(chalk.blue('\n⚡ 2/2 - Backup das Edge Functions locais...'));
     await backupLocalFunctions(backupDir);
 
     // Gerar manifesto do backup
-    await generateBackupManifest(config, backupDir);
+    await generateBackupManifest(config, backupDir, dbBackupResult.files);
 
     console.log(chalk.green('\n🎉 Backup completo finalizado!'));
     console.log(chalk.blue(`📁 Localização: ${backupDir}`));
+    console.log(chalk.green(`✅ Database: ${dbBackupResult.files.length} arquivos SQL gerados`));
+    
+    // Mostrar resumo dos arquivos
+    console.log(chalk.blue('\n📊 Resumo dos arquivos gerados:'));
+    for (const file of dbBackupResult.files) {
+      const filePath = path.join(backupDir, file.filename);
+      const stats = fs.statSync(filePath);
+      const sizeKB = (stats.size / 1024).toFixed(1);
+      console.log(chalk.gray(`   - ${file.filename}: ${sizeKB} KB`));
+    }
 
   } catch (error) {
     console.error(chalk.red(`❌ Erro no backup: ${error.message}`));
@@ -68,57 +83,177 @@ module.exports = async (options) => {
   }
 };
 
-// Backup da database usando Supabase CLI
-async function backupDatabaseWithSupabaseCLI(databaseUrl, backupDir) {
-  try {
-    console.log(chalk.blue('   - Exportando roles...'));
-    const { stdout: rolesOutput } = await runCommand(
-      `supabase db dump --db-url "${databaseUrl}" -f roles.sql --role-only`
-    );
+// Encontrar caminho do pg_dump automaticamente
+async function findPgDumpPath() {
+  // Primeiro, tentar encontrar no PATH
+  const pgDumpPath = await ensureBin('pg_dump');
+  if (pgDumpPath) {
+    return pgDumpPath;
+  }
+
+  // No Windows, tentar caminhos comuns
+  if (process.platform === 'win32') {
+    const possiblePaths = [
+      'C:\\Program Files\\PostgreSQL\\17\\bin\\pg_dump.exe',
+      'C:\\Program Files\\PostgreSQL\\16\\bin\\pg_dump.exe',
+      'C:\\Program Files\\PostgreSQL\\15\\bin\\pg_dump.exe',
+      'C:\\Program Files\\PostgreSQL\\14\\bin\\pg_dump.exe',
+      'C:\\Program Files\\PostgreSQL\\13\\bin\\pg_dump.exe'
+    ];
     
+    for (const pgDumpPath of possiblePaths) {
+      if (fs.existsSync(pgDumpPath)) {
+        return pgDumpPath;
+      }
+    }
+  }
+
+  return null;
+}
+
+// Backup da database usando APENAS pg_dump/pg_dumpall
+async function backupDatabaseWithPgDump(databaseUrl, backupDir, pgDumpPath) {
+  try {
+    // Parse da URL da database
+    const url = new URL(databaseUrl);
+    const host = url.hostname;
+    const port = url.port || '5432';
+    const username = url.username;
+    const password = url.password;
+    const database = url.pathname.slice(1);
+
+    console.log(chalk.gray(`   - Host: ${host}:${port}`));
+    console.log(chalk.gray(`   - Database: ${database}`));
+    console.log(chalk.gray(`   - Username: ${username}`));
+
+    const files = [];
+    let success = true;
+
+    // 1. Backup do schema usando pg_dump (COMANDO VALIDADO)
     console.log(chalk.blue('   - Exportando schema...'));
-    const { stdout: schemaOutput } = await runCommand(
-      `supabase db dump --db-url "${databaseUrl}" -f schema.sql`
-    );
+    const schemaFile = path.join(backupDir, 'schema.sql');
+    const schemaCommand = `"${pgDumpPath}" "${databaseUrl}" --schema-only -f "${schemaFile}"`;
     
+    try {
+      await runCommand(schemaCommand, {
+        env: { ...process.env, PGPASSWORD: password }
+      });
+      
+      const schemaValidation = await validateSqlFile(schemaFile);
+      if (schemaValidation.valid) {
+        files.push({
+          filename: 'schema.sql',
+          size: schemaValidation.size,
+          sizeKB: schemaValidation.sizeKB
+        });
+        console.log(chalk.green(`     ✅ Schema exportado: ${schemaValidation.sizeKB} KB`));
+      } else {
+        console.log(chalk.red(`     ❌ Arquivo schema.sql inválido: ${schemaValidation.error}`));
+        success = false;
+      }
+    } catch (error) {
+      console.log(chalk.red(`     ❌ Erro ao exportar schema: ${error.message}`));
+      success = false;
+    }
+
+    // 2. Backup dos dados usando pg_dump (COMANDO VALIDADO)
     console.log(chalk.blue('   - Exportando dados...'));
-    const { stdout: dataOutput } = await runCommand(
-      `supabase db dump --db-url "${databaseUrl}" -f data.sql --use-copy --data-only`
-    );
+    const dataFile = path.join(backupDir, 'data.sql');
+    const dataCommand = `"${pgDumpPath}" "${databaseUrl}" --data-only -f "${dataFile}"`;
+    
+    try {
+      await runCommand(dataCommand, {
+        env: { ...process.env, PGPASSWORD: password }
+      });
+      
+      const dataValidation = await validateSqlFile(dataFile);
+      if (dataValidation.valid) {
+        files.push({
+          filename: 'data.sql',
+          size: dataValidation.size,
+          sizeKB: dataValidation.sizeKB
+        });
+        console.log(chalk.green(`     ✅ Dados exportados: ${dataValidation.sizeKB} KB`));
+      } else {
+        console.log(chalk.red(`     ❌ Arquivo data.sql inválido: ${dataValidation.error}`));
+        success = false;
+      }
+    } catch (error) {
+      console.log(chalk.red(`     ❌ Erro ao exportar dados: ${error.message}`));
+      success = false;
+    }
+
+    // 3. Backup dos roles usando pg_dumpall (COMANDO VALIDADO)
+    console.log(chalk.blue('   - Exportando roles...'));
+    const rolesFile = path.join(backupDir, 'roles.sql');
+    const pgDumpallPath = pgDumpPath.replace('pg_dump', 'pg_dumpall');
+    const rolesCommand = `"${pgDumpallPath}" --host=${host} --port=${port} --username=${username} --roles-only -f "${rolesFile}"`;
+    
+    try {
+      await runCommand(rolesCommand, {
+        env: { ...process.env, PGPASSWORD: password }
+      });
+      
+      const rolesValidation = await validateSqlFile(rolesFile);
+      if (rolesValidation.valid) {
+        files.push({
+          filename: 'roles.sql',
+          size: rolesValidation.size,
+          sizeKB: rolesValidation.sizeKB
+        });
+        console.log(chalk.green(`     ✅ Roles exportados: ${rolesValidation.sizeKB} KB`));
+      } else {
+        console.log(chalk.red(`     ❌ Arquivo roles.sql inválido: ${rolesValidation.error}`));
+        success = false;
+      }
+    } catch (error) {
+      console.log(chalk.red(`     ❌ Erro ao exportar roles: ${error.message}`));
+      success = false;
+    }
 
-    console.log(chalk.green('✅ Database exportada com sucesso'));
+    return { success, files };
   } catch (error) {
     throw new Error(`Falha no backup da database: ${error.message}`);
   }
 }
 
-// Gerar inventário completo
-async function generateInventory(config, backupDir) {
+// Validar arquivo SQL (não vazio e com conteúdo válido)
+async function validateSqlFile(filePath) {
   try {
-    const introspection = new IntrospectionService(config);
-    const inventory = await introspection.generateFullInventory();
+    if (!fs.existsSync(filePath)) {
+      return { valid: false, error: 'Arquivo não existe', size: 0, sizeKB: '0.0' };
+    }
 
-    // Salvar inventário em arquivos separados
-    const inventoryDir = path.join(backupDir, 'inventory');
-    await ensureDir(inventoryDir);
+    const stats = fs.statSync(filePath);
+    const sizeKB = (stats.size / 1024).toFixed(1);
+    
+    if (stats.size === 0) {
+      return { valid: false, error: 'Arquivo vazio', size: 0, sizeKB: '0.0' };
+    }
 
-    for (const [component, data] of Object.entries(inventory.components)) {
-      const filePath = path.join(inventoryDir, `${component}.json`);
-      await writeJson(filePath, data);
+    const content = fs.readFileSync(filePath, 'utf8');
+    
+    // Verificar se contém conteúdo SQL válido
+    const sqlKeywords = ['CREATE', 'INSERT', 'COPY', 'ALTER', 'DROP', 'GRANT', 'REVOKE'];
+    const hasValidContent = sqlKeywords.some(keyword => 
+      content.toUpperCase().includes(keyword)
+    );
+
+    if (!hasValidContent) {
+      return { valid: false, error: 'Sem conteúdo SQL válido', size: stats.size, sizeKB };
     }
 
-    console.log(chalk.green('✅ Inventário completo gerado'));
+    return { valid: true, error: null, size: stats.size, sizeKB };
   } catch (error) {
-    console.log(chalk.yellow(`⚠️ Erro ao gerar inventário: ${error.message}`));
+    return { valid: false, error: error.message, size: 0, sizeKB: '0.0' };
   }
 }
 
-// Backup das Edge Functions locais
+// Backup das Edge Functions locais (se existirem)
 async function backupLocalFunctions(backupDir) {
   const localFunctionsPath = 'supabase/functions';
   
   try {
-    const fs = require('fs');
     if (fs.existsSync(localFunctionsPath)) {
       const functionsBackupDir = path.join(backupDir, 'functions');
       await copyDir(localFunctionsPath, functionsBackupDir);
@@ -132,23 +267,26 @@ async function backupLocalFunctions(backupDir) {
 }
 
 // Gerar manifesto do backup
-async function generateBackupManifest(config, backupDir) {
+async function generateBackupManifest(config, backupDir, sqlFiles) {
   const manifest = {
     created_at: new Date().toISOString(),
     project_id: config.supabase.projectId,
     smoonb_version: require('../../package.json').version,
-    backup_type: 'complete',
+    backup_type: 'postgresql_native',
     files: {
       roles: 'roles.sql',
       schema: 'schema.sql',
       data: 'data.sql'
     },
     hashes: {},
-    inventory: {}
+    validation: {
+      sql_files_created: sqlFiles.length,
+      sql_files_valid: sqlFiles.length === 3,
+      total_size_kb: sqlFiles.reduce((total, file) => total + parseFloat(file.sizeKB), 0).toFixed(1)
+    }
   };
 
   // Calcular hashes dos arquivos SQL
-  const fs = require('fs');
   for (const [type, filename] of Object.entries(manifest.files)) {
     const filePath = path.join(backupDir, filename);
     if (fs.existsSync(filePath)) {
@@ -156,17 +294,6 @@ async function generateBackupManifest(config, backupDir) {
     }
   }
 
-  // Adicionar referências ao inventário
-  const inventoryDir = path.join(backupDir, 'inventory');
-  if (fs.existsSync(inventoryDir)) {
-    const inventoryFiles = fs.readdirSync(inventoryDir);
-    manifest.inventory = inventoryFiles.reduce((acc, file) => {
-      const component = path.basename(file, '.json');
-      acc[component] = `inventory/${file}`;
-      return acc;
-    }, {});
-  }
-
   const manifestPath = path.join(backupDir, 'backup-manifest.json');
   await writeJson(manifestPath, manifest);
 }