smoonb 0.0.73 → 0.0.75

package/src/commands/backup/steps/06-storage.js

@@ -5,6 +5,7 @@ const AdmZip = require('adm-zip');
 const { createClient } = require('@supabase/supabase-js');
 const { ensureDir, writeJson } = require('../../../utils/fsx');
 const { confirm } = require('../../../utils/prompt');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 6: Backup Storage via Supabase API
@@ -12,10 +13,11 @@ const { confirm } = require('../../../utils/prompt');
  */
 module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supabaseServiceKey }) => {
   try {
+    const getT = global.smoonbI18n?.t || t;
     const storageDir = path.join(backupDir, 'storage');
     await ensureDir(storageDir);
 
-    console.log(chalk.white('   - Listando buckets de Storage via Management API...'));
+    console.log(chalk.white(`   - ${getT('backup.steps.storage.listing')}`));
     
     // Usar fetch direto para Management API com Personal Access Token
     const storageResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/storage/buckets`, {
@@ -26,25 +28,25 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
     });
     
     if (!storageResponse.ok) {
-      console.log(chalk.yellow(`     ⚠️ Erro ao listar buckets: ${storageResponse.status} ${storageResponse.statusText}`));
+      console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.storage.listBucketsError', { status: storageResponse.status, statusText: storageResponse.statusText })}`));
       return { success: false, buckets: [] };
     }
 
     const buckets = await storageResponse.json();
 
     if (!buckets || buckets.length === 0) {
-      console.log(chalk.white('   - Nenhum bucket encontrado'));
+      console.log(chalk.white(`   - ${getT('backup.steps.storage.noBuckets')}`));
       await writeJson(path.join(storageDir, 'README.md'), {
         message: 'Nenhum bucket de Storage encontrado neste projeto'
       });
       return { success: true, buckets: [] };
     }
 
-    console.log(chalk.white(`   - Encontrados ${buckets.length} buckets`));
+    console.log(chalk.white(`   - ${getT('backup.steps.storage.found', { count: buckets.length })}`));
 
     // Validar credenciais do Supabase para download de arquivos
     if (!supabaseUrl || !supabaseServiceKey) {
-      console.log(chalk.yellow('   ⚠️  Credenciais do Supabase não disponíveis. Fazendo backup apenas de metadados...'));
+      console.log(chalk.yellow(`   ⚠️  ${getT('backup.steps.storage.credentialsNotAvailable')}`));
       return await backupMetadataOnly(buckets, storageDir, projectId, accessToken);
     }
 
@@ -64,7 +66,7 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
 
     for (const bucket of buckets || []) {
       try {
-        console.log(chalk.white(`   - Processando bucket: ${bucket.name}`));
+        console.log(chalk.white(`   - ${getT('backup.steps.storage.processing', { bucketName: bucket.name })}`));
         
         // Listar objetos do bucket via Management API com Personal Access Token
         const objectsResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/storage/buckets/${bucket.name}/objects`, {
@@ -97,12 +99,12 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
         await ensureDir(bucketDir);
         
         // Listar todos os arquivos recursivamente usando Supabase client
-        console.log(chalk.white(`     - Listando arquivos do bucket ${bucket.name}...`));
+        console.log(chalk.white(`     - ${getT('backup.steps.storage.listingFiles', { bucketName: bucket.name })}`));
         const allFiles = await listAllFilesRecursively(supabase, bucket.name, '');
         
         let filesDownloaded = 0;
         if (allFiles.length > 0) {
-          console.log(chalk.white(`     - Baixando ${allFiles.length} arquivo(s) do bucket ${bucket.name}...`));
+          console.log(chalk.white(`     - ${getT('backup.steps.storage.downloading', { count: allFiles.length, bucketName: bucket.name })}`));
           
           for (const filePath of allFiles) {
             try {
@@ -112,7 +114,7 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
                 .download(filePath);
 
               if (downloadError) {
-                console.log(chalk.yellow(`       ⚠️  Erro ao baixar ${filePath}: ${downloadError.message}`));
+                console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.downloadError', { path: filePath, message: downloadError.message })}`));
                 continue;
               }
 
@@ -129,10 +131,10 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
 
               // Mostrar progresso a cada 10 arquivos ou se for o último
               if (filesDownloaded % 10 === 0 || filesDownloaded === allFiles.length) {
-                console.log(chalk.white(`       - Baixados ${filesDownloaded}/${allFiles.length} arquivo(s)...`));
+                console.log(chalk.white(`       - ${getT('backup.steps.storage.downloaded', { current: filesDownloaded, total: allFiles.length })}`));
               }
             } catch (fileError) {
-              console.log(chalk.yellow(`       ⚠️  Erro ao processar arquivo ${filePath}: ${fileError.message}`));
+              console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.processFileError', { path: filePath, message: fileError.message })}`));
             }
           }
         }
@@ -145,14 +147,14 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
           totalFiles: allFiles.length
         });
 
-        console.log(chalk.green(`     ✅ Bucket ${bucket.name}: ${filesDownloaded}/${allFiles.length} arquivo(s) baixado(s)`));
+        console.log(chalk.green(`     ✅ ${getT('backup.steps.storage.bucketDone', { bucketName: bucket.name, downloaded: filesDownloaded, total: allFiles.length })}`));
       } catch (error) {
-        console.log(chalk.yellow(`     ⚠️ Erro ao processar bucket ${bucket.name}: ${error.message}`));
+        console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.storage.processBucketError', { bucketName: bucket.name, message: error.message })}`));
       }
     }
 
     // Criar ZIP no padrão do Dashboard: {project-id}.storage.zip
-    console.log(chalk.white('\n   - Criando arquivo ZIP no padrão do Dashboard...'));
+    console.log(chalk.white(`\n   - ${getT('backup.steps.storage.creatingZip')}`));
     const zipFileName = `${projectId}.storage.zip`;
     const zipFilePath = path.join(backupDir, zipFileName);
     
@@ -167,25 +169,24 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
     const zipStats = await fs.stat(zipFilePath);
     const zipSizeMB = (zipStats.size / (1024 * 1024)).toFixed(2);
     
-    console.log(chalk.green(`   ✅ Arquivo ZIP criado: ${zipFileName} (${zipSizeMB} MB)`));
+    console.log(chalk.green(`   ✅ ${getT('backup.steps.storage.zipCreated', { fileName: zipFileName, size: zipSizeMB })}`));
 
     // Perguntar ao usuário se deseja limpar a estrutura temporária
-    const tempDirName = path.basename(tempStorageDir);
-    const shouldCleanup = await confirm(`   Deseja limpar ${tempDirName} após o backup`, false);
+    const shouldCleanup = await confirm(`   ${getT('backup.steps.storage.cleanup')}`, false);
     
     if (shouldCleanup) {
-      console.log(chalk.white(`   - Limpando estrutura temporária...`));
+      console.log(chalk.white(`   - ${getT('backup.steps.storage.cleanupRemoving')}`));
       try {
         await fs.rm(tempStorageDir, { recursive: true, force: true });
-        console.log(chalk.green(`   ✅ Estrutura temporária removida`));
+        console.log(chalk.green(`   ✅ ${getT('backup.steps.storage.cleanupRemoved')}`));
       } catch (cleanupError) {
-        console.log(chalk.yellow(`   ⚠️  Erro ao limpar estrutura temporária: ${cleanupError.message}`));
+        console.log(chalk.yellow(`   ⚠️  ${getT('backup.steps.storage.cleanupError', { message: cleanupError.message })}`));
       }
     } else {
-      console.log(chalk.white(`   ℹ️  Estrutura temporária mantida em: ${path.relative(process.cwd(), tempStorageDir)}`));
+      console.log(chalk.white(`   ℹ️  ${getT('backup.steps.storage.tempKept', { path: path.relative(process.cwd(), tempStorageDir) })}`));
     }
 
-    console.log(chalk.green(`✅ Storage backupado: ${processedBuckets.length} buckets, ${totalFilesDownloaded} arquivo(s) baixado(s)`));
+    console.log(chalk.green(`✅ ${getT('backup.steps.storage.done', { buckets: processedBuckets.length, files: totalFilesDownloaded })}`));
     return { 
       success: true, 
       buckets: processedBuckets,
@@ -195,7 +196,8 @@ module.exports = async ({ projectId, accessToken, backupDir, supabaseUrl, supaba
       tempDirCleaned: shouldCleanup
     };
   } catch (error) {
-    console.log(chalk.yellow(`⚠️ Erro no backup do Storage: ${error.message}`));
+    const getT = global.smoonbI18n?.t || t;
+    console.log(chalk.yellow(`⚠️ ${getT('backup.steps.storage.error', { message: error.message })}`));
     return { success: false, buckets: [] };
   }
 };
@@ -254,6 +256,7 @@ async function backupMetadataOnly(buckets, storageDir, projectId, accessToken) {
  */
 async function listAllFilesRecursively(supabase, bucketName, folderPath = '') {
   const allFiles = [];
+  const getT = global.smoonbI18n?.t || t;
   
   try {
     // Listar arquivos e pastas no caminho atual
@@ -265,7 +268,7 @@ async function listAllFilesRecursively(supabase, bucketName, folderPath = '') {
       });
 
     if (error) {
-      console.log(chalk.yellow(`       ⚠️  Erro ao listar ${folderPath || 'raiz'}: ${error.message}`));
+      console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.listError', { path: folderPath || 'raiz', message: error.message })}`));
       return allFiles;
     }
 
@@ -286,7 +289,7 @@ async function listAllFilesRecursively(supabase, bucketName, folderPath = '') {
       }
     }
   } catch (error) {
-    console.log(chalk.yellow(`       ⚠️  Erro ao processar ${folderPath || 'raiz'}: ${error.message}`));
+    console.log(chalk.yellow(`       ⚠️  ${getT('backup.steps.storage.processError', { path: folderPath || 'raiz', message: error.message })}`));
   }
 
   return allFiles;

package/src/commands/backup/steps/07-custom-roles.js

@@ -3,6 +3,7 @@ const path = require('path');
 const fs = require('fs').promises;
 const { promisify } = require('util');
 const { exec } = require('child_process');
+const { t } = require('../../../i18n');
 
 const execAsync = promisify(exec);
 
@@ -11,7 +12,8 @@ const execAsync = promisify(exec);
  */
 module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
   try {
-    console.log(chalk.white('   - Exportando Custom Roles via Docker...'));
+    const getT = global.smoonbI18n?.t || t;
+    console.log(chalk.white(`   - ${getT('backup.steps.roles.exporting')}`));
     
     const customRolesFile = path.join(backupDir, 'custom-roles.sql');
     
@@ -28,11 +30,12 @@ module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
       
       return { success: true, roles: [{ filename: 'custom-roles.sql', sizeKB }] };
     } catch (error) {
-      console.log(chalk.yellow(`     ⚠️ Erro ao exportar Custom Roles via Docker: ${error.message}`));
+      console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.roles.exportError', { message: error.message })}`));
       return { success: false, roles: [] };
     }
   } catch (error) {
-    console.log(chalk.yellow(`     ⚠️ Erro no backup dos Custom Roles: ${error.message}`));
+    const getT = global.smoonbI18n?.t || t;
+    console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.roles.error', { message: error.message })}`));
     return { success: false, roles: [] };
   }
 };

package/src/commands/backup/steps/08-edge-functions.js

@@ -4,6 +4,7 @@ const fs = require('fs').promises;
 const { ensureDir, writeJson } = require('../../../utils/fsx');
 const { extractPasswordFromDbUrl, ensureCleanLink } = require('../../../utils/supabaseLink');
 const { cleanDir } = require('../../../utils/fsExtra');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 8: Backup Edge Functions via Docker (reset link + limpeza opcional)
@@ -42,21 +43,23 @@ module.exports = async (context) => {
     
     // Se o usuário escolheu limpar APÓS, podemos limpar ANTES também para garantir ambiente limpo
     // Mas se escolheu NÃO limpar, preservamos o que já existe
+    const getT = global.smoonbI18n?.t || t;
+    
     if (shouldCleanAfter) {
       // Limpar antes se o usuário escolheu limpar após (garante ambiente limpo)
       await cleanDir(supabaseFunctionsDir);
-      console.log(chalk.white('   - Pasta supabase/functions limpa antes do backup.'));
+      console.log(chalk.white(`   - ${getT('backup.steps.functions.cleanBefore')}`));
     } else {
       // Apenas garantir que o diretório existe
       await fs.mkdir(supabaseFunctionsDir, { recursive: true });
       if (existingFunctionsBefore.length > 0) {
-        console.log(chalk.white(`   - Preservando ${existingFunctionsBefore.length} função(ões) existente(s) na pasta supabase/functions.`));
+        console.log(chalk.white(`   - ${getT('backup.steps.functions.preserving', { count: existingFunctionsBefore.length })}`));
       } else {
-        console.log(chalk.white('   - Pasta supabase/functions preparada (será preservada após backup).'));
+        console.log(chalk.white(`   - ${getT('backup.steps.functions.prepared')}`));
       }
     }
 
-    console.log(chalk.white('   - Listando Edge Functions via Management API...'));
+    console.log(chalk.white(`   - ${getT('backup.steps.functions.listing')}`));
     
     // Usar fetch direto para Management API com Personal Access Token
     const functionsResponse = await fetch(`https://api.supabase.com/v1/projects/${projectId}/functions`, {
@@ -67,14 +70,14 @@ module.exports = async (context) => {
     });
     
     if (!functionsResponse.ok) {
-      console.log(chalk.yellow(`     ⚠️ Erro ao listar Edge Functions: ${functionsResponse.status} ${functionsResponse.statusText}`));
+      console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.functions.listError', { status: functionsResponse.status, statusText: functionsResponse.statusText })}`));
       return { success: false, reason: 'api_error', functions: [] };
     }
 
     const functions = await functionsResponse.json();
     
     if (!functions || functions.length === 0) {
-      console.log(chalk.white('   - Nenhuma Edge Function encontrada'));
+      console.log(chalk.white(`   - ${getT('backup.steps.functions.noneFound')}`));
       await writeJson(path.join(functionsDir, 'README.md'), {
         message: 'Nenhuma Edge Function encontrada neste projeto'
       });
@@ -154,7 +157,7 @@ module.exports = async (context) => {
         });
         
       } catch (error) {
-        console.log(chalk.yellow(`     ⚠️ Erro ao baixar ${func.name}: ${error.message}`));
+        console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.functions.downloadError', { funcName: func.name, message: error.message })}`));
         errorCount++;
       }
     }
@@ -167,11 +170,11 @@ module.exports = async (context) => {
     // Nota: shouldCleanAfter já foi definido acima
     if (shouldCleanAfter) {
       await cleanDir(supabaseFunctionsDir);
-      console.log(chalk.white('   - supabase/functions limpo após o backup.'));
+      console.log(chalk.white(`   - ${getT('backup.steps.functions.cleanAfter')}`));
     } else {
       // Preservar tudo: tanto as funções que já existiam quanto as que foram baixadas
       // As funções baixadas não foram removidas individualmente (linha acima foi ajustada)
-      console.log(chalk.white('   - supabase/functions preservada conforme solicitado.'));
+      console.log(chalk.white(`   - ${getT('backup.steps.functions.preserved')}`));
     }
     
     return { 
@@ -185,7 +188,8 @@ module.exports = async (context) => {
     };
 
   } catch (error) {
-    console.log(chalk.yellow(`   ⚠️ Erro durante backup de Edge Functions: ${error.message}`));
+    const getT = global.smoonbI18n?.t || t;
+    console.log(chalk.yellow(`   ⚠️ ${getT('backup.steps.functions.error', { message: error.message })}`));
     console.log('⏭️  Continuando com outros componentes...');
     return { success: false, reason: 'download_error', error: error.message, functions: [] };
   }

package/src/commands/backup/steps/09-supabase-temp.js

@@ -2,6 +2,7 @@ const chalk = require('chalk');
 const path = require('path');
 const { copyDirSafe } = require('../../../utils/fsExtra');
 const { cleanDir } = require('../../../utils/fsExtra');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 9: Backup Supabase .temp (NOVA ETAPA INDEPENDENTE)
@@ -9,17 +10,18 @@ const { cleanDir } = require('../../../utils/fsExtra');
 module.exports = async (context) => {
   const { backupDir } = context;
   try {
+    const getT = global.smoonbI18n?.t || t;
     const tempDir = path.join(process.cwd(), 'supabase', '.temp');
     const backupTempDir = path.join(backupDir, 'supabase-temp');
     
     const fileCount = await copyDirSafe(tempDir, backupTempDir);
-    
-    console.log(chalk.white(`   - Copiando supabase/.temp → backups/backup-${path.basename(backupDir)}/supabase-temp (${fileCount} arquivos)...`));
+    const relativePath = path.relative(process.cwd(), backupTempDir);
+    console.log(chalk.white(`   - ${getT('backup.steps.temp.copying', { path: relativePath, count: fileCount })}`));
     
     if (fileCount === 0) {
-      console.log(chalk.white('   - Nenhum arquivo encontrado em supabase/.temp'));
+      console.log(chalk.white(`   - ${getT('backup.steps.temp.noFiles')}`));
     } else {
-      console.log(chalk.green(`   ✅ ${fileCount} arquivo(s) copiado(s)`));
+      console.log(chalk.green(`   ✅ ${getT('backup.steps.temp.copied', { count: fileCount })}`));
     }
     
     // Usar flag de limpeza do contexto (já foi perguntado no início)
@@ -27,7 +29,7 @@ module.exports = async (context) => {
     
     if (shouldClean) {
       await cleanDir(tempDir);
-      console.log(chalk.white('   - supabase/.temp apagado.'));
+      console.log(chalk.white(`   - ${getT('backup.steps.temp.cleaned')}`));
     }
     
     return {
@@ -35,7 +37,8 @@ module.exports = async (context) => {
       file_count: fileCount
     };
   } catch (error) {
-    console.log(chalk.yellow(`   ⚠️ Erro no backup do supabase/.temp: ${error.message}`));
+    const getT = global.smoonbI18n?.t || t;
+    console.log(chalk.yellow(`   ⚠️ ${getT('backup.steps.temp.error', { message: error.message })}`));
     return { success: false };
   }
 };

package/src/commands/backup/steps/10-migrations.js

@@ -3,6 +3,7 @@ const path = require('path');
 const { execSync } = require('child_process');
 const { extractPasswordFromDbUrl, ensureCleanLink } = require('../../../utils/supabaseLink');
 const { cleanDir, countFiles, copyDirSafe } = require('../../../utils/fsExtra');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 10: Backup Migrations (NOVA ETAPA INDEPENDENTE)
@@ -10,6 +11,7 @@ const { cleanDir, countFiles, copyDirSafe } = require('../../../utils/fsExtra');
 module.exports = async (context) => {
   const { projectId, accessToken, databaseUrl, backupDir } = context;
   try {
+    const getT = global.smoonbI18n?.t || t;
     // Reset de link ao projeto de ORIGEM
     const dbPassword = extractPasswordFromDbUrl(databaseUrl);
     await ensureCleanLink(projectId, accessToken, dbPassword);
@@ -17,10 +19,10 @@ module.exports = async (context) => {
     // Limpar migrations local (opcional, mas recomendado para garantir servidor como fonte da verdade)
     const migrationsDir = path.join(process.cwd(), 'supabase', 'migrations');
     await cleanDir(migrationsDir);
-    console.log(chalk.white('   - Limpando supabase/migrations...'));
+    console.log(chalk.white(`   - ${getT('backup.steps.migrations.cleaning')}`));
     
     // Baixar todas as migrations do servidor usando migration fetch
-    console.log(chalk.white('   - Baixando todas as migrations do servidor usando migration fetch...'));
+    console.log(chalk.white(`   - ${getT('backup.steps.migrations.downloading')}`));
     
     const env = {
       ...process.env,
@@ -36,22 +38,23 @@ module.exports = async (context) => {
         env
       });
     } catch (error) {
-      console.log(chalk.yellow(`   ⚠️ Erro ao executar migration fetch: ${error.message}`));
-      console.log(chalk.yellow('   💡 Verifique se o projeto está linkado corretamente e se o token está válido.'));
+      console.log(chalk.yellow(`   ⚠️ ${getT('backup.steps.migrations.fetchError', { message: error.message })}`));
+      console.log(chalk.yellow(`   💡 ${getT('backup.steps.migrations.fetchTip')}`));
       return { success: false };
     }
     
     // Contar arquivos baixados
     const fileCount = await countFiles(migrationsDir);
-    console.log(chalk.white(`   - Arquivos baixados: ${fileCount} migrations`));
+    console.log(chalk.white(`   - ${getT('backup.steps.migrations.downloaded', { count: fileCount })}`));
     
     // Copiar migrations para o backup
     const backupMigrationsDir = path.join(backupDir, 'migrations');
     const copiedCount = await copyDirSafe(migrationsDir, backupMigrationsDir);
-    console.log(chalk.white(`   - Copiando supabase/migrations → backups/backup-${path.basename(backupDir)}/migrations (${copiedCount} arquivos)...`));
+    const relativePath = path.relative(process.cwd(), backupMigrationsDir);
+    console.log(chalk.white(`   - ${getT('backup.steps.migrations.copying', { path: relativePath, count: copiedCount })}`));
     
     if (copiedCount > 0) {
-      console.log(chalk.green(`   ✅ ${copiedCount} migration(s) copiada(s)`));
+      console.log(chalk.green(`   ✅ ${getT('backup.steps.migrations.copied', { count: copiedCount })}`));
     }
     
     // Usar flag de limpeza do contexto (já foi perguntado no início)
@@ -59,7 +62,7 @@ module.exports = async (context) => {
     
     if (shouldClean) {
       await cleanDir(migrationsDir);
-      console.log(chalk.gray('   - supabase/migrations apagado.'));
+      console.log(chalk.gray(`   - ${getT('backup.steps.migrations.cleaned')}`));
     }
     
     return {
@@ -67,7 +70,8 @@ module.exports = async (context) => {
       file_count: copiedCount
     };
   } catch (error) {
-    console.log(chalk.yellow(`   ⚠️ Erro no backup das migrations: ${error.message}`));
+    const getT = global.smoonbI18n?.t || t;
+    console.log(chalk.yellow(`   ⚠️ ${getT('backup.steps.migrations.error', { message: error.message })}`));
     return { success: false };
   }
 };

package/src/commands/restore/steps/00-backup-selection.js

@@ -1,12 +1,14 @@
 const chalk = require('chalk');
 const readline = require('readline');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 0: Seleção interativa de backup
  */
 module.exports = async (backups) => {
-  console.log(chalk.blue('\n📋 Backups disponíveis:'));
-  console.log(chalk.blue('═'.repeat(80)));
+  const getT = global.smoonbI18n?.t || t;
+  console.log(chalk.blue(`\n📋 ${getT('restore.steps.backupSelection.title')}`));
+  console.log(chalk.blue(getT('restore.steps.backupSelection.separator')));
   
   backups.forEach((backup, index) => {
     const date = new Date(backup.created).toLocaleString('pt-BR');

package/src/commands/restore/steps/01-components-selection.js

@@ -2,31 +2,33 @@ const path = require('path');
 const fs = require('fs');
 const chalk = require('chalk');
 const { confirm } = require('../../../utils/prompt');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 1: Perguntar quais componentes restaurar
  */
 module.exports = async (backupPath) => {
+  const getT = global.smoonbI18n?.t || t;
   // Database (sempre disponível)
-  const restoreDatabase = await confirm('Deseja restaurar Database', true);
+  const restoreDatabase = await confirm(getT('restore.steps.components.database.include'), true);
   
   // Edge Functions
   const edgeFunctionsDir = path.join(backupPath, 'edge-functions');
   let restoreEdgeFunctions = false;
   if (fs.existsSync(edgeFunctionsDir) && fs.readdirSync(edgeFunctionsDir).length > 0) {
-    console.log(chalk.cyan('\n⚡ Edge Functions:'));
-    console.log(chalk.white('   As Edge Functions serão copiadas para supabase/functions e implantadas no projeto destino.'));
-    console.log(chalk.white('   A pasta supabase/functions será limpa antes do processo.\n'));
-    restoreEdgeFunctions = await confirm('Deseja restaurar Edge Functions', true);
+    console.log(chalk.cyan(`\n⚡ ${getT('restore.steps.components.edgeFunctions.title')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.edgeFunctions.description1')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.edgeFunctions.description2')}\n`));
+    restoreEdgeFunctions = await confirm(getT('restore.steps.components.edgeFunctions.include'), true);
   }
-  
+
   // Auth Settings
   let restoreAuthSettings = false;
   if (fs.existsSync(path.join(backupPath, 'auth-settings.json'))) {
-    console.log(chalk.cyan('\n🔐 Auth Settings:'));
-    console.log(chalk.white('   As configurações de Auth serão exibidas para configuração manual no Dashboard.'));
-    console.log(chalk.white('   Algumas configurações não podem ser aplicadas automaticamente por questões de segurança.\n'));
-    restoreAuthSettings = await confirm('Deseja ver as configurações de Auth Settings', true);
+    console.log(chalk.cyan(`\n🔐 ${getT('restore.steps.components.auth.title')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.auth.description1')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.auth.description2')}\n`));
+    restoreAuthSettings = await confirm(getT('restore.steps.components.auth.include'), true);
   }
   
   // Storage Buckets
@@ -49,37 +51,37 @@ module.exports = async (backupPath) => {
   const hasStorageFiles = hasStorageDir && fs.readdirSync(storageDir).length > 0;
   
   if (storageZipFiles.length > 0 || hasStorageFiles) {
-    console.log(chalk.cyan('\n📦 Storage:'));
+    console.log(chalk.cyan(`\n📦 ${getT('restore.steps.components.storage.title')}`));
     if (storageZipFiles.length > 0) {
-      console.log(chalk.white(`   Arquivo .storage.zip encontrado: ${storageZipFiles[0]}`));
-      console.log(chalk.white('   Os buckets e arquivos serão restaurados automaticamente no projeto destino.'));
-      console.log(chalk.white('   O arquivo ZIP será extraído, buckets criados e arquivos enviados via API.\n'));
+      console.log(chalk.white(`   ${getT('restore.steps.components.storage.zipFound', { fileName: storageZipFiles[0] })}`));
+      console.log(chalk.white(`   ${getT('restore.steps.components.storage.withZip.description1')}`));
+      console.log(chalk.white(`   ${getT('restore.steps.components.storage.withZip.description2')}\n`));
     } else {
-      console.log(chalk.white('   Apenas metadados dos buckets encontrados (pasta storage).'));
-      console.log(chalk.white('   Para restaurar os arquivos, é necessário o arquivo .storage.zip do Dashboard.'));
-      console.log(chalk.white('   Apenas informações dos buckets serão exibidas.\n'));
+      console.log(chalk.white(`   ${getT('restore.steps.components.storage.metadataOnly.description1')}`));
+      console.log(chalk.white(`   ${getT('restore.steps.components.storage.metadataOnly.description2')}`));
+      console.log(chalk.white(`   ${getT('restore.steps.components.storage.metadataOnly.description3')}\n`));
     }
-    restoreStorage = await confirm('Deseja restaurar Storage Buckets', true);
+    restoreStorage = await confirm(getT('restore.steps.components.storage.include'), true);
   }
-  
+
   // Database Extensions and Settings
   const dbSettingsFiles = fs.readdirSync(backupPath)
     .filter(file => file.startsWith('database-settings-') && file.endsWith('.json'));
   let restoreDatabaseSettings = false;
   if (dbSettingsFiles.length > 0) {
-    console.log(chalk.cyan('\n🔧 Database Extensions and Settings:'));
-    console.log(chalk.white('   As extensões e configurações do banco de dados serão restauradas via SQL.'));
-    console.log(chalk.white('   Isso inclui extensões PostgreSQL e configurações específicas do projeto.\n'));
-    restoreDatabaseSettings = await confirm('Deseja restaurar Database Extensions and Settings', true);
+    console.log(chalk.cyan(`\n🔧 ${getT('restore.steps.components.databaseSettings.title')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.databaseSettings.description1')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.databaseSettings.description2')}\n`));
+    restoreDatabaseSettings = await confirm(getT('restore.steps.components.databaseSettings.include'), true);
   }
-  
+
   // Realtime Settings
   let restoreRealtimeSettings = false;
   if (fs.existsSync(path.join(backupPath, 'realtime-settings.json'))) {
-    console.log(chalk.cyan('\n🔄 Realtime Settings:'));
-    console.log(chalk.white('   As configurações de Realtime serão exibidas para configuração manual no Dashboard.'));
-    console.log(chalk.white('   Algumas configurações precisam ser aplicadas manualmente.\n'));
-    restoreRealtimeSettings = await confirm('Deseja ver as configurações de Realtime Settings', true);
+    console.log(chalk.cyan(`\n🔄 ${getT('restore.steps.components.realtime.title')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.realtime.description1')}`));
+    console.log(chalk.white(`   ${getT('restore.steps.components.realtime.description2')}\n`));
+    restoreRealtimeSettings = await confirm(getT('restore.steps.components.realtime.include'), true);
   }
   
   return {

package/src/commands/restore/steps/03-database.js

@@ -1,20 +1,22 @@
 const chalk = require('chalk');
 const path = require('path');
 const { execSync } = require('child_process');
+const { t } = require('../../../i18n');
 
 /**
  * Etapa 3: Restaurar Database via psql
  */
 module.exports = async ({ backupFilePath, targetDatabaseUrl }) => {
   try {
+    const getT = global.smoonbI18n?.t || t;
     const backupDirAbs = path.resolve(path.dirname(backupFilePath));
     const fileName = path.basename(backupFilePath);
     let uncompressedFile = fileName;
     
     // Verificar se é arquivo .backup.gz (compactado) ou .backup (descompactado)
     if (fileName.endsWith('.backup.gz')) {
-      console.log(chalk.white('   - Arquivo .backup.gz detectado'));
-      console.log(chalk.white('   - Extraindo arquivo .gz...'));
+      console.log(chalk.white(`   - ${getT('restore.steps.database.detectedGz')}`));
+      console.log(chalk.white(`   - ${getT('restore.steps.database.extractingGz')}`));
       
       const unzipCmd = [
         'docker run --rm',
@@ -24,10 +26,10 @@ module.exports = async ({ backupFilePath, targetDatabaseUrl }) => {
       
       execSync(unzipCmd, { stdio: 'pipe' });
       uncompressedFile = fileName.replace('.gz', '');
-      console.log(chalk.white('   - Arquivo descompactado: ' + uncompressedFile));
+      console.log(chalk.white(`   - ${getT('restore.steps.database.uncompressed', { file: uncompressedFile })}`));
     } else if (fileName.endsWith('.backup')) {
-      console.log(chalk.white('   - Arquivo .backup detectado (já descompactado)'));
-      console.log(chalk.white('   - Prosseguindo com restauração direta'));
+      console.log(chalk.white(`   - ${getT('restore.steps.database.detectedBackup')}`));
+      console.log(chalk.white(`   - ${getT('restore.steps.database.proceeding')}`));
     } else {
       throw new Error(`Formato de arquivo inválido. Esperado .backup.gz ou .backup, recebido: ${fileName}`);
     }
@@ -49,29 +51,30 @@ module.exports = async ({ backupFilePath, targetDatabaseUrl }) => {
       `-f /host/${uncompressedFile}`
     ].join(' ');
     
-    console.log(chalk.cyan('   - Executando psql via Docker...'));
-    console.log(chalk.cyan('   ℹ️ Seguindo documentação oficial Supabase'));
-    console.log(chalk.yellow('   ⚠️ AVISO: Erros como "object already exists" são ESPERADOS'));
-    console.log(chalk.yellow('   ⚠️ Isto acontece porque o backup contém CREATE para todos os schemas'));
-    console.log(chalk.yellow('   ⚠️ Supabase já tem auth e storage criados, então esses erros são normais'));
+    console.log(chalk.cyan(`   - ${getT('restore.steps.database.executing')}`));
+    console.log(chalk.cyan(`   ℹ️ ${getT('restore.steps.database.followingDocs')}`));
+    console.log(chalk.yellow(`   ⚠️ ${getT('restore.steps.database.warning')}`));
+    console.log(chalk.yellow(`   ⚠️ ${getT('restore.steps.database.warningReason1')}`));
+    console.log(chalk.yellow(`   ⚠️ ${getT('restore.steps.database.warningReason2')}`));
     
     // Executar comando de restauração
     execSync(restoreCmd, { stdio: 'inherit', encoding: 'utf8' });
     
-    console.log(chalk.green('   ✅ Database restaurada com sucesso!'));
-    console.log(chalk.gray('   ℹ️ Erros "already exists" são normais e não afetam a restauração'));
+    console.log(chalk.green(`   ✅ ${getT('restore.steps.database.success')}`));
+    console.log(chalk.gray(`   ℹ️ ${getT('restore.steps.database.normalErrors')}`));
     
   } catch (error) {
     // Erros esperados conforme documentação oficial Supabase
+    const getT = global.smoonbI18n?.t || t;
     if (error.message.includes('already exists') || 
         error.message.includes('constraint') ||
         error.message.includes('duplicate') ||
         error.stdout?.includes('already exists')) {
-      console.log(chalk.yellow('   ⚠️ Erros esperados encontrados (conforme documentação Supabase)'));
-      console.log(chalk.green('   ✅ Database restaurada com sucesso!'));
-      console.log(chalk.gray('   ℹ️ Erros são ignorados pois são comandos de CREATE que já existem'));
+      console.log(chalk.yellow(`   ⚠️ ${getT('restore.steps.database.expectedErrors')}`));
+      console.log(chalk.green(`   ✅ ${getT('restore.steps.database.success')}`));
+      console.log(chalk.gray(`   ℹ️ ${getT('restore.steps.database.errorsIgnored')}`));
     } else {
-      console.error(chalk.red(`   ❌ Erro inesperado na restauração: ${error.message}`));
+      console.error(chalk.red(`   ❌ ${getT('restore.steps.database.error', { message: error.message })}`));
       throw error;
     }
   }