smoonb 0.0.1

package/src/index.js

@@ -0,0 +1,269 @@
+/**
+ * smoonb - Complete Supabase backup and migration tool
+ * Entry point principal e exports dos módulos
+ * 
+ * Versão: 0.1.0-beta (FREE BETA PERIOD)
+ */
+
+const chalk = require('chalk');
+
+// Exportar comandos
+const backupCommand = require('./commands/backup');
+const restoreCommand = require('./commands/restore');
+const secretsCommand = require('./commands/secrets');
+const functionsCommand = require('./commands/functions');
+const checkCommand = require('./commands/check');
+const configCommand = require('./commands/config');
+
+// Exportar utilitários
+const supabaseUtils = require('./utils/supabase');
+const validationUtils = require('./utils/validation');
+
+/**
+ * Informações do pacote
+ */
+const packageInfo = {
+  name: 'smoonb',
+  version: '0.0.1',
+  description: 'Complete Supabase backup and migration tool - EXPERIMENTAL VERSION - USE AT YOUR OWN RISK',
+  author: 'Goalmoon Tecnologia LTDA <https://goalmoon.com>',
+  license: 'SEE LICENSE IN LICENSE.md'
+};
+
+/**
+ * Banner da versão experimental
+ */
+function showBetaBanner() {
+  console.log(chalk.red.bold(`
+╔══════════════════════════════════════════════════════════════╗
+║                    🚀 smoonb v0.0.1                        ║
+║                                                              ║
+║              ⚠️  EXPERIMENTAL VERSION - NÃO TESTADA!        ║
+║                                                              ║
+║  🚨 AVISO: Este software NUNCA foi testado em produção!     ║
+║  ⚠️  USE POR SUA CONTA E RISCO - Pode causar perda de dados ║
+║  ❌ NÃO NOS RESPONSABILIZAMOS por qualquer perda de dados   ║
+║                                                              ║
+║  A primeira ferramenta CLI completa para backup e migração  ║
+║  de projetos Supabase. Resolve o problema de backup        ║
+║  incompleto das ferramentas existentes.                     ║
+║                                                              ║
+║  ✅ Database PostgreSQL + Edge Functions + Auth Settings     ║
+║  ✅ Storage Objects + Realtime Settings + Metadados          ║
+║                                                              ║
+║  🏢 Desenvolvido por: Goalmoon Tecnologia LTDA              ║
+║  🌐 Website: https://goalmoon.com                           ║
+║  📖 Documentação: https://github.com/almmello/smoonb       ║
+║  🐛 Issues: https://github.com/almmello/smoonb/issues      ║
+╚══════════════════════════════════════════════════════════════╝
+`));
+}
+
+/**
+ * Informações de licenciamento
+ */
+function showLicenseInfo() {
+  console.log(chalk.yellow.bold(`
+📋 INFORMAÇÕES DE LICENCIAMENTO:
+
+🆓 VERSÃO EXPERIMENTAL GRATUITA (Versões 0.x.x):
+   ✅ Uso gratuito para projetos pessoais e comerciais
+   ✅ Sem restrições de funcionalidades
+   ❌ SEM SUPORTE - apenas aceitamos contribuições
+   ⚠️ USE POR SUA CONTA E RISCO - software não testado
+
+💼 LICENÇA COMERCIAL (Versões 1.0.0+):
+   ⚠️  A partir da versão 1.0.0, o smoonb será licenciado comercialmente
+   📧 Aviso prévio: Mudanças serão anunciadas 90 dias antes
+   💰 Desconto especial: Usuários experimentais terão condições preferenciais
+
+🏢 DESENVOLVIDO POR: Goalmoon Tecnologia LTDA
+🌐 Website: https://goalmoon.com
+
+📖 Leia a licença completa em: LICENSE.md
+`));
+}
+
+/**
+ * Informações de ajuda rápida
+ */
+function showQuickHelp() {
+  console.log(chalk.cyan.bold(`
+🚀 COMANDOS PRINCIPAIS:
+
+📊 Backup completo:
+   smoonb backup --project-id <project-id>
+
+🔄 Restauração completa:
+   smoonb restore --project-id <project-id> --backup-dir <backup-dir>
+
+🔐 Gerenciamento de secrets:
+   smoonb secrets export
+   smoonb secrets import
+
+⚡ Edge Functions:
+   smoonb functions push
+   smoonb functions list
+
+🔍 Verificação pós-restore:
+   smoonb check --project-id <project-id>
+
+⚙️  Configuração:
+   smoonb config --init
+`));
+}
+
+/**
+ * Verificar pré-requisitos
+ */
+function checkPrerequisites() {
+  const prerequisites = {
+    node: { installed: true, version: process.version },
+    npm: { installed: false, version: null },
+    supabase_cli: { installed: false, version: null },
+    pg_dump: { installed: false, version: null }
+  };
+
+  // Verificar npm
+  try {
+    const { execSync } = require('child_process');
+    const npmVersion = execSync('npm --version', { encoding: 'utf8' }).trim();
+    prerequisites.npm = { installed: true, version: npmVersion };
+  } catch (error) {
+    prerequisites.npm = { installed: false, version: null };
+  }
+
+  // Verificar Supabase CLI
+  try {
+    const { execSync } = require('child_process');
+    const supabaseVersion = execSync('supabase --version', { encoding: 'utf8' }).trim();
+    prerequisites.supabase_cli = { installed: true, version: supabaseVersion };
+  } catch (error) {
+    prerequisites.supabase_cli = { installed: false, version: null };
+  }
+
+  // Verificar pg_dump
+  try {
+    const { execSync } = require('child_process');
+    const pgDumpVersion = execSync('pg_dump --version', { encoding: 'utf8' }).trim();
+    prerequisites.pg_dump = { installed: true, version: pgDumpVersion };
+  } catch (error) {
+    prerequisites.pg_dump = { installed: false, version: null };
+  }
+
+  return prerequisites;
+}
+
+/**
+ * Mostrar status dos pré-requisitos
+ */
+function showPrerequisitesStatus() {
+  const prerequisites = checkPrerequisites();
+  
+  console.log(chalk.blue.bold('\n📋 Status dos Pré-requisitos:\n'));
+  
+  Object.entries(prerequisites).forEach(([name, info]) => {
+    const icon = info.installed ? '✅' : '❌';
+    const status = info.installed ? chalk.green('Instalado') : chalk.red('Não instalado');
+    const version = info.version ? chalk.gray(`(${info.version})`) : '';
+    
+    console.log(`  ${icon} ${chalk.cyan(name)}: ${status} ${version}`);
+  });
+
+  // Mostrar instruções para instalar dependências faltantes
+  const missing = Object.entries(prerequisites)
+    .filter(([_, info]) => !info.installed)
+    .map(([name, _]) => name);
+
+  if (missing.length > 0) {
+    console.log(chalk.yellow.bold('\n💡 Instruções de instalação:'));
+    
+    if (missing.includes('supabase_cli')) {
+      console.log(chalk.gray('  - Supabase CLI: npm install -g supabase'));
+    }
+    
+    if (missing.includes('pg_dump')) {
+      console.log(chalk.gray('  - PostgreSQL: https://www.postgresql.org/download/'));
+    }
+  }
+}
+
+/**
+ * Verificar configuração atual
+ */
+function checkCurrentConfig() {
+  const config = supabaseUtils.loadConfig();
+  const hasCredentials = supabaseUtils.hasCredentials();
+  
+  console.log(chalk.blue.bold('\n⚙️  Configuração Atual:\n'));
+  
+  if (config) {
+    console.log(chalk.green('✅ Arquivo de configuração encontrado'));
+    console.log(chalk.gray(`   - Localização: ${require('os').homedir()}/.smoonbrc`));
+    
+    if (config.supabase?.url) {
+      console.log(chalk.gray(`   - Supabase URL: ${config.supabase.url}`));
+    }
+    
+    if (config.supabase?.serviceKey) {
+      console.log(chalk.gray('   - Service Key: Configurada'));
+    }
+    
+    if (config.supabase?.anonKey) {
+      console.log(chalk.gray('   - Anon Key: Configurada'));
+    }
+  } else {
+    console.log(chalk.yellow('⚠️  Arquivo de configuração não encontrado'));
+    console.log(chalk.gray('   - Use: smoonb config --init'));
+  }
+  
+  if (hasCredentials) {
+    console.log(chalk.green('✅ Credenciais configuradas'));
+  } else {
+    console.log(chalk.yellow('⚠️  Credenciais não configuradas'));
+    console.log(chalk.gray('   - Configure SUPABASE_URL e SUPABASE_ANON_KEY'));
+  }
+}
+
+/**
+ * Informações de diagnóstico completo
+ */
+function showDiagnostics() {
+  showBetaBanner();
+  showPrerequisitesStatus();
+  checkCurrentConfig();
+  showLicenseInfo();
+}
+
+/**
+ * Exportar todos os módulos
+ */
+module.exports = {
+  // Informações do pacote
+  packageInfo,
+  
+  // Comandos
+  commands: {
+    backup: backupCommand,
+    restore: restoreCommand,
+    secrets: secretsCommand,
+    functions: functionsCommand,
+    check: checkCommand,
+    config: configCommand
+  },
+  
+  // Utilitários
+  utils: {
+    supabase: supabaseUtils,
+    validation: validationUtils
+  },
+  
+  // Funções de utilidade
+  showBetaBanner,
+  showLicenseInfo,
+  showQuickHelp,
+  checkPrerequisites,
+  showPrerequisitesStatus,
+  checkCurrentConfig,
+  showDiagnostics
+};

package/src/utils/supabase.js

@@ -0,0 +1,364 @@
+/**
+ * Utilitários para conexão e operações com Supabase
+ */
+
+const { createClient } = require('@supabase/supabase-js');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Cliente Supabase configurado
+ */
+let supabaseClient = null;
+
+/**
+ * Inicializar cliente Supabase
+ */
+function initSupabaseClient() {
+  try {
+    const supabaseUrl = process.env.SUPABASE_URL;
+    const supabaseKey = process.env.SUPABASE_ANON_KEY || process.env.SUPABASE_SERVICE_ROLE_KEY;
+
+    if (!supabaseUrl || !supabaseKey) {
+      throw new Error('SUPABASE_URL e SUPABASE_ANON_KEY são obrigatórios');
+    }
+
+    supabaseClient = createClient(supabaseUrl, supabaseKey);
+    return supabaseClient;
+  } catch (error) {
+    throw new Error(`Erro ao inicializar cliente Supabase: ${error.message}`);
+  }
+}
+
+/**
+ * Obter cliente Supabase (inicializa se necessário)
+ */
+function getSupabaseClient() {
+  if (!supabaseClient) {
+    return initSupabaseClient();
+  }
+  return supabaseClient;
+}
+
+/**
+ * Carregar configuração do arquivo .smoonbrc
+ */
+function loadConfig() {
+  const configPath = path.join(os.homedir(), '.smoonbrc');
+  
+  try {
+    if (fs.existsSync(configPath)) {
+      const configContent = fs.readFileSync(configPath, 'utf8');
+      return JSON.parse(configContent);
+    }
+  } catch (error) {
+    console.warn('Erro ao carregar configuração:', error.message);
+  }
+  
+  return null;
+}
+
+/**
+ * Salvar configuração no arquivo .smoonbrc
+ */
+function saveConfig(config) {
+  const configPath = path.join(os.homedir(), '.smoonbrc');
+  
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    return true;
+  } catch (error) {
+    console.error('Erro ao salvar configuração:', error.message);
+    return false;
+  }
+}
+
+/**
+ * Obter URL de conexão da database
+ */
+function getDatabaseUrl(projectId) {
+  // Tentar variável de ambiente primeiro
+  if (process.env.DATABASE_URL) {
+    return process.env.DATABASE_URL;
+  }
+  
+  // Tentar configuração
+  const config = loadConfig();
+  if (config?.supabase?.databaseUrl) {
+    return config.supabase.databaseUrl;
+  }
+  
+  // URL padrão (requer configuração de senha)
+  return `postgresql://postgres:[password]@db.${projectId}.supabase.co:5432/postgres`;
+}
+
+/**
+ * Obter URL do projeto Supabase
+ */
+function getSupabaseUrl(projectId) {
+  // Tentar variável de ambiente primeiro
+  if (process.env.SUPABASE_URL) {
+    return process.env.SUPABASE_URL;
+  }
+  
+  // Tentar configuração
+  const config = loadConfig();
+  if (config?.supabase?.url) {
+    return config.supabase.url;
+  }
+  
+  // URL padrão
+  return `https://${projectId}.supabase.co`;
+}
+
+/**
+ * Obter service key do Supabase
+ */
+function getServiceKey() {
+  // Tentar variável de ambiente primeiro
+  if (process.env.SUPABASE_SERVICE_ROLE_KEY) {
+    return process.env.SUPABASE_SERVICE_ROLE_KEY;
+  }
+  
+  // Tentar configuração
+  const config = loadConfig();
+  if (config?.supabase?.serviceKey) {
+    return config.supabase.serviceKey;
+  }
+  
+  return null;
+}
+
+/**
+ * Obter anon key do Supabase
+ */
+function getAnonKey() {
+  // Tentar variável de ambiente primeiro
+  if (process.env.SUPABASE_ANON_KEY) {
+    return process.env.SUPABASE_ANON_KEY;
+  }
+  
+  // Tentar configuração
+  const config = loadConfig();
+  if (config?.supabase?.anonKey) {
+    return config.supabase.anonKey;
+  }
+  
+  return null;
+}
+
+/**
+ * Verificar se credenciais estão configuradas
+ */
+function hasCredentials() {
+  return !!(getSupabaseUrl() && (getServiceKey() || getAnonKey()));
+}
+
+/**
+ * Testar conexão com Supabase
+ */
+async function testConnection() {
+  try {
+    const client = getSupabaseClient();
+    
+    // Tentar uma operação simples
+    const { data, error } = await client.from('_smoonb_test').select('*').limit(1);
+    
+    if (error && error.code !== 'PGRST116') { // PGRST116 = tabela não existe (esperado)
+      throw error;
+    }
+    
+    return { success: true, message: 'Conexão estabelecida com sucesso' };
+  } catch (error) {
+    return { success: false, message: error.message };
+  }
+}
+
+/**
+ * Obter informações do projeto
+ */
+async function getProjectInfo(projectId) {
+  try {
+    const client = getSupabaseClient();
+    
+    // TODO: Implementar busca real de informações do projeto
+    // Por enquanto, retornar informações básicas
+    return {
+      id: projectId,
+      url: getSupabaseUrl(projectId),
+      status: 'active',
+      region: 'unknown',
+      created_at: new Date().toISOString()
+    };
+  } catch (error) {
+    throw new Error(`Erro ao obter informações do projeto: ${error.message}`);
+  }
+}
+
+/**
+ * Listar tabelas da database
+ */
+async function listTables() {
+  try {
+    const client = getSupabaseClient();
+    
+    // Usar RPC para listar tabelas
+    const { data, error } = await client.rpc('get_tables');
+    
+    if (error) {
+      throw error;
+    }
+    
+    return data || [];
+  } catch (error) {
+    // Fallback: tentar query direta
+    try {
+      const { data, error } = await client
+        .from('information_schema.tables')
+        .select('table_name')
+        .eq('table_schema', 'public');
+      
+      if (error) {
+        throw error;
+      }
+      
+      return data?.map(row => row.table_name) || [];
+    } catch (fallbackError) {
+      throw new Error(`Erro ao listar tabelas: ${fallbackError.message}`);
+    }
+  }
+}
+
+/**
+ * Listar extensões instaladas
+ */
+async function listExtensions() {
+  try {
+    const client = getSupabaseClient();
+    
+    // Usar RPC para listar extensões
+    const { data, error } = await client.rpc('get_extensions');
+    
+    if (error) {
+      throw error;
+    }
+    
+    return data || [];
+  } catch (error) {
+    // Fallback: tentar query direta
+    try {
+      const { data, error } = await client
+        .from('pg_extension')
+        .select('extname');
+      
+      if (error) {
+        throw error;
+      }
+      
+      return data?.map(row => row.extname) || [];
+    } catch (fallbackError) {
+      throw new Error(`Erro ao listar extensões: ${fallbackError.message}`);
+    }
+  }
+}
+
+/**
+ * Obter configurações de Auth
+ */
+async function getAuthSettings() {
+  try {
+    const client = getSupabaseClient();
+    
+    // TODO: Implementar busca real de configurações de Auth
+    // Por enquanto, retornar estrutura básica
+    return {
+      providers: [],
+      policies: [],
+      settings: {
+        enable_signup: true,
+        enable_email_confirmations: true
+      }
+    };
+  } catch (error) {
+    throw new Error(`Erro ao obter configurações de Auth: ${error.message}`);
+  }
+}
+
+/**
+ * Obter configurações de Storage
+ */
+async function getStorageSettings() {
+  try {
+    const client = getSupabaseClient();
+    
+    // Listar buckets
+    const { data: buckets, error: bucketsError } = await client.storage.listBuckets();
+    
+    if (bucketsError) {
+      throw bucketsError;
+    }
+    
+    // Para cada bucket, listar objetos
+    const bucketsWithObjects = [];
+    for (const bucket of buckets) {
+      const { data: objects, error: objectsError } = await client.storage
+        .from(bucket.name)
+        .list();
+      
+      bucketsWithObjects.push({
+        ...bucket,
+        objects: objects || []
+      });
+    }
+    
+    return {
+      buckets: bucketsWithObjects,
+      total_buckets: buckets.length,
+      total_objects: bucketsWithObjects.reduce((sum, bucket) => sum + bucket.objects.length, 0)
+    };
+  } catch (error) {
+    throw new Error(`Erro ao obter configurações de Storage: ${error.message}`);
+  }
+}
+
+/**
+ * Obter configurações de Realtime
+ */
+async function getRealtimeSettings() {
+  try {
+    const client = getSupabaseClient();
+    
+    // TODO: Implementar busca real de configurações de Realtime
+    // Por enquanto, retornar estrutura básica
+    return {
+      enabled: true,
+      channels: [],
+      settings: {
+        max_channels_per_client: 100,
+        max_events_per_second: 100
+      }
+    };
+  } catch (error) {
+    throw new Error(`Erro ao obter configurações de Realtime: ${error.message}`);
+  }
+}
+
+module.exports = {
+  initSupabaseClient,
+  getSupabaseClient,
+  loadConfig,
+  saveConfig,
+  getDatabaseUrl,
+  getSupabaseUrl,
+  getServiceKey,
+  getAnonKey,
+  hasCredentials,
+  testConnection,
+  getProjectInfo,
+  listTables,
+  listExtensions,
+  getAuthSettings,
+  getStorageSettings,
+  getRealtimeSettings
+};