smoonb 0.0.42 → 0.0.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoonb",
-  "version": "0.0.42",
+  "version": "0.0.45",
   "description": "Complete Supabase backup and migration tool - EXPERIMENTAL VERSION - USE AT YOUR OWN RISK",
   "preferGlobal": false,
   "preventGlobalInstall": true,

package/src/commands/restore.js

@@ -89,7 +89,7 @@ module.exports = async (options) => {
   }
 };
 
-// Listar backups válidos (apenas com .backup.gz)
+// Listar backups válidos (aceita .backup.gz e .backup)
 async function listValidBackups(backupsDir) {
   if (!fs.existsSync(backupsDir)) {
     return [];
@@ -102,7 +102,10 @@ async function listValidBackups(backupsDir) {
     if (item.isDirectory() && item.name.startsWith('backup-')) {
       const backupPath = path.join(backupsDir, item.name);
       const files = fs.readdirSync(backupPath);
-      const backupFile = files.find(file => file.endsWith('.backup.gz'));
+      // 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');
@@ -184,7 +187,7 @@ async function askRestoreComponents(backupPath) {
   questions.push({
     type: 'confirm',
     name: 'restoreDatabase',
-    message: 'Deseja restaurar Database?',
+    message: 'Deseja restaurar Database (S/n):',
     default: true
   });
   
@@ -194,7 +197,7 @@ async function askRestoreComponents(backupPath) {
     questions.push({
       type: 'confirm',
       name: 'restoreEdgeFunctions',
-      message: 'Deseja restaurar Edge Functions?',
+      message: 'Deseja restaurar Edge Functions (S/n):',
       default: true
     });
   }
@@ -204,8 +207,8 @@ async function askRestoreComponents(backupPath) {
     questions.push({
       type: 'confirm',
       name: 'restoreAuthSettings',
-      message: 'Deseja restaurar Auth Settings (interativo)?',
-      default: true
+      message: 'Deseja restaurar Auth Settings (s/N):',
+      default: false
     });
   }
   
@@ -215,7 +218,7 @@ async function askRestoreComponents(backupPath) {
     questions.push({
       type: 'confirm',
       name: 'restoreStorage',
-      message: 'Deseja ver informações de Storage Buckets?',
+      message: 'Deseja ver informações de Storage Buckets (s/N):',
       default: false
     });
   }
@@ -227,7 +230,7 @@ async function askRestoreComponents(backupPath) {
     questions.push({
       type: 'confirm',
       name: 'restoreDatabaseSettings',
-      message: 'Deseja restaurar Database Extensions and Settings?',
+      message: 'Deseja restaurar Database Extensions and Settings (s/N):',
       default: false
     });
   }
@@ -237,8 +240,8 @@ async function askRestoreComponents(backupPath) {
     questions.push({
       type: 'confirm',
       name: 'restoreRealtimeSettings',
-      message: 'Deseja restaurar Realtime Settings (interativo)?',
-      default: true
+      message: 'Deseja restaurar Realtime Settings (s/N):',
+      default: false
     });
   }
   
@@ -313,9 +316,9 @@ async function confirmExecution() {
 }
 
 // Restaurar Database via psql (conforme documentação oficial Supabase: https://supabase.com/docs/guides/platform/migrating-within-supabase/dashboard-restore)
+// Aceita tanto arquivos .backup.gz quanto .backup já descompactados
 async function restoreDatabaseGz(backupFilePath, targetDatabaseUrl) {
   console.log(chalk.blue('📊 Restaurando Database...'));
-  console.log(chalk.gray('   - Descompactando backup (se necessário)...'));
   
   try {
     const { execSync } = require('child_process');
@@ -324,9 +327,11 @@ async function restoreDatabaseGz(backupFilePath, targetDatabaseUrl) {
     const fileName = path.basename(backupFilePath);
     let uncompressedFile = fileName;
     
-    // Descompactar .gz se necessário
-    if (fileName.endsWith('.gz')) {
+    // Verificar se é arquivo .backup.gz (compactado) ou .backup (descompactado)
+    if (fileName.endsWith('.backup.gz')) {
+      console.log(chalk.gray('   - Arquivo .backup.gz detectado'));
       console.log(chalk.gray('   - Extraindo arquivo .gz...'));
+      
       const unzipCmd = [
         'docker run --rm',
         `-v "${backupDirAbs}:/host"`,
@@ -336,6 +341,11 @@ async function restoreDatabaseGz(backupFilePath, targetDatabaseUrl) {
       execSync(unzipCmd, { stdio: 'pipe' });
       uncompressedFile = fileName.replace('.gz', '');
       console.log(chalk.gray('   - Arquivo descompactado: ' + uncompressedFile));
+    } else if (fileName.endsWith('.backup')) {
+      console.log(chalk.gray('   - Arquivo .backup detectado (já descompactado)'));
+      console.log(chalk.gray('   - Prosseguindo com restauração direta'));
+    } else {
+      throw new Error(`Formato de arquivo inválido. Esperado .backup.gz ou .backup, recebido: ${fileName}`);
     }
     
     // Extrair credenciais da URL de conexão
@@ -391,17 +401,25 @@ async function restoreEdgeFunctions(backupPath, targetProject) {
   console.log(chalk.blue('\n⚡ Restaurando Edge Functions...'));
   
   try {
+    const fs = require('fs').promises;
     const { execSync } = require('child_process');
     const edgeFunctionsDir = path.join(backupPath, 'edge-functions');
     
-    if (!fs.existsSync(edgeFunctionsDir)) {
+    if (!await fs.access(edgeFunctionsDir).then(() => true).catch(() => false)) {
       console.log(chalk.yellow('   ⚠️  Nenhuma Edge Function encontrada no backup'));
       return;
     }
     
-    const functions = fs.readdirSync(edgeFunctionsDir).filter(item => 
-      fs.statSync(path.join(edgeFunctionsDir, item)).isDirectory()
-    );
+    const items = await fs.readdir(edgeFunctionsDir);
+    const functions = [];
+    
+    for (const item of items) {
+      const itemPath = path.join(edgeFunctionsDir, item);
+      const stats = await fs.stat(itemPath);
+      if (stats.isDirectory()) {
+        functions.push(item);
+      }
+    }
     
     if (functions.length === 0) {
       console.log(chalk.yellow('   ⚠️  Nenhuma Edge Function encontrada no backup'));
@@ -410,29 +428,55 @@ async function restoreEdgeFunctions(backupPath, targetProject) {
     
     console.log(chalk.gray(`   - Encontradas ${functions.length} Edge Function(s)`));
     
-    // Link com projeto target
+    // ✅ COPIAR Edge Functions de backups/backup-XXX/edge-functions para supabase/functions
+    const supabaseFunctionsDir = path.join(process.cwd(), 'supabase', 'functions');
+    
+    // Criar diretório supabase/functions se não existir
+    await fs.mkdir(supabaseFunctionsDir, { recursive: true });
+    
+    // Limpar supabase/functions antes de copiar
+    console.log(chalk.gray('   - Limpando supabase/functions...'));
+    try {
+      await fs.rm(supabaseFunctionsDir, { recursive: true, force: true });
+      await fs.mkdir(supabaseFunctionsDir, { recursive: true });
+    } catch (cleanError) {
+      // Ignorar erro de limpeza se não existir
+    }
+    
+    // Copiar cada Edge Function para supabase/functions
+    for (const funcName of functions) {
+      const backupFuncPath = path.join(edgeFunctionsDir, funcName);
+      const targetFuncPath = path.join(supabaseFunctionsDir, funcName);
+      
+      console.log(chalk.gray(`   - Copiando ${funcName} para supabase/functions...`));
+      
+      // Copiar recursivamente
+      await copyDirectoryRecursive(backupFuncPath, targetFuncPath);
+    }
+    
     console.log(chalk.gray(`   - Linkando com projeto ${targetProject.targetProjectId}...`));
     
+    // Linkar com o projeto destino
     try {
       execSync(`supabase link --project-ref ${targetProject.targetProjectId}`, {
         stdio: 'pipe',
-        encoding: 'utf8'
+        encoding: 'utf8',
+        timeout: 10000
       });
     } catch (linkError) {
-      console.log(chalk.yellow(`   ⚠️  Link pode já existir, continuando...`));
+      console.log(chalk.yellow('   ⚠️  Link pode já existir, continuando...'));
     }
     
-    // Deploy de cada função
+    // Deploy das Edge Functions
     for (const funcName of functions) {
       console.log(chalk.gray(`   - Deployando ${funcName}...`));
       
       try {
-        const functionPath = path.join(edgeFunctionsDir, funcName);
-        
         execSync(`supabase functions deploy ${funcName}`, {
-          cwd: functionPath,
+          cwd: process.cwd(),
           stdio: 'pipe',
-          encoding: 'utf8'
+          encoding: 'utf8',
+          timeout: 120000
         });
         
         console.log(chalk.green(`   ✅ ${funcName} deployada com sucesso!`));
@@ -441,11 +485,41 @@ async function restoreEdgeFunctions(backupPath, targetProject) {
       }
     }
     
+    // Limpar supabase/functions após deploy
+    console.log(chalk.gray('   - Limpando supabase/functions após deploy...'));
+    try {
+      await fs.rm(supabaseFunctionsDir, { recursive: true, force: true });
+    } catch (cleanError) {
+      // Ignorar erro de limpeza
+    }
+    
+    console.log(chalk.green('   ✅ Edge Functions restauradas com sucesso!'));
+    
   } catch (error) {
     console.error(chalk.red(`   ❌ Erro ao restaurar Edge Functions: ${error.message}`));
   }
 }
 
+// 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);
+    }
+  }
+}
+
 // Restaurar Storage Buckets (interativo - exibir informações)
 async function restoreStorageBuckets(backupPath, targetProject) {
   console.log(chalk.blue('\n📦 Restaurando Storage Buckets...'));