smoonb 0.0.6 → 0.0.8

package/src/commands/check.js

@@ -1,412 +1,272 @@
-/**
- * Comando de checklist pós-restore
- * Verificação de integridade completa
- */
-
+const { Command } = require('commander');
 const chalk = require('chalk');
-const { execSync } = require('child_process');
-const fs = require('fs');
 const path = require('path');
-const { getProjectId } = require('../utils/supabase');
-
-/**
- * Checklist pós-restore - Verificação de integridade
- * Resolve o problema: garantir que restauração foi bem-sucedida
- */
-async function checkCommand(options) {
-  console.log(chalk.red.bold('🚀 smoonb - EXPERIMENTAL VERSION'));
-  console.log(chalk.red.bold('⚠️  VERSÃO EXPERIMENTAL - NUNCA TESTADA EM PRODUÇÃO!'));
-  console.log(chalk.red.bold('🚨 USE POR SUA CONTA E RISCO - Pode causar perda de dados!'));
-  console.log(chalk.red.bold('❌ NÃO NOS RESPONSABILIZAMOS por qualquer perda de dados!\n'));
-  
-  console.log(chalk.cyan.bold('🔍 Checklist pós-restore - Verificação de integridade...\n'));
+const fs = require('fs');
+const { ensureBin, runCommand } = require('../utils/cli');
+const { readConfig, validateFor, writeJson } = require('../utils/config');
+const { IntrospectionService } = require('../services/introspect');
+const { showBetaBanner } = require('../index');
 
-  try {
-    // Obter projectId (da opção ou da configuração)
-    const projectId = options.projectId || getProjectId();
+const checkCommand = new Command('check')
+  .description('Verificar integridade do projeto Supabase após restauração')
+  .option('-o, --output <file>', 'Arquivo de saída do relatório', 'check-report.json')
+  .action(async (options) => {
+    showBetaBanner();
     
-    if (!projectId) {
-      console.error(chalk.red.bold('❌ Erro: Project ID não encontrado'));
-      console.log(chalk.yellow('💡 Opções:'));
-      console.log(chalk.gray('   1. Use: smoonb check --project-id <seu-project-id>'));
-      console.log(chalk.gray('   2. Configure: smoonb config --init'));
-      console.log(chalk.gray('   3. Ou defina SUPABASE_PROJECT_ID no ambiente'));
-      console.log(chalk.gray('   4. Ou edite ~/.smoonbrc e configure o projectId'));
-      process.exit(1);
-    }
+    try {
+      // Verificar se psql está disponível
+      const psqlPath = await ensureBin('psql');
+      if (!psqlPath) {
+        console.error(chalk.red('❌ psql não encontrado'));
+        console.log(chalk.yellow('💡 Instale PostgreSQL:'));
+        console.log(chalk.yellow('  https://www.postgresql.org/download/'));
+        process.exit(1);
+      }
+
+      // Carregar configuração
+      const config = await readConfig();
+      validateFor(config, 'backup'); // Usar mesma validação do backup
 
-    console.log(chalk.blue('🆔 Project ID:'), projectId);
-    console.log(chalk.blue('📊 Modo verbose:'), options.verbose ? 'Ativado' : 'Desativado');
-    console.log();
+      const databaseUrl = config.supabase.databaseUrl;
+      if (!databaseUrl) {
+        console.error(chalk.red('❌ databaseUrl não configurada'));
+        console.log(chalk.yellow('💡 Configure databaseUrl no .smoonbrc'));
+        process.exit(1);
+      }
 
-    // Executar verificações
-    const results = await runPostRestoreChecks(projectId, options.verbose);
+      console.log(chalk.blue(`🔍 Verificando integridade do projeto: ${config.supabase.projectId}`));
 
-    // Mostrar resumo
-    showCheckSummary(results);
+      // Executar verificações
+      const report = await performChecks(config, databaseUrl);
 
-  } catch (error) {
-    console.error(chalk.red.bold('❌ Erro durante o checklist:'), error.message);
-    process.exit(1);
-  }
-}
+      // Salvar relatório
+      const reportPath = path.resolve(options.output);
+      await writeJson(reportPath, report);
 
-/**
- * Executar todas as verificações pós-restore
- */
-async function runPostRestoreChecks(projectId, verbose = false) {
-  const checks = [
-    { name: 'Database Connection', category: 'database', status: 'pending', details: [] },
-    { name: 'Database Schema', category: 'database', status: 'pending', details: [] },
-    { name: 'Database Extensions', category: 'database', status: 'pending', details: [] },
-    { name: 'Edge Functions', category: 'functions', status: 'pending', details: [] },
-    { name: 'Auth Providers', category: 'auth', status: 'pending', details: [] },
-    { name: 'Auth Policies', category: 'auth', status: 'pending', details: [] },
-    { name: 'Storage Buckets', category: 'storage', status: 'pending', details: [] },
-    { name: 'Storage Objects', category: 'storage', status: 'pending', details: [] },
-    { name: 'Realtime Settings', category: 'realtime', status: 'pending', details: [] },
-    { name: 'API Endpoints', category: 'api', status: 'pending', details: [] }
-  ];
+      // Mostrar resumo
+      showCheckSummary(report);
 
-  console.log(chalk.blue.bold('🔍 Executando verificações...\n'));
+      console.log(chalk.green('\n🎉 Verificação concluída!'));
+      console.log(chalk.blue(`📋 Relatório salvo em: ${reportPath}`));
 
-  // Executar verificações por categoria
-  for (const check of checks) {
-    try {
-      await performCheck(check, projectId, verbose);
     } catch (error) {
-      check.status = 'error';
-      check.details.push(`Erro: ${error.message}`);
+      console.error(chalk.red(`❌ Erro na verificação: ${error.message}`));
+      process.exit(1);
     }
-  }
+  });
 
-  return checks;
-}
+// Executar todas as verificações
+async function performChecks(config, databaseUrl) {
+  const report = {
+    timestamp: new Date().toISOString(),
+    project_id: config.supabase.projectId,
+    checks: {}
+  };
 
-/**
- * Executar verificação individual
- */
-async function performCheck(check, projectId, verbose) {
-  if (verbose) {
-    console.log(chalk.gray(`   - Verificando ${check.name}...`));
-  }
+  // 1. Verificar conexão com database
+  console.log(chalk.blue('\n🔌 1/6 - Verificando conexão com database...'));
+  report.checks.database_connection = await checkDatabaseConnection(databaseUrl);
 
-  switch (check.name) {
-    case 'Database Connection':
-      await checkDatabaseConnection(check, projectId, verbose);
-      break;
-    case 'Database Schema':
-      await checkDatabaseSchema(check, projectId, verbose);
-      break;
-    case 'Database Extensions':
-      await checkDatabaseExtensions(check, projectId, verbose);
-      break;
-    case 'Edge Functions':
-      await checkEdgeFunctions(check, projectId, verbose);
-      break;
-    case 'Auth Providers':
-      await checkAuthProviders(check, projectId, verbose);
-      break;
-    case 'Auth Policies':
-      await checkAuthPolicies(check, projectId, verbose);
-      break;
-    case 'Storage Buckets':
-      await checkStorageBuckets(check, projectId, verbose);
-      break;
-    case 'Storage Objects':
-      await checkStorageObjects(check, projectId, verbose);
-      break;
-    case 'Realtime Settings':
-      await checkRealtimeSettings(check, projectId, verbose);
-      break;
-    case 'API Endpoints':
-      await checkAPIEndpoints(check, projectId, verbose);
-      break;
-  }
+  // 2. Verificar extensões
+  console.log(chalk.blue('\n🔧 2/6 - Verificando extensões...'));
+  report.checks.extensions = await checkExtensions(databaseUrl);
+
+  // 3. Verificar tabelas
+  console.log(chalk.blue('\n📊 3/6 - Verificando tabelas...'));
+  report.checks.tables = await checkTables(databaseUrl);
+
+  // 4. Verificar políticas RLS
+  console.log(chalk.blue('\n🔒 4/6 - Verificando políticas RLS...'));
+  report.checks.rls_policies = await checkRLSPolicies(databaseUrl);
+
+  // 5. Verificar Realtime
+  console.log(chalk.blue('\n🔄 5/6 - Verificando Realtime...'));
+  report.checks.realtime = await checkRealtime(databaseUrl);
+
+  // 6. Verificar Storage
+  console.log(chalk.blue('\n📦 6/6 - Verificando Storage...'));
+  report.checks.storage = await checkStorage(config);
+
+  return report;
 }
 
-/**
- * Verificar conexão com database
- */
-async function checkDatabaseConnection(check, projectId, verbose) {
+// Verificar conexão com database
+async function checkDatabaseConnection(databaseUrl) {
   try {
-    const dbUrl = process.env.DATABASE_URL || `postgresql://postgres:[password]@db.${projectId}.supabase.co:5432/postgres`;
-    
-    // Tentar conectar via psql
-    const testCmd = `psql "${dbUrl}" -c "SELECT 1;"`;
-    execSync(testCmd, { stdio: 'pipe' });
+    const { stdout } = await runCommand(
+      `psql "${databaseUrl}" -t -c "SELECT 1 as test_connection;"`
+    );
     
-    check.status = 'ok';
-    check.details.push('Conexão estabelecida com sucesso');
-    
-    if (verbose) {
-      console.log(chalk.gray('     ✅ Conexão com database OK'));
+    if (stdout.trim() === '1') {
+      return { status: 'ok', message: 'Conexão estabelecida com sucesso' };
+    } else {
+      return { status: 'error', message: 'Resposta inesperada da database' };
     }
   } catch (error) {
-    check.status = 'warning';
-    check.details.push('Conexão falhou (credenciais não configuradas)');
-    
-    if (verbose) {
-      console.log(chalk.gray('     ⚠️  Conexão com database falhou'));
-    }
+    return { status: 'error', message: `Falha na conexão: ${error.message}` };
   }
 }
 
-/**
- * Verificar schema da database
- */
-async function checkDatabaseSchema(check, projectId, verbose) {
+// Verificar extensões
+async function checkExtensions(databaseUrl) {
   try {
-    const dbUrl = process.env.DATABASE_URL || `postgresql://postgres:[password]@db.${projectId}.supabase.co:5432/postgres`;
-    
-    // Verificar tabelas principais
-    const schemaCmd = `psql "${dbUrl}" -c "SELECT schemaname, tablename FROM pg_tables WHERE schemaname = 'public';"`;
-    const output = execSync(schemaCmd, { encoding: 'utf8', stdio: 'pipe' });
+    const query = `
+      SELECT extname, extversion 
+      FROM pg_extension 
+      ORDER BY extname;
+    `;
     
-    const lines = output.split('\n').filter(line => line.trim() && !line.includes('schemaname'));
-    const tableCount = lines.length;
+    const { stdout } = await runCommand(
+      `psql "${databaseUrl}" -t -c "${query}"`
+    );
     
-    check.status = 'ok';
-    check.details.push(`${tableCount} tabelas encontradas no schema public`);
+    const extensions = stdout.trim().split('\n')
+      .filter(line => line.trim())
+      .map(line => {
+        const [name, version] = line.trim().split('|');
+        return { name: name?.trim(), version: version?.trim() };
+      });
     
-    if (verbose) {
-      console.log(chalk.gray(`     ✅ Schema OK (${tableCount} tabelas)`));
-    }
+    return {
+      status: 'ok',
+      message: `${extensions.length} extensões encontradas`,
+      data: extensions
+    };
   } catch (error) {
-    check.status = 'warning';
-    check.details.push('Não foi possível verificar schema (credenciais não configuradas)');
-    
-    if (verbose) {
-      console.log(chalk.gray('     ⚠️  Verificação de schema falhou'));
-    }
+    return { status: 'error', message: `Erro ao verificar extensões: ${error.message}` };
   }
 }
 
-/**
- * Verificar extensões da database
- */
-async function checkDatabaseExtensions(check, projectId, verbose) {
+// Verificar tabelas
+async function checkTables(databaseUrl) {
   try {
-    const dbUrl = process.env.DATABASE_URL || `postgresql://postgres:[password]@db.${projectId}.supabase.co:5432/postgres`;
+    const query = `
+      SELECT schemaname, tablename, tableowner 
+      FROM pg_tables 
+      WHERE schemaname IN ('public', 'auth', 'storage') 
+      ORDER BY schemaname, tablename;
+    `;
     
-    // Verificar extensões instaladas
-    const extensionsCmd = `psql "${dbUrl}" -c "SELECT extname FROM pg_extension;"`;
-    const output = execSync(extensionsCmd, { encoding: 'utf8', stdio: 'pipe' });
+    const { stdout } = await runCommand(
+      `psql "${databaseUrl}" -t -c "${query}"`
+    );
     
-    const lines = output.split('\n').filter(line => line.trim() && !line.includes('extname'));
-    const extensionCount = lines.length;
+    const tables = stdout.trim().split('\n')
+      .filter(line => line.trim())
+      .map(line => {
+        const [schema, table, owner] = line.trim().split('|');
+        return {
+          schema: schema?.trim(),
+          table: table?.trim(),
+          owner: owner?.trim()
+        };
+      });
     
-    check.status = 'ok';
-    check.details.push(`${extensionCount} extensões instaladas`);
-    
-    if (verbose) {
-      console.log(chalk.gray(`     ✅ Extensões OK (${extensionCount} instaladas)`));
-    }
+    return {
+      status: 'ok',
+      message: `${tables.length} tabelas encontradas`,
+      data: tables
+    };
   } catch (error) {
-    check.status = 'warning';
-    check.details.push('Não foi possível verificar extensões (credenciais não configuradas)');
-    
-    if (verbose) {
-      console.log(chalk.gray('     ⚠️  Verificação de extensões falhou'));
-    }
+    return { status: 'error', message: `Erro ao verificar tabelas: ${error.message}` };
   }
 }
 
-/**
- * Verificar Edge Functions
- */
-async function checkEdgeFunctions(check, projectId, verbose) {
+// Verificar políticas RLS
+async function checkRLSPolicies(databaseUrl) {
   try {
-    // Verificar se Supabase CLI está disponível
-    execSync('supabase --version', { stdio: 'pipe' });
+    const query = `
+      SELECT COUNT(*) as policy_count 
+      FROM pg_policies;
+    `;
     
-    // Listar functions remotas
-    const listCmd = 'supabase functions list';
-    const output = execSync(listCmd, { encoding: 'utf8', stdio: 'pipe' });
+    const { stdout } = await runCommand(
+      `psql "${databaseUrl}" -t -c "${query}"`
+    );
     
-    if (output.trim()) {
-      const lines = output.split('\n').filter(line => line.trim());
-      const functionCount = lines.length;
-      
-      check.status = 'ok';
-      check.details.push(`${functionCount} Edge Functions encontradas`);
-      
-      if (verbose) {
-        console.log(chalk.gray(`     ✅ Edge Functions OK (${functionCount} encontradas)`));
-      }
-    } else {
-      check.status = 'warning';
-      check.details.push('Nenhuma Edge Function encontrada');
-      
-      if (verbose) {
-        console.log(chalk.gray('     ⚠️  Nenhuma Edge Function encontrada'));
-      }
-    }
-  } catch (error) {
-    check.status = 'warning';
-    check.details.push('Supabase CLI não encontrado ou projeto não configurado');
+    const policyCount = parseInt(stdout.trim());
     
-    if (verbose) {
-      console.log(chalk.gray('     ⚠️  Verificação de Edge Functions falhou'));
-    }
-  }
-}
-
-/**
- * Verificar Auth Providers
- */
-async function checkAuthProviders(check, projectId, verbose) {
-  // TODO: Implementar verificação real via Supabase API
-  check.status = 'warning';
-  check.details.push('Verificação de Auth Providers em desenvolvimento');
-  
-  if (verbose) {
-    console.log(chalk.gray('     ⚠️  Verificação de Auth Providers em desenvolvimento'));
-  }
-}
-
-/**
- * Verificar Auth Policies
- */
-async function checkAuthPolicies(check, projectId, verbose) {
-  // TODO: Implementar verificação real via Supabase API
-  check.status = 'warning';
-  check.details.push('Verificação de Auth Policies em desenvolvimento');
-  
-  if (verbose) {
-    console.log(chalk.gray('     ⚠️  Verificação de Auth Policies em desenvolvimento'));
-  }
-}
-
-/**
- * Verificar Storage Buckets
- */
-async function checkStorageBuckets(check, projectId, verbose) {
-  // TODO: Implementar verificação real via Supabase API
-  check.status = 'warning';
-  check.details.push('Verificação de Storage Buckets em desenvolvimento');
-  
-  if (verbose) {
-    console.log(chalk.gray('     ⚠️  Verificação de Storage Buckets em desenvolvimento'));
-  }
-}
-
-/**
- * Verificar Storage Objects
- */
-async function checkStorageObjects(check, projectId, verbose) {
-  // TODO: Implementar verificação real via Supabase API
-  check.status = 'warning';
-  check.details.push('Verificação de Storage Objects em desenvolvimento');
-  
-  if (verbose) {
-    console.log(chalk.gray('     ⚠️  Verificação de Storage Objects em desenvolvimento'));
+    return {
+      status: 'ok',
+      message: `${policyCount} políticas RLS encontradas`,
+      data: { policy_count: policyCount }
+    };
+  } catch (error) {
+    return { status: 'error', message: `Erro ao verificar políticas RLS: ${error.message}` };
   }
 }
 
-/**
- * Verificar Realtime Settings
- */
-async function checkRealtimeSettings(check, projectId, verbose) {
-  // TODO: Implementar verificação real via Supabase API
-  check.status = 'warning';
-  check.details.push('Verificação de Realtime Settings em desenvolvimento');
-  
-  if (verbose) {
-    console.log(chalk.gray('     ⚠️  Verificação de Realtime Settings em desenvolvimento'));
+// Verificar Realtime
+async function checkRealtime(databaseUrl) {
+  try {
+    const query = `
+      SELECT pubname 
+      FROM pg_publication 
+      ORDER BY pubname;
+    `;
+    
+    const { stdout } = await runCommand(
+      `psql "${databaseUrl}" -t -c "${query}"`
+    );
+    
+    const publications = stdout.trim().split('\n')
+      .filter(line => line.trim())
+      .map(line => line.trim());
+    
+    return {
+      status: 'ok',
+      message: `${publications.length} publicações Realtime encontradas`,
+      data: { publications }
+    };
+  } catch (error) {
+    return { status: 'error', message: `Erro ao verificar Realtime: ${error.message}` };
   }
 }
 
-/**
- * Verificar API Endpoints
- */
-async function checkAPIEndpoints(check, projectId, verbose) {
+// Verificar Storage
+async function checkStorage(config) {
   try {
-    const supabaseUrl = process.env.SUPABASE_URL || `https://${projectId}.supabase.co`;
+    const introspection = new IntrospectionService(config);
+    const storageInventory = await introspection.getStorageInventory();
     
-    // Verificar endpoint de health
-    const healthUrl = `${supabaseUrl}/rest/v1/`;
+    const bucketCount = storageInventory.buckets?.length || 0;
+    const totalObjects = storageInventory.buckets?.reduce(
+      (total, bucket) => total + (bucket.objects?.length || 0), 0
+    ) || 0;
     
-    // Simular verificação (TODO: implementar verificação real)
-    check.status = 'ok';
-    check.details.push('API endpoints respondendo');
-    
-    if (verbose) {
-      console.log(chalk.gray('     ✅ API endpoints OK'));
-    }
+    return {
+      status: 'ok',
+      message: `${bucketCount} buckets e ${totalObjects} objetos encontrados`,
+      data: storageInventory
+    };
   } catch (error) {
-    check.status = 'warning';
-    check.details.push('Não foi possível verificar API endpoints');
-    
-    if (verbose) {
-      console.log(chalk.gray('     ⚠️  Verificação de API endpoints falhou'));
-    }
+    return { status: 'error', message: `Erro ao verificar Storage: ${error.message}` };
   }
 }
 
-/**
- * Mostrar resumo das verificações
- */
-function showCheckSummary(results) {
-  console.log(chalk.blue.bold('\n📊 Resumo das Verificações:\n'));
-
-  // Agrupar por categoria
-  const categories = {};
-  results.forEach(check => {
-    if (!categories[check.category]) {
-      categories[check.category] = [];
-    }
-    categories[check.category].push(check);
-  });
-
-  // Mostrar por categoria
-  Object.entries(categories).forEach(([category, checks]) => {
-    const categoryName = category.charAt(0).toUpperCase() + category.slice(1);
-    console.log(chalk.cyan.bold(`📁 ${categoryName}:`));
+// Mostrar resumo das verificações
+function showCheckSummary(report) {
+  console.log(chalk.blue('\n📋 RESUMO DAS VERIFICAÇÕES:'));
+  console.log(chalk.blue('═'.repeat(50)));
+  
+  for (const [checkName, result] of Object.entries(report.checks)) {
+    const icon = result.status === 'ok' ? '✅' : '❌';
+    const color = result.status === 'ok' ? chalk.green : chalk.red;
     
-    checks.forEach(check => {
-      const icon = check.status === 'ok' ? '✅' : 
-                   check.status === 'warning' ? '⚠️' : '❌';
-      const statusColor = check.status === 'ok' ? chalk.green : 
-                         check.status === 'warning' ? chalk.yellow : chalk.red;
-      
-      console.log(`  ${icon} ${statusColor(check.name)}`);
-      
-      if (check.details.length > 0) {
-        check.details.forEach(detail => {
-          console.log(chalk.gray(`    - ${detail}`));
-        });
-      }
-    });
-    console.log();
-  });
-
-  // Estatísticas gerais
-  const totalChecks = results.length;
-  const okChecks = results.filter(c => c.status === 'ok').length;
-  const warningChecks = results.filter(c => c.status === 'warning').length;
-  const errorChecks = results.filter(c => c.status === 'error').length;
-
-  console.log(chalk.blue.bold('📈 Estatísticas:'));
-  console.log(chalk.green(`✅ OK: ${okChecks}/${totalChecks}`));
-  console.log(chalk.yellow(`⚠️  Avisos: ${warningChecks}/${totalChecks}`));
-  console.log(chalk.red(`❌ Erros: ${errorChecks}/${totalChecks}`));
-
-  // Status geral
-  if (errorChecks === 0 && warningChecks === 0) {
-    console.log(chalk.green.bold('\n🎉 Todas as verificações passaram com sucesso!'));
-  } else if (errorChecks === 0) {
-    console.log(chalk.yellow.bold('\n⚠️  Verificações concluídas com avisos'));
-    console.log(chalk.gray('   - Projeto funcional, mas algumas verificações precisam de atenção'));
+    console.log(`${icon} ${color(checkName.replace(/_/g, ' ').toUpperCase())}: ${result.message}`);
+  }
+  
+  const okCount = Object.values(report.checks).filter(c => c.status === 'ok').length;
+  const totalCount = Object.keys(report.checks).length;
+  
+  console.log(chalk.blue('═'.repeat(50)));
+  console.log(chalk.blue(`📊 Resultado: ${okCount}/${totalCount} verificações passaram`));
+  
+  if (okCount === totalCount) {
+    console.log(chalk.green('🎉 Todas as verificações passaram!'));
   } else {
-    console.log(chalk.red.bold('\n❌ Verificações encontraram problemas críticos'));
-    console.log(chalk.gray('   - Alguns componentes podem não estar funcionando corretamente'));
+    console.log(chalk.yellow('⚠️ Algumas verificações falharam. Verifique o relatório completo.'));
   }
-
-  console.log(chalk.yellow('\n💡 Dicas:'));
-  console.log(chalk.gray('   - Configure credenciais: smoonb config --init'));
-  console.log(chalk.gray('   - Instale Supabase CLI: npm install -g supabase'));
-  console.log(chalk.gray('   - Execute verificações detalhadas: smoonb check --verbose'));
 }
 
-module.exports = checkCommand;
+module.exports = checkCommand;