smoonb 0.0.21 → 0.0.24

package/README.md

@@ -25,25 +25,42 @@ O **smoonb** resolve o problema das ferramentas existentes que fazem backup apen
 
 ## 🚀 Instalação
 
+**⚠️ IMPORTANTE: Instale APENAS localmente no projeto!**
+
 ```bash
-# Instalar localmente no projeto
+# ✅ CORRETO - Instalar localmente no projeto
 npm install smoonb
 
-# Usar com npx
+# ✅ CORRETO - Usar com npx
 npx smoonb --help
+
+# ❌ ERRADO - NÃO instalar globalmente
+npm install -g smoonb  # ← Isso será bloqueado!
 ```
 
+**💡 Por que apenas local?**
+- **🔒 Segurança**: Evita conflitos de versão
+- **📦 Isolamento**: Cada projeto usa sua versão
+- **🔄 Atualizações**: Controle granular por projeto
+- **🛡️ Estabilidade**: Evita quebras em outros projetos
+
 ## 📋 Pré-requisitos
 
-### 1. Supabase CLI
+### 1. Docker Desktop
 ```bash
-npm install -g supabase
+# Instalar Docker Desktop
+# Windows/macOS: https://docs.docker.com/desktop/install/
+# Linux: https://docs.docker.com/engine/install/
+
+# Verificar se está rodando
+docker --version
+docker ps
 ```
 
-### 2. PostgreSQL (psql)
-- **Windows**: https://www.postgresql.org/download/windows/
-- **macOS**: `brew install postgresql`
-- **Linux**: `sudo apt-get install postgresql-client`
+### 2. Supabase CLI
+```bash
+npm install -g supabase
+```
 
 ## ⚙️ Configuração
 

package/bin/smoonb.js

@@ -70,6 +70,7 @@ program
   .command('backup')
   .description('Fazer backup completo do projeto Supabase usando Supabase CLI')
   .option('-o, --output <dir>', 'Diretório de saída do backup')
+  .option('--skip-realtime', 'Pular captura interativa de Realtime Settings')
   .action(commands.backup);
 
 program

package/package.json

@@ -1,14 +1,18 @@
 {
   "name": "smoonb",
-  "version": "0.0.21",
+  "version": "0.0.24",
   "description": "Complete Supabase backup and migration tool - EXPERIMENTAL VERSION - USE AT YOUR OWN RISK",
+  "preferGlobal": false,
+  "preventGlobalInstall": true,
   "main": "index.js",
   "bin": {
     "smoonb": "bin/smoonb.js"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "start": "node bin/smoonb.js"
+    "start": "node bin/smoonb.js",
+    "preinstall": "node -e \"if(process.env.npm_config_global) { console.error('\\n❌ SMOONB NÃO DEVE SER INSTALADO GLOBALMENTE!\\n\\n📋 Para usar o smoonb, instale localmente no seu projeto:\\n   npm install smoonb\\n\\n💡 Depois execute com:\\n   npx smoonb backup\\n\\n🚫 Instalação global cancelada!\\n'); process.exit(1); }\"",
+    "postinstall": "echo '\\n✅ smoonb instalado com sucesso!\\n💡 Execute: npx smoonb backup\\n📖 Documentação: https://github.com/almmello/smoonb\\n'"
   },
   "keywords": [
     "supabase",

package/src/commands/backup.js

@@ -8,6 +8,7 @@ const { sha256 } = require('../utils/hash');
 const { readConfig, validateFor } = require('../utils/config');
 const { showBetaBanner } = require('../utils/banner');
 const { canPerformCompleteBackup, getDockerVersion } = require('../utils/docker');
+const { captureRealtimeSettings } = require('../utils/realtime-settings');
 
 const execAsync = promisify(exec);
 
@@ -135,9 +136,9 @@ async function performFullBackup(config, options) {
   const rolesResult = await backupCustomRoles(config.supabase.databaseUrl, backupDir);
   manifest.components.custom_roles = rolesResult;
 
-  // 6. Backup Realtime Settings via SQL
-  console.log(chalk.blue('\n🔄 6/6 - Backup das Realtime Settings via SQL...'));
-  const realtimeResult = await backupRealtimeSettings(config.supabase.databaseUrl, backupDir);
+  // 6. Backup Realtime Settings via Captura Interativa
+  console.log(chalk.blue('\n🔄 6/6 - Backup das Realtime Settings via Captura Interativa...'));
+  const realtimeResult = await backupRealtimeSettings(config.supabase.projectId, backupDir, options.skipRealtime);
   manifest.components.realtime = realtimeResult;
 
   // Salvar manifest
@@ -230,7 +231,7 @@ async function backupDatabaseWithDocker(databaseUrl, backupDir) {
     const schemaFile = path.join(backupDir, 'schema.sql');
     
     try {
-      await execAsync(`supabase db dump --db-url "${databaseUrl}" --schema-only -f "${schemaFile}"`);
+      await execAsync(`supabase db dump --db-url "${databaseUrl}" -f "${schemaFile}"`);
       
       const schemaValidation = await validateSqlFile(schemaFile);
       if (schemaValidation.valid) {
@@ -524,102 +525,48 @@ async function backupStorage(projectId, accessToken, backupDir) {
   }
 }
 
-// Backup dos Custom Roles via SQL
+// Backup dos Custom Roles via Docker
 async function backupCustomRoles(databaseUrl, backupDir) {
   try {
-    console.log(chalk.gray('   - Exportando Custom Roles...'));
+    console.log(chalk.gray('   - Exportando Custom Roles via Docker...'));
     
     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 execAsync(
-      `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 }] };
+    try {
+      // ✅ Usar Supabase CLI via Docker para roles
+      await execAsync(`supabase db dump --db-url "${databaseUrl}" --role-only -f "${customRolesFile}"`);
+      
+      const stats = fs.statSync(customRolesFile);
+      const sizeKB = (stats.size / 1024).toFixed(1);
+      
+      console.log(chalk.green(`     ✅ Custom Roles exportados via Docker: ${sizeKB} KB`));
+      
+      return { success: true, roles: [{ filename: 'custom-roles.sql', sizeKB }] };
+    } catch (error) {
+      console.log(chalk.yellow(`     ⚠️ Erro ao exportar Custom Roles via Docker: ${error.message}`));
+      return { success: false, roles: [] };
+    }
   } catch (error) {
-    console.log(chalk.yellow(`     ⚠️ Erro ao exportar Custom Roles: ${error.message}`));
+    console.log(chalk.yellow(`     ⚠️ Erro no backup dos Custom Roles: ${error.message}`));
     return { success: false, roles: [] };
   }
 }
 
-// Backup das Realtime Settings via SQL
-async function backupRealtimeSettings(databaseUrl, backupDir) {
+// Backup das Realtime Settings via Captura Interativa
+async function backupRealtimeSettings(projectId, backupDir, skipInteractive = false) {
   try {
-    console.log(chalk.gray('   - Exportando Realtime Settings...'));
+    console.log(chalk.gray('   - Capturando Realtime Settings interativamente...'));
     
-    const realtimeFile = path.join(backupDir, 'realtime-settings.sql');
+    const result = await captureRealtimeSettings(projectId, backupDir, skipInteractive);
     
-    // 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 execAsync(
-      `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 stats = fs.statSync(path.join(backupDir, 'realtime-settings.json'));
     const sizeKB = (stats.size / 1024).toFixed(1);
     
-    console.log(chalk.green(`     ✅ Realtime Settings exportados: ${sizeKB} KB`));
+    console.log(chalk.green(`     ✅ Realtime Settings capturadas: ${sizeKB} KB`));
     
-    return { success: true };
+    return { success: true, settings: result };
   } catch (error) {
-    console.log(chalk.yellow(`     ⚠️ Erro ao exportar Realtime Settings: ${error.message}`));
+    console.log(chalk.yellow(`     ⚠️ Erro ao capturar Realtime Settings: ${error.message}`));
     return { success: false };
   }
 }

package/src/utils/realtime-settings.js

@@ -0,0 +1,205 @@
+const readline = require('readline');
+const fs = require('fs').promises;
+const path = require('path');
+
+/**
+ * Captura configurações de Realtime Settings interativamente
+ * @param {string} projectId - ID do projeto Supabase
+ * @param {string} backupDir - Diretório do backup atual
+ * @param {boolean} skipInteractive - Se deve pular a etapa interativa
+ * @returns {Promise<Object>} Configurações capturadas
+ */
+async function captureRealtimeSettings(projectId, backupDir, skipInteractive = false) {
+  const settingsFile = path.join(backupDir, 'realtime-settings.json');
+  const dashboardUrl = `https://supabase.com/dashboard/project/${projectId}/realtime/settings`;
+  
+  // Tentar ler configurações de backup anterior
+  const previousSettings = await getPreviousRealtimeSettings(backupDir);
+  
+  if (skipInteractive && previousSettings) {
+    console.log('📋 Usando configurações de Realtime Settings do backup anterior...');
+    await fs.writeFile(settingsFile, JSON.stringify(previousSettings, null, 2));
+    return previousSettings;
+  }
+  
+  if (previousSettings && !skipInteractive) {
+    const shouldReuse = await askToReusePreviousSettings();
+    if (shouldReuse) {
+      console.log('📋 Reutilizando configurações de Realtime Settings do backup anterior...');
+      await fs.writeFile(settingsFile, JSON.stringify(previousSettings, null, 2));
+      return previousSettings;
+    }
+  }
+  
+  // Capturar configurações interativamente
+  console.log('\n🔧 Configurações de Realtime Settings');
+  console.log('═'.repeat(50));
+  console.log(`📱 Acesse: ${dashboardUrl}`);
+  console.log('📝 Anote os valores dos 4 parâmetros abaixo:\n');
+  
+  const settings = await captureSettingsInteractively(projectId, previousSettings);
+  
+  // Salvar configurações
+  await fs.writeFile(settingsFile, JSON.stringify(settings, null, 2));
+  console.log('\n✅ Configurações de Realtime Settings salvas!');
+  
+  return settings;
+}
+
+/**
+ * Busca configurações de backup anterior
+ * @param {string} backupDir - Diretório do backup atual
+ * @returns {Promise<Object|null>} Configurações anteriores ou null
+ */
+async function getPreviousRealtimeSettings(backupDir) {
+  try {
+    // Buscar em backups anteriores
+    const backupsDir = path.dirname(backupDir);
+    const entries = await fs.readdir(backupsDir, { withFileTypes: true });
+    const backupDirs = entries
+      .filter(entry => entry.isDirectory() && entry.name.startsWith('backup-'))
+      .map(entry => entry.name)
+      .sort()
+      .reverse(); // Mais recente primeiro
+    
+    for (const backupName of backupDirs) {
+      const settingsPath = path.join(backupsDir, backupName, 'realtime-settings.json');
+      try {
+        const content = await fs.readFile(settingsPath, 'utf8');
+        const settings = JSON.parse(content);
+        if (settings.realtime_settings && settings.realtime_settings.settings) {
+          return settings;
+        }
+      } catch (error) {
+        // Continuar para próximo backup
+        continue;
+      }
+    }
+    
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Pergunta se deve reutilizar configurações anteriores
+ * @returns {Promise<boolean>} true se deve reutilizar
+ */
+async function askToReusePreviousSettings() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  return new Promise((resolve) => {
+    rl.question('🔄 Foi identificada uma gravação anterior de Realtime Settings.\n   Deseja reutilizar as configurações anteriores? (S/n): ', (answer) => {
+      rl.close();
+      const shouldReuse = !answer.toLowerCase().startsWith('n');
+      resolve(shouldReuse);
+    });
+  });
+}
+
+/**
+ * Captura configurações interativamente via perguntas
+ * @param {string} projectId - ID do projeto Supabase
+ * @param {Object} previousSettings - Configurações anteriores para usar como padrão
+ * @returns {Promise<Object>} Configurações capturadas
+ */
+async function captureSettingsInteractively(projectId, previousSettings) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  const askQuestion = (question, defaultValue) => {
+    return new Promise((resolve) => {
+      rl.question(`${question} [${defaultValue}]: `, (answer) => {
+        resolve(answer.trim() || defaultValue);
+      });
+    });
+  };
+  
+  try {
+    console.log('📋 Responda as perguntas abaixo (pressione Enter para usar o valor padrão):\n');
+    
+    // Valores padrão baseados na imagem ou configurações anteriores
+    const defaults = previousSettings?.realtime_settings?.settings || {
+      allow_public_access: { value: true },
+      database_connection_pool_size: { value: 2 },
+      max_concurrent_clients: { value: 200 },
+      max_events_per_second: { value: 100 }
+    };
+    
+    const allowPublicAccess = await askQuestion(
+      '1. Allow public access (true/false):',
+      defaults.allow_public_access.value
+    );
+    
+    const poolSize = await askQuestion(
+      '2. Database connection pool size:',
+      defaults.database_connection_pool_size.value
+    );
+    
+    const maxClients = await askQuestion(
+      '3. Max concurrent clients:',
+      defaults.max_concurrent_clients.value
+    );
+    
+    const maxEvents = await askQuestion(
+      '4. Max events per second:',
+      defaults.max_events_per_second.value
+    );
+    
+    const settings = {
+      realtime_settings: {
+        note: "Configurações de Realtime Settings capturadas interativamente",
+        dashboard_url: `https://supabase.com/dashboard/project/${projectId}/realtime/settings`,
+        captured_at: new Date().toISOString(),
+        settings: {
+          allow_public_access: {
+            label: "Allow public access",
+            description: "If disabled, only private channels will be allowed",
+            value: allowPublicAccess === 'true'
+          },
+          database_connection_pool_size: {
+            label: "Database connection pool size",
+            description: "Realtime Authorization uses this database pool to check client access",
+            value: parseInt(poolSize)
+          },
+          max_concurrent_clients: {
+            label: "Max concurrent clients", 
+            description: "Sets maximum number of concurrent clients that can connect to your Realtime service",
+            value: parseInt(maxClients)
+          },
+          max_events_per_second: {
+            label: "Max events per second",
+            description: "Sets maximum number of events per second that can be sent to your Realtime service",
+            value: parseInt(maxEvents)
+          }
+        },
+        restore_instructions: {
+          url: `https://supabase.com/dashboard/project/${projectId}/realtime/settings`,
+          steps: [
+            "1. Acesse a URL acima",
+            "2. Configure 'Allow public access' conforme o valor em settings.allow_public_access.value",
+            "3. Configure 'Database connection pool size' conforme o valor em settings.database_connection_pool_size.value",
+            "4. Configure 'Max concurrent clients' conforme o valor em settings.max_concurrent_clients.value", 
+            "5. Configure 'Max events per second' conforme o valor em settings.max_events_per_second.value",
+            "6. Clique em 'Save changes'"
+          ]
+        }
+      }
+    };
+    
+    return settings;
+    
+  } finally {
+    rl.close();
+  }
+}
+
+module.exports = {
+  captureRealtimeSettings
+};