smoonb 0.0.14 → 0.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoonb",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "Complete Supabase backup and migration tool - EXPERIMENTAL VERSION - USE AT YOUR OWN RISK",
   "main": "index.js",
   "bin": {

package/src/commands/backup.js

@@ -256,66 +256,104 @@ async function backupDatabaseWithPgDump(databaseUrl, backupDir, pgDumpPath) {
 // Backup das Edge Functions via Supabase API
 async function backupEdgeFunctions(config, backupDir) {
   try {
-    const supabase = createClient(config.supabase.url, config.supabase.serviceKey);
     const functionsDir = path.join(backupDir, 'edge-functions');
     await ensureDir(functionsDir);
 
-    console.log(chalk.gray('   - Listando Edge Functions...'));
+    console.log(chalk.gray('   - Listando Edge Functions via Management API...'));
     
-    // Listar Edge Functions via API
-    const { data: functions, error } = await supabase.functions.list();
+    // ✅ Usar fetch direto para Management API
+    const functionsResponse = await fetch(`https://api.supabase.com/v1/projects/${config.supabase.projectId}/functions`, {
+      headers: { 
+        'Authorization': `Bearer ${config.supabase.serviceKey}`, 
+        'apikey': config.supabase.serviceKey,
+        'Content-Type': 'application/json'
+      }
+    });
     
-    if (error) {
-      console.log(chalk.yellow(`     ⚠️ Erro ao listar Edge Functions: ${error.message}`));
+    if (!functionsResponse.ok) {
+      console.log(chalk.yellow(`     ⚠️ Erro ao listar Edge Functions: ${functionsResponse.status} ${functionsResponse.statusText}`));
       return { success: false, functions: [] };
     }
 
+    const functions = await functionsResponse.json();
+    
+    if (!functions || functions.length === 0) {
+      console.log(chalk.gray('   - Nenhuma Edge Function encontrada'));
+      await writeJson(path.join(functionsDir, 'README.md'), {
+        message: 'Nenhuma Edge Function encontrada neste projeto'
+      });
+      return { success: true, functions: [] };
+    }
+
+    console.log(chalk.gray(`   - Encontradas ${functions.length} Edge Functions`));
+    
     const downloadedFunctions = [];
 
-    for (const func of functions || []) {
+    // ✅ Baixar todas as functions encontradas
+    for (const func of functions) {
       try {
-        console.log(chalk.gray(`   - Baixando function: ${func.name}`));
+        console.log(chalk.gray(`   - Baixando: ${func.name}`));
         
-        // Criar diretório para a function
-        const funcDir = path.join(functionsDir, func.name);
-        await ensureDir(funcDir);
-
-        // Baixar código da function via API
-        const { data: functionCode, error: codeError } = await supabase.functions.getEdgeFunction(func.name);
+        // ✅ Baixar código da function via Management API
+        const functionResponse = await fetch(`https://api.supabase.com/v1/projects/${config.supabase.projectId}/functions/${func.name}`, {
+          headers: { 
+            'Authorization': `Bearer ${config.supabase.serviceKey}`, 
+            'apikey': config.supabase.serviceKey,
+            'Content-Type': 'application/json'
+          }
+        });
         
-        if (codeError) {
-          console.log(chalk.yellow(`     ⚠️ Erro ao baixar ${func.name}: ${codeError.message}`));
+        if (!functionResponse.ok) {
+          console.log(chalk.yellow(`     ⚠️ Erro ao baixar ${func.name}: ${functionResponse.status} ${functionResponse.statusText}`));
           continue;
         }
 
-        // Salvar arquivos da function
-        if (functionCode) {
-          // Salvar index.ts
-          const indexPath = path.join(funcDir, 'index.ts');
-          await fs.promises.writeFile(indexPath, functionCode.code || '// Function code not available');
+        const functionData = await functionResponse.json();
+
+        // ✅ Salvar arquivos dinamicamente
+        const funcDir = path.join(functionsDir, func.name);
+        await ensureDir(funcDir);
 
-          // Salvar deno.json se disponível
-          if (functionCode.deno_config) {
+        // ✅ Salvar cada arquivo da function
+        if (functionData && functionData.files) {
+          for (const file of functionData.files) {
+            const fileName = path.basename(file.name);
+            const filePath = path.join(funcDir, fileName);
+            await fs.promises.writeFile(filePath, file.content);
+          }
+        } else if (functionData && functionData.code) {
+          // Fallback para estrutura simples
+          const indexPath = path.join(funcDir, 'index.ts');
+          await fs.promises.writeFile(indexPath, functionData.code);
+          
+          if (functionData.deno_config) {
             const denoPath = path.join(funcDir, 'deno.json');
-            await writeJson(denoPath, functionCode.deno_config);
+            await writeJson(denoPath, functionData.deno_config);
           }
+        } else {
+          // Criar arquivo placeholder se não houver código
+          const indexPath = path.join(funcDir, 'index.ts');
+          await fs.promises.writeFile(indexPath, `// Edge Function: ${func.name}\n// Code not available via API\n`);
+        }
 
-          downloadedFunctions.push({
-            name: func.name,
-            version: func.version,
-            files: ['index.ts', 'deno.json'].filter(file => fs.existsSync(path.join(funcDir, file)))
-          });
+        downloadedFunctions.push({
+          name: func.name,
+          slug: func.name,
+          version: func.version || 'unknown',
+          files: fs.existsSync(funcDir) ? fs.readdirSync(funcDir) : []
+        });
 
-          console.log(chalk.green(`     ✅ ${func.name} baixada`));
-        }
+        console.log(chalk.green(`     ✅ ${func.name} baixada`));
       } catch (error) {
-        console.log(chalk.yellow(`     ⚠️ Erro ao processar ${func.name}: ${error.message}`));
+        console.log(chalk.yellow(`     ⚠️ Erro ao baixar ${func.name}: ${error.message}`));
       }
     }
 
+    console.log(chalk.green(`✅ Edge Functions backupadas: ${downloadedFunctions.length} functions`));
     return { success: true, functions: downloadedFunctions };
+
   } catch (error) {
-    console.log(chalk.yellow(`⚠️ Erro no backup das Edge Functions: ${error.message}`));
+    console.log(chalk.yellow(`   ⚠️ Erro no backup das Edge Functions: ${error.message}`));
     return { success: false, functions: [] };
   }
 }
@@ -323,31 +361,37 @@ async function backupEdgeFunctions(config, backupDir) {
 // Backup das Auth Settings via Management API
 async function backupAuthSettings(config, backupDir) {
   try {
-    console.log(chalk.gray('   - Exportando configurações de Auth...'));
+    console.log(chalk.gray('   - Exportando configurações de Auth via Management API...'));
     
-    // Usar Management API para obter configurações de Auth
-    const authSettingsPath = path.join(backupDir, 'auth-settings.json');
+    // ✅ Usar fetch direto para Management API
+    const authResponse = await fetch(`https://api.supabase.com/v1/projects/${config.supabase.projectId}/auth/settings`, {
+      headers: { 
+        'Authorization': `Bearer ${config.supabase.serviceKey}`, 
+        'apikey': config.supabase.serviceKey,
+        'Content-Type': 'application/json'
+      }
+    });
     
-    const authSettings = {
+    if (!authResponse.ok) {
+      console.log(chalk.yellow(`     ⚠️ Erro ao obter Auth Settings: ${authResponse.status} ${authResponse.statusText}`));
+      return { success: false };
+    }
+
+    const authSettings = await authResponse.json();
+    
+    // Salvar configurações de Auth
+    const authSettingsPath = path.join(backupDir, 'auth-settings.json');
+    await writeJson(authSettingsPath, {
       project_id: config.supabase.projectId,
       timestamp: new Date().toISOString(),
-      settings: {
-        // Configurações básicas que podemos obter
-        site_url: config.supabase.url,
-        jwt_secret: 'REDACTED', // Não expor secret
-        smtp_settings: null,
-        rate_limits: null,
-        email_templates: null
-      },
-      note: 'Configurações completas requerem acesso ao Management API'
-    };
+      settings: authSettings
+    });
 
-    await writeJson(authSettingsPath, authSettings);
-    console.log(chalk.green('     ✅ Auth Settings exportadas'));
-    
+    console.log(chalk.green(`✅ Auth Settings exportadas: ${path.basename(authSettingsPath)}`));
     return { success: true };
+
   } catch (error) {
-    console.log(chalk.yellow(`     ⚠️ Erro ao exportar Auth Settings: ${error.message}`));
+    console.log(chalk.yellow(`   ⚠️ Erro no backup das Auth Settings: ${error.message}`));
     return { success: false };
   }
 }
@@ -355,30 +399,54 @@ async function backupAuthSettings(config, backupDir) {
 // Backup do Storage via Supabase API
 async function backupStorage(config, backupDir) {
   try {
-    const supabase = createClient(config.supabase.url, config.supabase.serviceKey);
     const storageDir = path.join(backupDir, 'storage');
     await ensureDir(storageDir);
 
-    console.log(chalk.gray('   - Listando buckets de Storage...'));
+    console.log(chalk.gray('   - Listando buckets de Storage via Management API...'));
     
-    // Listar buckets
-    const { data: buckets, error } = await supabase.storage.listBuckets();
+    // ✅ Usar fetch direto para Management API
+    const storageResponse = await fetch(`https://api.supabase.com/v1/projects/${config.supabase.projectId}/storage/buckets`, {
+      headers: { 
+        'Authorization': `Bearer ${config.supabase.serviceKey}`, 
+        'apikey': config.supabase.serviceKey,
+        'Content-Type': 'application/json'
+      }
+    });
     
-    if (error) {
-      console.log(chalk.yellow(`     ⚠️ Erro ao listar buckets: ${error.message}`));
+    if (!storageResponse.ok) {
+      console.log(chalk.yellow(`     ⚠️ Erro ao listar buckets: ${storageResponse.status} ${storageResponse.statusText}`));
       return { success: false, buckets: [] };
     }
 
-    const processedBuckets = [];
+    const buckets = await storageResponse.json();
+
+    if (!buckets || buckets.length === 0) {
+      console.log(chalk.gray('   - Nenhum bucket encontrado'));
+      await writeJson(path.join(storageDir, 'README.md'), {
+        message: 'Nenhum bucket de Storage encontrado neste projeto'
+      });
+      return { success: true, buckets: [] };
+    }
+
+    console.log(chalk.gray(`   - Encontrados ${buckets.length} buckets`));
 
     for (const bucket of buckets || []) {
       try {
         console.log(chalk.gray(`   - Processando bucket: ${bucket.name}`));
         
-        // Listar objetos do bucket
-        const { data: objects, error: objectsError } = await supabase.storage
-          .from(bucket.name)
-          .list('', { limit: 1000 });
+        // ✅ Listar objetos do bucket via Management API
+        const objectsResponse = await fetch(`https://api.supabase.com/v1/projects/${config.supabase.projectId}/storage/buckets/${bucket.name}/objects`, {
+          headers: { 
+            'Authorization': `Bearer ${config.supabase.serviceKey}`, 
+            'apikey': config.supabase.serviceKey,
+            'Content-Type': 'application/json'
+          }
+        });
+
+        let objects = [];
+        if (objectsResponse.ok) {
+          objects = await objectsResponse.json();
+        }
 
         const bucketInfo = {
           id: bucket.id,
@@ -404,7 +472,7 @@ async function backupStorage(config, backupDir) {
       }
     }
 
-    return { success: true, buckets: processedBuckets };
+    console.log(chalk.green(`✅ Storage backupado: ${processedBuckets.length} buckets`));
   } catch (error) {
     console.log(chalk.yellow(`⚠️ Erro no backup do Storage: ${error.message}`));
     return { success: false, buckets: [] };