smoonb 1.0.6 → 1.0.8

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

@@ -1,202 +1,76 @@
-const chalk = require('chalk');
-const path = require('path');
-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)
- */
-module.exports = async (context) => {
-  const { projectId, accessToken, databaseUrl, backupDir } = context;
-  try {
-    const functionsDir = path.join(backupDir, 'edge-functions');
-    await ensureDir(functionsDir);
-
-    // Reset de link ao projeto de ORIGEM
-    const dbPassword = extractPasswordFromDbUrl(databaseUrl);
-    await ensureCleanLink(projectId, accessToken, dbPassword);
-
-    // Preparar diretório supabase/functions (criar se não existir, mas não limpar ainda)
-    const supabaseFunctionsDir = path.join(process.cwd(), 'supabase', 'functions');
-    
-    // Verificar flag de limpeza antes do backup
-    const shouldCleanAfter = context?.cleanupFlags?.cleanFunctions || false;
-    
-    // Registrar funções que já existiam ANTES do processo (para preservar se necessário)
-    let existingFunctionsBefore = [];
-    try {
-      const existingItems = await fs.readdir(supabaseFunctionsDir);
-      for (const item of existingItems) {
-        const itemPath = path.join(supabaseFunctionsDir, item);
-        const stats = await fs.stat(itemPath);
-        if (stats.isDirectory()) {
-          existingFunctionsBefore.push(item);
-        }
-      }
-    } catch {
-      // Diretório não existe, tudo bem
-      existingFunctionsBefore = [];
-    }
-    
-    // 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(`   - ${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(`   - ${getT('backup.steps.functions.preserving', { count: existingFunctionsBefore.length })}`));
-      } else {
-        console.log(chalk.white(`   - ${getT('backup.steps.functions.prepared')}`));
-      }
-    }
-
-    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`, {
-      headers: { 
-        'Authorization': `Bearer ${accessToken}`,
-        'Content-Type': 'application/json'
-      }
-    });
-    
-    if (!functionsResponse.ok) {
-      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(`   - ${getT('backup.steps.functions.noneFound')}`));
-      await writeJson(path.join(functionsDir, 'README.md'), {
-        message: getT('backup.steps.functions.noFunctionsMessage')
-      });
-      return { success: true, reason: 'no_functions', functions: [] };
-    }
-
-    console.log(chalk.white(`   - Encontradas ${functions.length} Edge Function(s)`));
-    
-    const downloadedFunctions = [];
-    let successCount = 0;
-    let errorCount = 0;
-    const totalFuncs = functions.length;
-    const stepStart = Date.now();
-
-    // Baixar cada Edge Function via Supabase CLI
-    // Nota: O CLI ignora o cwd e sempre baixa para supabase/functions
-    for (let idx = 0; idx < functions.length; idx++) {
-      const func = functions[idx];
-      const current = idx + 1;
-      const elapsed = Math.floor((Date.now() - stepStart) / 1000);
-      try {
-        console.log(chalk.white(`   - Baixando ${current}/${totalFuncs}: ${func.name}... (${elapsed}s)`));
-        
-        // Criar diretório da função NO BACKUP
-        const functionTargetDir = path.join(functionsDir, func.name);
-        await ensureDir(functionTargetDir);
-        
-        // Diretório temporário onde o supabase CLI irá baixar (supabase/functions)
-        const tempDownloadDir = path.join(process.cwd(), 'supabase', 'functions', func.name);
-        
-        // Baixar Edge Function via Supabase CLI (sempre vai para supabase/functions)
-        const { execSync } = require('child_process');
-        
-        execSync(`supabase functions download ${func.name}`, {
-          timeout: 60000,
-          stdio: 'pipe'
-        });
-        
-        // COPIAR arquivos de supabase/functions para o backup
-        try {
-          const stat = await fs.stat(tempDownloadDir);
-          if (stat.isDirectory()) {
-            const files = await fs.readdir(tempDownloadDir);
-            for (const file of files) {
-              const srcPath = path.join(tempDownloadDir, file);
-              const dstPath = path.join(functionTargetDir, file);
-              
-              const fileStats = await fs.stat(srcPath);
-              if (fileStats.isDirectory()) {
-                // Copiar diretórios recursivamente
-                await fs.cp(srcPath, dstPath, { recursive: true });
-              } else {
-                // Copiar arquivos
-                await fs.copyFile(srcPath, dstPath);
-              }
-            }
-          }
-        } catch {
-          // Arquivos não foram baixados, continuar
-          console.log(chalk.yellow(`     ⚠️ Nenhum arquivo encontrado em ${tempDownloadDir}`));
-        }
-        
-        // Limpar função baixada temporariamente APENAS se o usuário escolheu limpar após
-        // Se não escolheu, preservar (pode ser que já existisse antes)
-        if (shouldCleanAfter) {
-          try {
-            await fs.rm(tempDownloadDir, { recursive: true, force: true });
-          } catch {
-            // Ignorar erro de limpeza
-          }
-        }
-        // Se shouldCleanAfter = false, manter a função baixada (e qualquer função que já existia)
-        
-        console.log(chalk.green(`     ✅ ${func.name} baixada com sucesso`));
-        successCount++;
-        
-        downloadedFunctions.push({
-          name: func.name,
-          slug: func.name,
-          version: func.version || 'unknown',
-          files: await fs.readdir(functionTargetDir).catch(() => [])
-        });
-        
-      } catch (error) {
-        console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.functions.downloadError', { funcName: func.name, message: error.message })}`));
-        errorCount++;
-      }
-    }
-    
-    console.log(chalk.green(`📊 Backup de Edge Functions concluído:`));
-    console.log(chalk.green(`   ✅ Sucessos: ${successCount}`));
-    console.log(chalk.green(`   ❌ Erros: ${errorCount}`));
-    
-    // Limpar pasta supabase/functions APÓS o backup apenas se o usuário escolheu
-    // Nota: shouldCleanAfter já foi definido acima
-    if (shouldCleanAfter) {
-      await cleanDir(supabaseFunctionsDir);
-      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(`   - ${getT('backup.steps.functions.preserved')}`));
-    }
-    
-    return { 
-      success: true, 
-      reason: 'success',
-      functions: downloadedFunctions,
-      functions_count: functions.length,
-      success_count: successCount,
-      error_count: errorCount,
-      method: 'docker'
-    };
-
-  } catch (error) {
-    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: [] };
-  }
-};
-
+const path = require('path');
+const os = require('os');
+const fs = require('fs').promises;
+const { runSupabase } = require('../../../utils/supabaseCli');
+const { management } = require('../../restore/management');
+const { copyDirectoryRecursive } = require('../../restore/utils');
+module.exports = async ({ projectId, accessToken, backupDir }) => {
+  const root = await fs.mkdtemp(
+    path.join(os.tmpdir(), 'smoonb-functions-backup-'),
+  );
+  try {
+    const functions = await management(
+      { targetProjectId: projectId, targetAccessToken: accessToken },
+      'functions',
+    );
+    await fs.mkdir(path.join(root, 'supabase'), { recursive: true });
+    await fs.writeFile(
+      path.join(root, 'supabase', 'config.toml'),
+      'project_id = "smoonb-backup"\n',
+    );
+    const downloaded = [];
+    for (const f of functions) {
+      const name = f.slug || f.name;
+      if (!/^[-a-zA-Z0-9_]+$/.test(name))
+        throw new Error('Invalid function slug');
+      runSupabase(
+        'supabase',
+        [
+          'functions',
+          'download',
+          name,
+          '--project-ref',
+          projectId,
+          '--workdir',
+          root,
+        ],
+        {
+          cwd: root,
+          env: { ...process.env, SUPABASE_ACCESS_TOKEN: accessToken },
+          stdio: 'pipe',
+          timeout: 180000,
+          windowsHide: true,
+        },
+      );
+      const destination = path.join(backupDir, 'edge-functions', name);
+      await copyDirectoryRecursive(
+        path.join(root, 'supabase', 'functions', name),
+        destination,
+      );
+      downloaded.push({
+        name,
+        slug: name,
+        version: f.version,
+        verify_jwt: f.verify_jwt,
+        files: await fs.readdir(destination),
+      });
+    }
+    return {
+      success: true,
+      reason: 'success',
+      functions: downloaded,
+      functions_count: downloaded.length,
+      success_count: downloaded.length,
+      error_count: 0,
+      method: 'cli-isolated',
+    };
+  } catch {
+    return {
+      success: false,
+      reason: 'function_download_failed',
+      functions: [],
+    };
+  } finally {
+    await fs.rm(root, { recursive: true, force: true });
+  }
+};

package/src/commands/restore/auth-fields.json

@@ -0,0 +1,237 @@
+[
+  "site_url",
+  "disable_signup",
+  "jwt_exp",
+  "smtp_admin_email",
+  "smtp_host",
+  "smtp_port",
+  "smtp_user",
+  "smtp_pass",
+  "smtp_max_frequency",
+  "smtp_sender_name",
+  "mailer_allow_unverified_email_sign_ins",
+  "mailer_autoconfirm",
+  "mailer_subjects_invite",
+  "mailer_subjects_confirmation",
+  "mailer_subjects_recovery",
+  "mailer_subjects_email_change",
+  "mailer_subjects_magic_link",
+  "mailer_subjects_reauthentication",
+  "mailer_subjects_password_changed_notification",
+  "mailer_subjects_email_changed_notification",
+  "mailer_subjects_phone_changed_notification",
+  "mailer_subjects_mfa_factor_enrolled_notification",
+  "mailer_subjects_mfa_factor_unenrolled_notification",
+  "mailer_subjects_identity_linked_notification",
+  "mailer_subjects_identity_unlinked_notification",
+  "mailer_templates_invite_content",
+  "mailer_templates_confirmation_content",
+  "mailer_templates_recovery_content",
+  "mailer_templates_email_change_content",
+  "mailer_templates_magic_link_content",
+  "mailer_templates_reauthentication_content",
+  "mailer_templates_password_changed_notification_content",
+  "mailer_templates_email_changed_notification_content",
+  "mailer_templates_phone_changed_notification_content",
+  "mailer_templates_mfa_factor_enrolled_notification_content",
+  "mailer_templates_mfa_factor_unenrolled_notification_content",
+  "mailer_templates_identity_linked_notification_content",
+  "mailer_templates_identity_unlinked_notification_content",
+  "mailer_notifications_password_changed_enabled",
+  "mailer_notifications_email_changed_enabled",
+  "mailer_notifications_phone_changed_enabled",
+  "mailer_notifications_mfa_factor_enrolled_enabled",
+  "mailer_notifications_mfa_factor_unenrolled_enabled",
+  "mailer_notifications_identity_linked_enabled",
+  "mailer_notifications_identity_unlinked_enabled",
+  "mfa_max_enrolled_factors",
+  "uri_allow_list",
+  "external_anonymous_users_enabled",
+  "external_email_enabled",
+  "external_phone_enabled",
+  "saml_enabled",
+  "saml_external_url",
+  "security_sb_forwarded_for_enabled",
+  "security_captcha_enabled",
+  "security_captcha_provider",
+  "security_captcha_secret",
+  "sessions_timebox",
+  "sessions_inactivity_timeout",
+  "sessions_single_per_user",
+  "sessions_tags",
+  "rate_limit_anonymous_users",
+  "rate_limit_email_sent",
+  "rate_limit_sms_sent",
+  "rate_limit_verify",
+  "rate_limit_token_refresh",
+  "rate_limit_otp",
+  "rate_limit_web3",
+  "mailer_secure_email_change_enabled",
+  "refresh_token_rotation_enabled",
+  "password_hibp_enabled",
+  "password_min_length",
+  "password_required_characters",
+  "security_manual_linking_enabled",
+  "security_update_password_require_reauthentication",
+  "security_update_password_require_current_password",
+  "security_refresh_token_reuse_interval",
+  "mailer_otp_exp",
+  "mailer_otp_length",
+  "sms_autoconfirm",
+  "sms_max_frequency",
+  "sms_otp_exp",
+  "sms_otp_length",
+  "sms_provider",
+  "sms_messagebird_access_key",
+  "sms_messagebird_originator",
+  "sms_test_otp",
+  "sms_test_otp_valid_until",
+  "sms_textlocal_api_key",
+  "sms_textlocal_sender",
+  "sms_twilio_account_sid",
+  "sms_twilio_auth_token",
+  "sms_twilio_content_sid",
+  "sms_twilio_message_service_sid",
+  "sms_twilio_verify_account_sid",
+  "sms_twilio_verify_auth_token",
+  "sms_twilio_verify_message_service_sid",
+  "sms_vonage_api_key",
+  "sms_vonage_api_secret",
+  "sms_vonage_from",
+  "sms_template",
+  "hook_mfa_verification_attempt_enabled",
+  "hook_mfa_verification_attempt_uri",
+  "hook_mfa_verification_attempt_secrets",
+  "hook_password_verification_attempt_enabled",
+  "hook_password_verification_attempt_uri",
+  "hook_password_verification_attempt_secrets",
+  "hook_custom_access_token_enabled",
+  "hook_custom_access_token_uri",
+  "hook_custom_access_token_secrets",
+  "hook_send_sms_enabled",
+  "hook_send_sms_uri",
+  "hook_send_sms_secrets",
+  "hook_send_email_enabled",
+  "hook_send_email_uri",
+  "hook_send_email_secrets",
+  "hook_before_user_created_enabled",
+  "hook_before_user_created_uri",
+  "hook_before_user_created_secrets",
+  "hook_after_user_created_enabled",
+  "hook_after_user_created_uri",
+  "hook_after_user_created_secrets",
+  "external_apple_enabled",
+  "external_apple_client_id",
+  "external_apple_email_optional",
+  "external_apple_secret",
+  "external_apple_additional_client_ids",
+  "external_azure_enabled",
+  "external_azure_client_id",
+  "external_azure_email_optional",
+  "external_azure_secret",
+  "external_azure_url",
+  "external_bitbucket_enabled",
+  "external_bitbucket_client_id",
+  "external_bitbucket_email_optional",
+  "external_bitbucket_secret",
+  "external_discord_enabled",
+  "external_discord_client_id",
+  "external_discord_email_optional",
+  "external_discord_secret",
+  "external_facebook_enabled",
+  "external_facebook_client_id",
+  "external_facebook_email_optional",
+  "external_facebook_secret",
+  "external_figma_enabled",
+  "external_figma_client_id",
+  "external_figma_email_optional",
+  "external_figma_secret",
+  "external_github_enabled",
+  "external_github_client_id",
+  "external_github_email_optional",
+  "external_github_secret",
+  "external_gitlab_enabled",
+  "external_gitlab_client_id",
+  "external_gitlab_email_optional",
+  "external_gitlab_secret",
+  "external_gitlab_url",
+  "external_google_enabled",
+  "external_google_client_id",
+  "external_google_email_optional",
+  "external_google_secret",
+  "external_google_additional_client_ids",
+  "external_google_skip_nonce_check",
+  "external_kakao_enabled",
+  "external_kakao_client_id",
+  "external_kakao_email_optional",
+  "external_kakao_secret",
+  "external_keycloak_enabled",
+  "external_keycloak_client_id",
+  "external_keycloak_email_optional",
+  "external_keycloak_secret",
+  "external_keycloak_url",
+  "external_linkedin_oidc_enabled",
+  "external_linkedin_oidc_client_id",
+  "external_linkedin_oidc_email_optional",
+  "external_linkedin_oidc_secret",
+  "external_slack_oidc_enabled",
+  "external_slack_oidc_client_id",
+  "external_slack_oidc_email_optional",
+  "external_slack_oidc_secret",
+  "external_notion_enabled",
+  "external_notion_client_id",
+  "external_notion_email_optional",
+  "external_notion_secret",
+  "external_slack_enabled",
+  "external_slack_client_id",
+  "external_slack_email_optional",
+  "external_slack_secret",
+  "external_spotify_enabled",
+  "external_spotify_client_id",
+  "external_spotify_email_optional",
+  "external_spotify_secret",
+  "external_twitch_enabled",
+  "external_twitch_client_id",
+  "external_twitch_email_optional",
+  "external_twitch_secret",
+  "external_twitter_enabled",
+  "external_twitter_client_id",
+  "external_twitter_email_optional",
+  "external_twitter_secret",
+  "external_x_enabled",
+  "external_x_client_id",
+  "external_x_email_optional",
+  "external_x_secret",
+  "external_workos_enabled",
+  "external_workos_client_id",
+  "external_workos_secret",
+  "external_workos_url",
+  "external_web3_solana_enabled",
+  "external_web3_ethereum_enabled",
+  "external_zoom_enabled",
+  "external_zoom_client_id",
+  "external_zoom_email_optional",
+  "external_zoom_secret",
+  "db_max_pool_size",
+  "db_max_pool_size_unit",
+  "api_max_request_duration",
+  "mfa_totp_enroll_enabled",
+  "mfa_totp_verify_enabled",
+  "mfa_web_authn_enroll_enabled",
+  "mfa_web_authn_verify_enabled",
+  "passkey_enabled",
+  "webauthn_rp_display_name",
+  "webauthn_rp_id",
+  "webauthn_rp_origins",
+  "mfa_phone_enroll_enabled",
+  "mfa_phone_verify_enabled",
+  "mfa_phone_max_frequency",
+  "mfa_phone_otp_length",
+  "mfa_phone_template",
+  "nimbus_oauth_client_id",
+  "nimbus_oauth_client_secret",
+  "oauth_server_enabled",
+  "oauth_server_allow_dynamic_registration",
+  "oauth_server_authorization_path",
+  "custom_oauth_enabled"
+]