smoonb 0.0.47 → 0.0.48

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 (sqlError) {
+          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.entries(realtimeSettings.realtime_settings.settings).forEach(([key, 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 (error) {
+            // 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/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/supabaseLink.js

@@ -0,0 +1,82 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs').promises;
+const { execSync } = require('child_process');
+
+/**
+ * Extrai a senha da URL de conexão PostgreSQL
+ * @param {string} dbUrl - URL completa (postgresql://user:password@host:port/db)
+ * @returns {string} - Senha extraída
+ */
+function extractPasswordFromDbUrl(dbUrl) {
+  const urlMatch = dbUrl.match(/postgresql:\/\/([^:]+):([^@]+)@([^:]+):(\d+)\/(.+)/);
+  if (!urlMatch) {
+    throw new Error('Database URL inválida');
+  }
+  const [, , password] = urlMatch;
+  return password;
+}
+
+/**
+ * Garante que o projeto está corretamente linkado, removendo .temp e refazendo o link
+ * @param {string} projectRef - ID do projeto Supabase
+ * @param {string} accessToken - Token de acesso Supabase
+ * @param {string} dbPassword - Senha do banco de dados
+ * @returns {Promise<void>}
+ */
+async function ensureCleanLink(projectRef, accessToken, dbPassword) {
+  const tempDir = path.join(process.cwd(), 'supabase', '.temp');
+  
+  // Remover supabase/.temp completamente
+  console.log(chalk.gray(`   - Zerando vínculo e linkando projeto: ${projectRef}...`));
+  
+  try {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  } catch (error) {
+    // Ignorar erro se não existir
+  }
+  
+  // Executar supabase link com env local (não modificar process.env global)
+  const env = {
+    ...process.env,
+    SUPABASE_ACCESS_TOKEN: accessToken
+  };
+  
+  try {
+    execSync(`supabase link --project-ref ${projectRef} --password ${dbPassword}`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+      timeout: 15000,
+      env
+    });
+  } catch (error) {
+    throw new Error(`Falha ao linkar projeto ${projectRef}: ${error.message}`);
+  }
+  
+  // Validar: ler supabase/.temp/project-ref e verificar se == projectRef
+  const projectRefFile = path.join(tempDir, 'project-ref');
+  try {
+    const linkedRef = await fs.readFile(projectRefFile, 'utf8');
+    const linkedRefTrimmed = linkedRef.trim();
+    
+    if (linkedRefTrimmed !== projectRef) {
+      throw new Error(
+        `Validação falhou: linked-ref = ${linkedRefTrimmed} (esperado = ${projectRef}). ` +
+        `O projeto linkado não corresponde ao projeto esperado.`
+      );
+    }
+    
+    console.log(chalk.gray(`   - Validação: linked-ref = ${linkedRefTrimmed} (esperado = ${projectRef})`));
+  } catch (error) {
+    if (error.message.includes('Validação falhou')) {
+      throw error;
+    }
+    throw new Error(`Não foi possível validar o vínculo: ${error.message}`);
+  }
+}
+
+module.exports = {
+  extractPasswordFromDbUrl,
+  ensureCleanLink
+};
+