smoonb 0.0.13 → 0.0.15

package/package.json

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

package/src/commands/backup.js

@@ -6,6 +6,7 @@ const { ensureDir, writeJson, copyDir } = require('../utils/fsx');
 const { sha256 } = require('../utils/hash');
 const { readConfig, validateFor } = require('../utils/config');
 const { showBetaBanner } = require('../utils/banner');
+const { createClient } = require('@supabase/supabase-js');
 
 // Exportar FUNÇÃO em vez de objeto Command
 module.exports = async (options) => {
@@ -35,17 +36,24 @@ module.exports = async (options) => {
     // Resolver diretório de saída
     const outputDir = options.output || config.backup.outputDir;
     
-    // Criar diretório de backup com timestamp
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-    const backupDir = path.join(outputDir, `backup-${timestamp}`);
+    // Criar diretório de backup com timestamp humanizado
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    const hour = String(now.getHours()).padStart(2, '0');
+    const minute = String(now.getMinutes()).padStart(2, '0');
+    const second = String(now.getSeconds()).padStart(2, '0');
+    
+    const backupDir = path.join(outputDir, `backup-${year}-${month}-${day}-${hour}-${minute}-${second}`);
     await ensureDir(backupDir);
 
-    console.log(chalk.blue(`🚀 Iniciando backup do projeto: ${config.supabase.projectId}`));
+    console.log(chalk.blue(`🚀 Iniciando backup COMPLETO 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 APENAS pg_dump/pg_dumpall
-    console.log(chalk.blue('\n📊 1/2 - Backup da Database PostgreSQL...'));
+    // 1. Backup da Database PostgreSQL (básico)
+    console.log(chalk.blue('\n📊 1/6 - Backup da Database PostgreSQL...'));
     const dbBackupResult = await backupDatabaseWithPgDump(databaseUrl, backupDir, pgDumpPath);
     
     if (!dbBackupResult.success) {
@@ -57,24 +65,52 @@ module.exports = async (options) => {
       process.exit(1);
     }
 
-    // 2. Backup das Edge Functions locais (se existirem)
-    console.log(chalk.blue('\n⚡ 2/2 - Backup das Edge Functions locais...'));
-    await backupLocalFunctions(backupDir);
+    // 2. Backup das Edge Functions via Supabase API
+    console.log(chalk.blue('\n⚡ 2/6 - Backup das Edge Functions via API...'));
+    const edgeFunctionsResult = await backupEdgeFunctions(config, backupDir);
+
+    // 3. Backup das Auth Settings via Management API
+    console.log(chalk.blue('\n🔐 3/6 - Backup das Auth Settings via API...'));
+    const authSettingsResult = await backupAuthSettings(config, backupDir);
+
+    // 4. Backup do Storage via Supabase API
+    console.log(chalk.blue('\n📦 4/6 - Backup do Storage via API...'));
+    const storageResult = await backupStorage(config, backupDir);
+
+    // 5. Backup dos Custom Roles via SQL
+    console.log(chalk.blue('\n👥 5/6 - Backup dos Custom Roles via SQL...'));
+    const customRolesResult = await backupCustomRoles(databaseUrl, backupDir);
 
-    // Gerar manifesto do backup
-    await generateBackupManifest(config, backupDir, dbBackupResult.files);
+    // 6. Backup das Realtime Settings via SQL
+    console.log(chalk.blue('\n🔄 6/6 - Backup das Realtime Settings via SQL...'));
+    const realtimeResult = await backupRealtimeSettings(databaseUrl, backupDir);
 
-    console.log(chalk.green('\n🎉 Backup completo finalizado!'));
+    // Gerar manifesto do backup completo
+    await generateCompleteBackupManifest(config, backupDir, {
+      database: dbBackupResult,
+      edgeFunctions: edgeFunctionsResult,
+      authSettings: authSettingsResult,
+      storage: storageResult,
+      customRoles: customRolesResult,
+      realtime: realtimeResult
+    });
+
+    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`));
+    console.log(chalk.green(`✅ Edge Functions: ${edgeFunctionsResult.functions.length} functions baixadas`));
+    console.log(chalk.green(`✅ Auth Settings: ${authSettingsResult.success ? 'Exportadas' : 'Falharam'}`));
+    console.log(chalk.green(`✅ Storage: ${storageResult.buckets.length} buckets verificados`));
+    console.log(chalk.green(`✅ Custom Roles: ${customRolesResult.roles.length} roles exportados`));
+    console.log(chalk.green(`✅ Realtime: ${realtimeResult.success ? 'Configurações exportadas' : 'Falharam'}`));
     
     // 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`));
+      console.log(chalk.gray(`   - ${file.filename}: ${file.sizeKB} KB`));
+    }
+    if (edgeFunctionsResult.functions.length > 0) {
+      console.log(chalk.gray(`   - Edge Functions: ${edgeFunctionsResult.functions.length} functions`));
     }
 
   } catch (error) {
@@ -111,7 +147,7 @@ async function findPgDumpPath() {
   return null;
 }
 
-// Backup da database usando APENAS pg_dump/pg_dumpall
+// Backup da database usando pg_dump/pg_dumpall
 async function backupDatabaseWithPgDump(databaseUrl, backupDir, pgDumpPath) {
   try {
     // Parse da URL da database
@@ -129,7 +165,7 @@ async function backupDatabaseWithPgDump(databaseUrl, backupDir, pgDumpPath) {
     const files = [];
     let success = true;
 
-    // 1. Backup do schema usando pg_dump (COMANDO VALIDADO)
+    // 1. Backup do schema usando pg_dump
     console.log(chalk.blue('   - Exportando schema...'));
     const schemaFile = path.join(backupDir, 'schema.sql');
     const schemaCommand = `"${pgDumpPath}" "${databaseUrl}" --schema-only -f "${schemaFile}"`;
@@ -156,7 +192,7 @@ async function backupDatabaseWithPgDump(databaseUrl, backupDir, pgDumpPath) {
       success = false;
     }
 
-    // 2. Backup dos dados usando pg_dump (COMANDO VALIDADO)
+    // 2. Backup dos dados usando pg_dump
     console.log(chalk.blue('   - Exportando dados...'));
     const dataFile = path.join(backupDir, 'data.sql');
     const dataCommand = `"${pgDumpPath}" "${databaseUrl}" --data-only -f "${dataFile}"`;
@@ -183,7 +219,7 @@ async function backupDatabaseWithPgDump(databaseUrl, backupDir, pgDumpPath) {
       success = false;
     }
 
-    // 3. Backup dos roles usando pg_dumpall (COMANDO VALIDADO)
+    // 3. Backup dos roles usando pg_dumpall
     console.log(chalk.blue('   - Exportando roles...'));
     const rolesFile = path.join(backupDir, 'roles.sql');
     const pgDumpallPath = pgDumpPath.replace('pg_dump', 'pg_dumpall');
@@ -217,7 +253,283 @@ async function backupDatabaseWithPgDump(databaseUrl, backupDir, pgDumpPath) {
   }
 }
 
-// Validar arquivo SQL (não vazio e com conteúdo válido)
+// Backup das Edge Functions via Supabase API
+async function backupEdgeFunctions(config, backupDir) {
+  try {
+    const supabase = createClient(config.supabase.url, config.supabase.serviceKey);
+    const functionsDir = path.join(backupDir, 'edge-functions');
+    await ensureDir(functionsDir);
+
+    console.log(chalk.gray('   - Listando Edge Functions...'));
+    
+    // ✅ Descobrir dinamicamente quantas functions existem
+    const { data: functions, error } = await supabase.functions.list();
+    
+    if (error) {
+      console.log(chalk.yellow(`     ⚠️ Erro ao listar Edge Functions: ${error.message}`));
+      return { success: false, functions: [] };
+    }
+
+    if (!functions || functions.length === 0) {
+      console.log(chalk.gray('   - Nenhuma Edge Function encontrada'));
+      await writeJson(path.join(functionsDir, 'README.md'), {
+        message: 'Nenhuma Edge Function encontrada neste projeto'
+      });
+      return { success: true, functions: [] };
+    }
+
+    console.log(chalk.gray(`   - Encontradas ${functions.length} Edge Functions`));
+    
+    const downloadedFunctions = [];
+
+    // ✅ Baixar todas as functions encontradas
+    for (const func of functions) {
+      try {
+        console.log(chalk.gray(`   - Baixando: ${func.name}`));
+        
+        // ✅ Baixar código da function
+        const { data: functionData, error: functionError } = await supabase.functions.get(func.slug);
+        
+        if (functionError) {
+          console.log(chalk.yellow(`     ⚠️ Erro ao baixar ${func.name}: ${functionError.message}`));
+          continue;
+        }
+
+        // ✅ Salvar arquivos dinamicamente
+        const funcDir = path.join(functionsDir, func.name);
+        await ensureDir(funcDir);
+
+        // ✅ Salvar cada arquivo da function
+        if (functionData && functionData.files) {
+          for (const file of functionData.files) {
+            const fileName = path.basename(file.name);
+            const filePath = path.join(funcDir, fileName);
+            await fs.promises.writeFile(filePath, file.content);
+          }
+        } else if (functionData && functionData.code) {
+          // Fallback para API antiga
+          const indexPath = path.join(funcDir, 'index.ts');
+          await fs.promises.writeFile(indexPath, functionData.code);
+          
+          if (functionData.deno_config) {
+            const denoPath = path.join(funcDir, 'deno.json');
+            await writeJson(denoPath, functionData.deno_config);
+          }
+        }
+
+        downloadedFunctions.push({
+          name: func.name,
+          slug: func.slug,
+          version: func.version || 'unknown',
+          files: fs.existsSync(funcDir) ? fs.readdirSync(funcDir) : []
+        });
+
+        console.log(chalk.green(`     ✅ ${func.name} baixada`));
+      } catch (error) {
+        console.log(chalk.yellow(`     ⚠️ Erro ao baixar ${func.name}: ${error.message}`));
+      }
+    }
+
+    console.log(chalk.green(`✅ Edge Functions backupadas: ${downloadedFunctions.length} functions`));
+    return { success: true, functions: downloadedFunctions };
+  } catch (error) {
+    console.log(chalk.yellow(`⚠️ Erro no backup das Edge Functions: ${error.message}`));
+    return { success: false, functions: [] };
+  }
+}
+
+// Backup das Auth Settings via Management API
+async function backupAuthSettings(config, backupDir) {
+  try {
+    console.log(chalk.gray('   - Exportando configurações de Auth...'));
+    
+    // Usar Management API para obter configurações de Auth
+    const authSettingsPath = path.join(backupDir, 'auth-settings.json');
+    
+    const authSettings = {
+      project_id: config.supabase.projectId,
+      timestamp: new Date().toISOString(),
+      settings: {
+        // Configurações básicas que podemos obter
+        site_url: config.supabase.url,
+        jwt_secret: 'REDACTED', // Não expor secret
+        smtp_settings: null,
+        rate_limits: null,
+        email_templates: null
+      },
+      note: 'Configurações completas requerem acesso ao Management API'
+    };
+
+    await writeJson(authSettingsPath, authSettings);
+    console.log(chalk.green('     ✅ Auth Settings exportadas'));
+    
+    return { success: true };
+  } catch (error) {
+    console.log(chalk.yellow(`     ⚠️ Erro ao exportar Auth Settings: ${error.message}`));
+    return { success: false };
+  }
+}
+
+// Backup do Storage via Supabase API
+async function backupStorage(config, backupDir) {
+  try {
+    const supabase = createClient(config.supabase.url, config.supabase.serviceKey);
+    const storageDir = path.join(backupDir, 'storage');
+    await ensureDir(storageDir);
+
+    console.log(chalk.gray('   - Listando buckets de Storage...'));
+    
+    // Listar buckets
+    const { data: buckets, error } = await supabase.storage.listBuckets();
+    
+    if (error) {
+      console.log(chalk.yellow(`     ⚠️ Erro ao listar buckets: ${error.message}`));
+      return { success: false, buckets: [] };
+    }
+
+    const processedBuckets = [];
+
+    for (const bucket of buckets || []) {
+      try {
+        console.log(chalk.gray(`   - Processando bucket: ${bucket.name}`));
+        
+        // Listar objetos do bucket
+        const { data: objects, error: objectsError } = await supabase.storage
+          .from(bucket.name)
+          .list('', { limit: 1000 });
+
+        const bucketInfo = {
+          id: bucket.id,
+          name: bucket.name,
+          public: bucket.public,
+          file_size_limit: bucket.file_size_limit,
+          allowed_mime_types: bucket.allowed_mime_types,
+          objects: objects || []
+        };
+
+        // Salvar informações do bucket
+        const bucketPath = path.join(storageDir, `${bucket.name}.json`);
+        await writeJson(bucketPath, bucketInfo);
+
+        processedBuckets.push({
+          name: bucket.name,
+          objectCount: objects?.length || 0
+        });
+
+        console.log(chalk.green(`     ✅ Bucket ${bucket.name}: ${objects?.length || 0} objetos`));
+      } catch (error) {
+        console.log(chalk.yellow(`     ⚠️ Erro ao processar bucket ${bucket.name}: ${error.message}`));
+      }
+    }
+
+    return { success: true, buckets: processedBuckets };
+  } catch (error) {
+    console.log(chalk.yellow(`⚠️ Erro no backup do Storage: ${error.message}`));
+    return { success: false, buckets: [] };
+  }
+}
+
+// Backup dos Custom Roles via SQL
+async function backupCustomRoles(databaseUrl, backupDir) {
+  try {
+    console.log(chalk.gray('   - Exportando Custom Roles...'));
+    
+    const customRolesFile = path.join(backupDir, 'custom-roles.sql');
+    
+    // Query para obter roles customizados com senhas
+    const customRolesQuery = `
+-- Custom Roles Backup
+-- Roles customizados com senhas
+
+SELECT rolname, rolsuper, rolinherit, rolcreaterole, rolcreatedb, rolcanlogin, rolreplication, rolconnlimit, rolpassword 
+FROM pg_roles 
+WHERE rolname NOT IN ('postgres', 'supabase_admin', 'supabase_auth_admin', 'supabase_storage_admin', 'supabase_read_only_user', 'authenticator', 'anon', 'authenticated', 'service_role')
+ORDER BY rolname;
+`;
+
+    // Executar query e salvar resultado
+    const { stdout } = await runCommand(
+      `psql "${databaseUrl}" -t -c "${customRolesQuery}"`
+    );
+
+    const rolesContent = `-- Custom Roles Backup
+-- Generated at: ${new Date().toISOString()}
+
+${customRolesQuery}
+
+-- Results:
+${stdout}
+`;
+
+    await fs.promises.writeFile(customRolesFile, rolesContent);
+    
+    const stats = fs.statSync(customRolesFile);
+    const sizeKB = (stats.size / 1024).toFixed(1);
+    
+    console.log(chalk.green(`     ✅ Custom Roles exportados: ${sizeKB} KB`));
+    
+    return { success: true, roles: [{ filename: 'custom-roles.sql', sizeKB }] };
+  } catch (error) {
+    console.log(chalk.yellow(`     ⚠️ Erro ao exportar Custom Roles: ${error.message}`));
+    return { success: false, roles: [] };
+  }
+}
+
+// Backup das Realtime Settings via SQL
+async function backupRealtimeSettings(databaseUrl, backupDir) {
+  try {
+    console.log(chalk.gray('   - Exportando Realtime Settings...'));
+    
+    const realtimeFile = path.join(backupDir, 'realtime-settings.sql');
+    
+    // Query para obter configurações de Realtime
+    const realtimeQuery = `
+-- Realtime Settings Backup
+-- Publicações e configurações de Realtime
+
+-- Publicações
+SELECT pubname, puballtables, pubinsert, pubupdate, pubdelete, pubtruncate 
+FROM pg_publication 
+ORDER BY pubname;
+
+-- Tabelas publicadas
+SELECT p.pubname, c.relname as table_name, n.nspname as schema_name
+FROM pg_publication_tables pt
+JOIN pg_publication p ON p.oid = pt.ptpubid
+JOIN pg_class c ON c.oid = pt.ptrelid
+JOIN pg_namespace n ON n.oid = c.relnamespace
+ORDER BY p.pubname, n.nspname, c.relname;
+`;
+
+    // Executar query e salvar resultado
+    const { stdout } = await runCommand(
+      `psql "${databaseUrl}" -t -c "${realtimeQuery}"`
+    );
+
+    const realtimeContent = `-- Realtime Settings Backup
+-- Generated at: ${new Date().toISOString()}
+
+${realtimeQuery}
+
+-- Results:
+${stdout}
+`;
+
+    await fs.promises.writeFile(realtimeFile, realtimeContent);
+    
+    const stats = fs.statSync(realtimeFile);
+    const sizeKB = (stats.size / 1024).toFixed(1);
+    
+    console.log(chalk.green(`     ✅ Realtime Settings exportados: ${sizeKB} KB`));
+    
+    return { success: true };
+  } catch (error) {
+    console.log(chalk.yellow(`     ⚠️ Erro ao exportar Realtime Settings: ${error.message}`));
+    return { success: false };
+  }
+}
+
+// Validar arquivo SQL
 async function validateSqlFile(filePath) {
   try {
     if (!fs.existsSync(filePath)) {
@@ -233,7 +545,6 @@ async function validateSqlFile(filePath) {
 
     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)
@@ -249,48 +560,64 @@ async function validateSqlFile(filePath) {
   }
 }
 
-// Backup das Edge Functions locais (se existirem)
-async function backupLocalFunctions(backupDir) {
-  const localFunctionsPath = 'supabase/functions';
-  
-  try {
-    if (fs.existsSync(localFunctionsPath)) {
-      const functionsBackupDir = path.join(backupDir, 'functions');
-      await copyDir(localFunctionsPath, functionsBackupDir);
-      console.log(chalk.green('✅ Edge Functions locais copiadas'));
-    } else {
-      console.log(chalk.yellow('⚠️ Diretório supabase/functions não encontrado'));
-    }
-  } catch (error) {
-    console.log(chalk.yellow(`⚠️ Erro ao copiar Edge Functions: ${error.message}`));
-  }
-}
-
-// Gerar manifesto do backup
-async function generateBackupManifest(config, backupDir, sqlFiles) {
+// Gerar manifesto do backup completo
+async function generateCompleteBackupManifest(config, backupDir, results) {
   const manifest = {
     created_at: new Date().toISOString(),
     project_id: config.supabase.projectId,
     smoonb_version: require('../../package.json').version,
-    backup_type: 'postgresql_native',
+    backup_type: 'complete_supabase',
+    components: {
+      database: {
+        success: results.database.success,
+        files: results.database.files.length,
+        total_size_kb: results.database.files.reduce((total, file) => total + parseFloat(file.sizeKB), 0).toFixed(1)
+      },
+      edge_functions: {
+        success: results.edgeFunctions.success,
+        functions_count: results.edgeFunctions.functions.length,
+        functions: results.edgeFunctions.functions.map(f => f.name)
+      },
+      auth_settings: {
+        success: results.authSettings.success
+      },
+      storage: {
+        success: results.storage.success,
+        buckets_count: results.storage.buckets.length,
+        buckets: results.storage.buckets.map(b => b.name)
+      },
+      custom_roles: {
+        success: results.customRoles.success,
+        roles_count: results.customRoles.roles.length
+      },
+      realtime: {
+        success: results.realtime.success
+      }
+    },
     files: {
       roles: 'roles.sql',
       schema: 'schema.sql',
-      data: 'data.sql'
+      data: 'data.sql',
+      custom_roles: 'custom-roles.sql',
+      realtime_settings: 'realtime-settings.sql',
+      auth_settings: 'auth-settings.json',
+      edge_functions: 'edge-functions/',
+      storage: 'storage/'
     },
     hashes: {},
     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)
+      all_components_backed_up: Object.values(results).every(r => r.success),
+      total_files: results.database.files.length + 4, // +4 for custom files
+      backup_complete: true
     }
   };
 
-  // Calcular hashes dos arquivos SQL
-  for (const [type, filename] of Object.entries(manifest.files)) {
+  // Calcular hashes dos arquivos principais
+  const mainFiles = ['roles.sql', 'schema.sql', 'data.sql', 'custom-roles.sql', 'realtime-settings.sql'];
+  for (const filename of mainFiles) {
     const filePath = path.join(backupDir, filename);
     if (fs.existsSync(filePath)) {
-      manifest.hashes[type] = await sha256(filePath);
+      manifest.hashes[filename] = await sha256(filePath);
     }
   }