smoonb 0.0.47 → 0.0.49

package/src/commands/restore/steps/07-database-settings.js

@@ -0,0 +1,65 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+/**
+ * Etapa 7: Restaurar Database Settings (via SQL)
+ */
+module.exports = async ({ backupPath, targetProject }) => {
+  console.log(chalk.blue('\n🔧 Restaurando Database Settings...'));
+  
+  try {
+    const files = fs.readdirSync(backupPath);
+    const dbSettingsFile = files.find(f => f.startsWith('database-settings-') && f.endsWith('.json'));
+    
+    if (!dbSettingsFile) {
+      console.log(chalk.yellow('   ⚠️  Nenhuma configuração de Database encontrada no backup'));
+      return;
+    }
+    
+    const dbSettingsData = JSON.parse(fs.readFileSync(path.join(backupPath, dbSettingsFile), 'utf8'));
+    const dbSettings = dbSettingsData.database_settings || dbSettingsData;
+    
+    const extensions = dbSettings.extensions || [];
+    
+    if (extensions.length > 0) {
+      console.log(chalk.gray(`   - Habilitando ${extensions.length} extension(s)...`));
+      
+      for (const ext of extensions) {
+        const extName = typeof ext === 'string' ? ext : ext.name;
+        console.log(chalk.gray(`     - ${extName}`));
+        
+        const sqlCommand = `CREATE EXTENSION IF NOT EXISTS ${extName};`;
+        
+        const urlMatch = targetProject.targetDatabaseUrl.match(/postgresql:\/\/([^@:]+):([^@]+)@(.+)$/);
+        
+        if (!urlMatch) {
+          console.log(chalk.yellow(`     ⚠️  URL inválida para ${extName}`));
+          continue;
+        }
+        
+        const dockerCmd = [
+          'docker run --rm',
+          '--network host',
+          `-e PGPASSWORD="${encodeURIComponent(urlMatch[2])}"`,
+          'postgres:17 psql',
+          `-d "${targetProject.targetDatabaseUrl}"`,
+          `-c "${sqlCommand}"`
+        ].join(' ');
+        
+        try {
+          execSync(dockerCmd, { stdio: 'pipe', encoding: 'utf8' });
+        } catch {
+          console.log(chalk.yellow(`     ⚠️  ${extName} - extension já existe ou não pode ser habilitada`));
+        }
+      }
+    }
+    
+    console.log(chalk.green('   ✅ Database Settings restaurados com sucesso!'));
+    
+  } catch (error) {
+    console.error(chalk.red(`   ❌ Erro ao restaurar Database Settings: ${error.message}`));
+  }
+};
+

package/src/commands/restore/steps/08-realtime-settings.js

@@ -0,0 +1,50 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs');
+const inquirer = require('inquirer');
+
+/**
+ * Etapa 8: Restaurar Realtime Settings (interativo - exibir URL e valores)
+ */
+module.exports = async ({ backupPath, targetProject }) => {
+  console.log(chalk.blue('\n🔄 Restaurando Realtime Settings...'));
+  
+  try {
+    const realtimeSettingsPath = path.join(backupPath, 'realtime-settings.json');
+    
+    if (!fs.existsSync(realtimeSettingsPath)) {
+      console.log(chalk.yellow('   ⚠️  Nenhuma configuração de Realtime encontrada no backup'));
+      return;
+    }
+    
+    const realtimeSettings = JSON.parse(fs.readFileSync(realtimeSettingsPath, 'utf8'));
+    const dashboardUrl = `https://supabase.com/dashboard/project/${targetProject.targetProjectId}/realtime/settings`;
+    
+    console.log(chalk.green('\n   ✅ URL para configuração manual:'));
+    console.log(chalk.cyan(`   ${dashboardUrl}`));
+    console.log(chalk.yellow('\n   📋 Configure manualmente as seguintes opções:'));
+    
+    if (realtimeSettings.realtime_settings?.settings) {
+      Object.values(realtimeSettings.realtime_settings.settings).forEach((setting) => {
+        console.log(chalk.gray(`   - ${setting.label}: ${setting.value}`));
+        if (setting.description) {
+          console.log(chalk.gray(`     ${setting.description}`));
+        }
+      });
+    }
+    
+    console.log(chalk.yellow('\n   ⚠️  Após configurar, pressione Enter para continuar...'));
+    
+    await inquirer.prompt([{
+      type: 'input',
+      name: 'continue',
+      message: 'Pressione Enter para continuar'
+    }]);
+    
+    console.log(chalk.green('   ✅ Realtime Settings processados'));
+    
+  } catch (error) {
+    console.error(chalk.red(`   ❌ Erro ao processar Realtime Settings: ${error.message}`));
+  }
+};
+

package/src/commands/restore/utils.js

@@ -0,0 +1,139 @@
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Listar backups válidos (aceita .backup.gz e .backup)
+ */
+async function listValidBackups(backupsDir) {
+  if (!fs.existsSync(backupsDir)) {
+    return [];
+  }
+
+  const items = fs.readdirSync(backupsDir, { withFileTypes: true });
+  const validBackups = [];
+
+  for (const item of items) {
+    if (item.isDirectory() && item.name.startsWith('backup-')) {
+      const backupPath = path.join(backupsDir, item.name);
+      const files = fs.readdirSync(backupPath);
+      // Aceitar tanto .backup.gz quanto .backup
+      const backupFile = files.find(file => 
+        file.endsWith('.backup.gz') || file.endsWith('.backup')
+      );
+      
+      if (backupFile) {
+        const manifestPath = path.join(backupPath, 'backup-manifest.json');
+        let manifest = null;
+        
+        if (fs.existsSync(manifestPath)) {
+          try {
+            manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+          } catch {
+            // Ignorar erro de leitura do manifest
+          }
+        }
+
+        const stats = fs.statSync(path.join(backupPath, backupFile));
+        
+        validBackups.push({
+          name: item.name,
+          path: backupPath,
+          backupFile: backupFile,
+          created: manifest?.created_at || stats.birthtime.toISOString(),
+          projectId: manifest?.project_id || 'Desconhecido',
+          size: formatBytes(stats.size),
+          manifest: manifest
+        });
+      }
+    }
+  }
+
+  return validBackups.sort((a, b) => new Date(b.created) - new Date(a.created));
+}
+
+/**
+ * Formatar bytes
+ */
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 Bytes';
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+/**
+ * Mostrar resumo da restauração
+ */
+function showRestoreSummary(backup, components, targetProject) {
+  console.log(chalk.blue('\n📋 Resumo da Restauração:'));
+  console.log(chalk.blue('═'.repeat(80)));
+  console.log(chalk.cyan(`📦 Backup: ${backup.name}`));
+  console.log(chalk.cyan(`📤 Projeto Origem: ${backup.projectId}`));
+  console.log(chalk.cyan(`📥 Projeto Destino: ${targetProject.targetProjectId}`));
+  console.log('');
+  console.log(chalk.cyan('Componentes que serão restaurados:'));
+  console.log('');
+  
+  if (components.database) {
+    console.log('✅ Database (psql -f via Docker)');
+  }
+  
+  if (components.edgeFunctions) {
+    const edgeFunctionsDir = path.join(backup.path, 'edge-functions');
+    const functions = fs.readdirSync(edgeFunctionsDir).filter(item => 
+      fs.statSync(path.join(edgeFunctionsDir, item)).isDirectory()
+    );
+    console.log(`⚡ Edge Functions: ${functions.length} function(s)`);
+    functions.forEach(func => console.log(`   - ${func}`));
+  }
+  
+  if (components.authSettings) {
+    console.log('🔐 Auth Settings: Exibir URL e valores para configuração manual');
+  }
+  
+  if (components.storage) {
+    console.log('📦 Storage Buckets: Exibir informações e instruções do Google Colab');
+  }
+  
+  if (components.databaseSettings) {
+    console.log('🔧 Database Extensions and Settings: Restaurar via SQL');
+  }
+  
+  if (components.realtimeSettings) {
+    console.log('🔄 Realtime Settings: Exibir URL e valores para configuração manual');
+  }
+  
+  console.log('');
+}
+
+/**
+ * Função auxiliar para copiar diretório recursivamente
+ */
+async function copyDirectoryRecursive(src, dest) {
+  const fs = require('fs').promises;
+  
+  await fs.mkdir(dest, { recursive: true });
+  
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    
+    if (entry.isDirectory()) {
+      await copyDirectoryRecursive(srcPath, destPath);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}
+
+module.exports = {
+  listValidBackups,
+  formatBytes,
+  showRestoreSummary,
+  copyDirectoryRecursive
+};
+

package/src/index.js

@@ -125,7 +125,7 @@ function checkPrerequisites() {
     const { execSync } = require('child_process');
     const npmVersion = execSync('npm --version', { encoding: 'utf8' }).trim();
     prerequisites.npm = { installed: true, version: npmVersion };
-  } catch (error) {
+  } catch {
     prerequisites.npm = { installed: false, version: null };
   }
 
@@ -134,7 +134,7 @@ function checkPrerequisites() {
     const { execSync } = require('child_process');
     const supabaseVersion = execSync('supabase --version', { encoding: 'utf8' }).trim();
     prerequisites.supabase_cli = { installed: true, version: supabaseVersion };
-  } catch (error) {
+  } catch {
     prerequisites.supabase_cli = { installed: false, version: null };
   }
 
@@ -143,7 +143,7 @@ function checkPrerequisites() {
     const { execSync } = require('child_process');
     const pgDumpVersion = execSync('pg_dump --version', { encoding: 'utf8' }).trim();
     prerequisites.pg_dump = { installed: true, version: pgDumpVersion };
-  } catch (error) {
+  } catch {
     prerequisites.pg_dump = { installed: false, version: null };
   }
 

package/src/interactive/envMapper.js

@@ -1,5 +1,6 @@
 const inquirer = require('inquirer');
 const chalk = require('chalk');
+const { confirm } = require('../utils/prompt');
 
 async function mapEnvVariablesInteractively(env, expectedKeys) {
   const finalEnv = { ...env };
@@ -47,13 +48,7 @@ async function mapEnvVariablesInteractively(env, expectedKeys) {
     }
 
     const currentValue = finalEnv[clientKey] ?? '';
-    const { isCorrect } = await inquirer.prompt([{
-      type: 'confirm',
-      name: 'isCorrect',
-      message: `Valor atual: ${currentValue || '(vazio)'} Este é o valor correto do projeto alvo? (S/n):`,
-      default: true,
-      prefix: ''
-    }]);
+    const isCorrect = await confirm(`Valor atual: ${currentValue || '(vazio)'}\nEste é o valor correto do projeto alvo?`, true);
 
     let valueToWrite = currentValue;
     if (!isCorrect) {
@@ -87,13 +82,42 @@ async function mapEnvVariablesInteractively(env, expectedKeys) {
 }
 
 async function askComponentsFlags() {
-  const answers = await inquirer.prompt([
-    { type: 'confirm', name: 'includeFunctions', message: 'Deseja incluir Edge Functions (S/n):', default: true },
-    { type: 'confirm', name: 'includeStorage', message: 'Deseja incluir Storage (s/N):', default: false },
-    { type: 'confirm', name: 'includeAuth', message: 'Deseja incluir Auth (s/N):', default: false },
-    { type: 'confirm', name: 'includeRealtime', message: 'Deseja incluir Realtime (s/N):', default: false }
-  ]);
-  return answers;
+  // Explicação sobre Edge Functions
+  console.log(chalk.cyan('\n⚡ Edge Functions:'));
+  console.log(chalk.gray('   Vamos apagar as funções existentes na pasta supabase/functions, fazer um reset no link'));
+  console.log(chalk.gray('   entre a ferramenta e o projeto, e baixar novamente as funções do servidor.'));
+  console.log(chalk.gray('   Você terá a opção de manter ou apagar as funções na pasta após o backup.\n'));
+
+  const includeFunctions = await confirm('Deseja incluir Edge Functions', true);
+
+  // Explicação sobre .temp
+  console.log(chalk.cyan('\n📁 Supabase .temp:'));
+  console.log(chalk.gray('   Vamos copiar os arquivos existentes (se existirem) na pasta supabase/.temp.'));
+  console.log(chalk.gray('   Você terá a opção de manter ou apagar os arquivos nesta pasta após o backup.\n'));
+
+  // Explicação sobre Migrations
+  console.log(chalk.cyan('\n📋 Migrations:'));
+  console.log(chalk.gray('   Vamos apagar as migrations existentes (se existirem) na pasta supabase/migrations,'));
+  console.log(chalk.gray('   fazer um reset no link entre a ferramenta e o projeto, e baixar novamente as migrations'));
+  console.log(chalk.gray('   do servidor. Você terá a opção de manter ou apagar as migrations na pasta após o backup.\n'));
+
+  // Continuar com outras perguntas
+  const includeStorage = await confirm('Deseja incluir Storage', true);
+  const includeAuth = await confirm('Deseja incluir Auth', true);
+  const includeRealtime = await confirm('Deseja incluir Realtime', true);
+  const cleanFunctions = await confirm('Deseja limpar supabase/functions após o backup', false);
+  const cleanTemp = await confirm('Deseja apagar supabase/.temp após o backup', false);
+  const cleanMigrations = await confirm('Deseja apagar supabase/migrations após o backup', false);
+
+  return {
+    includeFunctions,
+    includeStorage,
+    includeAuth,
+    includeRealtime,
+    cleanFunctions,
+    cleanTemp,
+    cleanMigrations
+  };
 }
 
 module.exports = {

package/src/utils/cli.js

@@ -13,7 +13,7 @@ async function ensureBin(name) {
     const { stdout } = await exec(command);
     const path = stdout.trim().split('\n')[0];
     return path || null;
-  } catch (error) {
+  } catch {
     return null;
   }
 }

package/src/utils/config.js

@@ -13,16 +13,14 @@ async function readConfig() {
   ];
 
   let configContent = null;
-  let configPath = null;
 
   for (const configPathCandidate of configPaths) {
     try {
       if (fs.existsSync(configPathCandidate)) {
         configContent = fs.readFileSync(configPathCandidate, 'utf8');
-        configPath = configPathCandidate;
         break;
       }
-    } catch (error) {
+    } catch {
       // Continue para próximo caminho
     }
   }

package/src/utils/docker.js

@@ -12,7 +12,7 @@ async function detectDockerInstallation() {
     // Tentar executar docker --version
     await execAsync('docker --version');
     return { installed: true, running: false }; // Instalado mas não sabemos se está rodando
-  } catch (error) {
+  } catch {
     return { installed: false, running: false };
   }
 }
@@ -26,7 +26,7 @@ async function detectDockerRunning() {
     // Tentar executar docker ps
     await execAsync('docker ps');
     return true;
-  } catch (error) {
+  } catch {
     return false;
   }
 }
@@ -40,7 +40,7 @@ async function detectSupabaseCLI() {
     // Tentar executar supabase --version
     await execAsync('supabase --version');
     return true;
-  } catch (error) {
+  } catch {
     return false;
   }
 }

package/src/utils/env.js

@@ -1,4 +1,3 @@
-const fs = require('fs');
 const fsp = require('fs').promises;
 const path = require('path');
 
@@ -27,7 +26,7 @@ function stringifyEnv(entries, existingContent) {
   const seen = new Set();
   const resultLines = [];
 
-  for (let line of existingLines) {
+  for (const line of existingLines) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith('#') || !trimmed.includes('=')) {
       resultLines.push(line);
@@ -70,7 +69,7 @@ async function readEnvFile(filePath) {
   }
 }
 
-async function writeEnvFile(filePath, entries, options = {}) {
+async function writeEnvFile(filePath, entries, _options = {}) {
   const dir = path.dirname(filePath);
   await fsp.mkdir(dir, { recursive: true });
   let existing = '';

package/src/utils/envMap.js

@@ -6,7 +6,7 @@ async function loadEnvMap(filePath) {
   try {
     const content = await fs.readFile(filePath, 'utf8');
     return JSON.parse(content);
-  } catch (e) {
+  } catch {
     return {};
   }
 }

package/src/utils/fsExtra.js

@@ -0,0 +1,98 @@
+const fs = require('fs').promises;
+const path = require('path');
+
+/**
+ * Copia um diretório de forma segura (retorna 0 se src não existir)
+ * @param {string} src - Diretório origem
+ * @param {string} dest - Diretório destino
+ * @returns {Promise<number>} - Quantidade de arquivos copiados (0 se src não existir)
+ */
+async function copyDirSafe(src, dest) {
+  try {
+    await fs.access(src);
+  } catch {
+    return 0; // Diretório não existe, retornar 0
+  }
+  
+  const stats = await fs.stat(src);
+  if (!stats.isDirectory()) {
+    return 0; // Não é diretório
+  }
+  
+  // Criar diretório destino
+  await fs.mkdir(dest, { recursive: true });
+  
+  // Contar e copiar arquivos
+  let count = 0;
+  const entries = await fs.readdir(src);
+  
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry);
+    const destPath = path.join(dest, entry);
+    
+    const entryStats = await fs.stat(srcPath);
+    if (entryStats.isDirectory()) {
+      count += await copyDirSafe(srcPath, destPath);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+      count++;
+    }
+  }
+  
+  return count;
+}
+
+/**
+ * Limpa um diretório completamente (rm -rf) e recria (mkdir -p)
+ * @param {string} dir - Diretório a limpar
+ * @returns {Promise<void>}
+ */
+async function cleanDir(dir) {
+  try {
+    await fs.rm(dir, { recursive: true, force: true });
+  } catch {
+    // Ignorar erro se não existir
+  }
+  await fs.mkdir(dir, { recursive: true });
+}
+
+/**
+ * Conta arquivos em um diretório recursivamente
+ * @param {string} dir - Diretório a contar
+ * @returns {Promise<number>} - Número de arquivos (0 se não existir)
+ */
+async function countFiles(dir) {
+  try {
+    await fs.access(dir);
+  } catch {
+    return 0;
+  }
+  
+  const stats = await fs.stat(dir);
+  if (!stats.isDirectory()) {
+    return 1; // É um arquivo
+  }
+  
+  let count = 0;
+  const entries = await fs.readdir(dir);
+  
+  for (const entry of entries) {
+    const entryPath = path.join(dir, entry);
+    const entryStats = await fs.stat(entryPath);
+    
+    if (entryStats.isDirectory()) {
+      count += await countFiles(entryPath);
+    } else {
+      count++;
+    }
+  }
+  
+  return count;
+}
+
+module.exports = {
+  copyDirSafe,
+  cleanDir,
+  countFiles
+};
+

package/src/utils/fsx.js

@@ -14,13 +14,13 @@ async function copyDir(src, dest) {
       await fs.promises.cp(src, dest, { recursive: true });
       return;
     }
-  } catch (error) {
+  } catch {
     // Fallback para fs-extra se disponível
     try {
       const fse = require('fs-extra');
       await fse.copy(src, dest);
       return;
-    } catch (fseError) {
+    } catch {
       // Fallback manual usando fs nativo
     }
   }

package/src/utils/prompt.js

@@ -0,0 +1,34 @@
+const readline = require('readline');
+
+/**
+ * Função helper para fazer perguntas de confirmação customizadas
+ * Mostra (S/n) ou (s/N) em português em vez de (Y/n) ou (y/N)
+ */
+async function confirm(question, defaultYes = true) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const promptText = defaultYes ? '(S/n)' : '(s/N)';
+  const fullQuestion = `${question} ${promptText}: `;
+
+  return new Promise((resolve) => {
+    rl.question(fullQuestion, (answer) => {
+      rl.close();
+      
+      if (!answer || answer.trim() === '') {
+        resolve(defaultYes);
+        return;
+      }
+
+      const normalized = answer.trim().toLowerCase();
+      resolve(normalized === 's' || normalized === 'sim' || normalized === 'y' || normalized === 'yes');
+    });
+  });
+}
+
+module.exports = {
+  confirm
+};
+

package/src/utils/realtime-settings.js

@@ -70,14 +70,14 @@ async function getPreviousRealtimeSettings(backupDir) {
         if (settings.realtime_settings && settings.realtime_settings.settings) {
           return settings;
         }
-      } catch (error) {
+      } catch {
         // Continuar para próximo backup
         continue;
       }
     }
     
     return null;
-  } catch (error) {
+  } catch {
     return null;
   }
 }

package/src/utils/supabase.js

@@ -43,7 +43,7 @@ function findPgDumpPath() {
       } else if (fs.existsSync(pgPath)) {
         return pgPath;
       }
-    } catch (error) {
+    } catch {
       // Continuar para o próximo caminho
       continue;
     }
@@ -244,10 +244,10 @@ async function testConnection() {
     const client = getSupabaseClient();
     
     // Tentar uma operação simples
-    const { data, error } = await client.from('_smoonb_test').select('*').limit(1);
+    const { error: testError } = await client.from('_smoonb_test').select('*').limit(1);
     
-    if (error && error.code !== 'PGRST116') { // PGRST116 = tabela não existe (esperado)
-      throw error;
+    if (testError && testError.code !== 'PGRST116') { // PGRST116 = tabela não existe (esperado)
+      throw testError;
     }
     
     return { success: true, message: 'Conexão estabelecida com sucesso' };
@@ -261,7 +261,7 @@ async function testConnection() {
  */
 async function getProjectInfo(projectId) {
   try {
-    const client = getSupabaseClient();
+    getSupabaseClient(); // Garantir que cliente está disponível
     
     // TODO: Implementar busca real de informações do projeto
     // Por enquanto, retornar informações básicas
@@ -292,7 +292,7 @@ async function listTables() {
     }
     
     return data || [];
-  } catch (error) {
+  } catch {
     // Fallback: tentar query direta
     try {
       const { data, error } = await client
@@ -326,7 +326,7 @@ async function listExtensions() {
     }
     
     return data || [];
-  } catch (error) {
+  } catch {
     // Fallback: tentar query direta
     try {
       const { data, error } = await client
@@ -349,7 +349,7 @@ async function listExtensions() {
  */
 async function getAuthSettings() {
   try {
-    const client = getSupabaseClient();
+    getSupabaseClient(); // Garantir que cliente está disponível
     
     // TODO: Implementar busca real de configurações de Auth
     // Por enquanto, retornar estrutura básica
@@ -383,7 +383,7 @@ async function getStorageSettings() {
     // Para cada bucket, listar objetos
     const bucketsWithObjects = [];
     for (const bucket of buckets) {
-      const { data: objects, error: objectsError } = await client.storage
+      const { data: objects } = await client.storage
         .from(bucket.name)
         .list();
       
@@ -408,7 +408,7 @@ async function getStorageSettings() {
  */
 async function getRealtimeSettings() {
   try {
-    const client = getSupabaseClient();
+    getSupabaseClient(); // Garantir que cliente está disponível
     
     // TODO: Implementar busca real de configurações de Realtime
     // Por enquanto, retornar estrutura básica