smoonb 1.0.6 → 1.0.7

package/package.json

@@ -1,66 +1,67 @@
-{
-  "name": "smoonb",
-  "version": "1.0.6",
-  "description": "Complete Supabase backup and migration tool. https://www.smoonb.com/#price",
-  "preferGlobal": false,
-  "preventGlobalInstall": true,
-  "main": "index.js",
-  "bin": {
-    "smoonb": "bin/smoonb.js"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "start": "node bin/smoonb.js",
-    "preinstall": "node -e \"if(process.env.npm_config_global) { console.error('\\n❌ SMOONB NÃO DEVE SER INSTALADO GLOBALMENTE!\\n\\n📋 Para usar o smoonb, instale localmente no seu projeto:\\n   npm install smoonb\\n\\n💡 Depois execute com:\\n   npx smoonb backup\\n\\n🚫 Instalação global cancelada!\\n'); process.exit(1); }\"",
-    "postinstall": "echo '\\n✅ smoonb instalado com sucesso!\\n💡 Execute: npx smoonb backup\\n📖 Documentação: https://github.com/almmello/smoonb\\n'",
-    "lint": "eslint . --ext .js",
-    "lint:fix": "eslint . --ext .js --fix",
-    "build": "node scripts/build.js",
-    "build:check": "node scripts/build.js",
-    "prepublishOnly": "node scripts/build.js"
-  },
-  "keywords": [
-    "supabase",
-    "backup",
-    "migration",
-    "postgresql",
-    "edge-functions",
-    "database",
-    "cli",
-    "tool"
-  ],
-  "author": "Goalmoon Tecnologia LTDA <https://www.smoonb.com>",
-  "license": "SEE LICENSE IN LICENSE.md",
-  "engines": {
-    "node": ">=16.0.0"
-  },
-  "dependencies": {
-    "@supabase/supabase-js": "^2.93.0",
-    "adm-zip": "^0.5.16",
-    "chalk": "^4.1.2",
-    "commander": "^11.1.0",
-    "env-paths": "^4.0.0",
-    "inquirer": "^8.2.7"
-  },
-  "type": "commonjs",
-  "devDependencies": {
-    "eslint": "^9.38.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/almmello/smoonb.git"
-  },
-  "bugs": {
-    "url": "https://github.com/almmello/smoonb/issues"
-  },
-  "homepage": "https://www.smoonb.com",
-  "files": [
-    "bin/",
-    "src/",
-    "README.md",
-    "README.pt-BR.md",
-    "LICENSE",
-    "LICENSE.pt-BR.md",
-    "CHANGELOG.md"
-  ]
-}
+{
+  "name": "smoonb",
+  "version": "1.0.7",
+  "description": "Complete Supabase backup and migration tool. https://www.smoonb.com/#price",
+  "preferGlobal": false,
+  "preventGlobalInstall": true,
+  "main": "index.js",
+  "bin": {
+    "smoonb": "bin/smoonb.js"
+  },
+  "scripts": {
+    "test": "node --test tests/*.test.js",
+    "start": "node bin/smoonb.js",
+    "preinstall": "node -e \"if(process.env.npm_config_global) { console.error('\\n❌ SMOONB NÃO DEVE SER INSTALADO GLOBALMENTE!\\n\\n📋 Para usar o smoonb, instale localmente no seu projeto:\\n   npm install smoonb\\n\\n💡 Depois execute com:\\n   npx smoonb backup\\n\\n🚫 Instalação global cancelada!\\n'); process.exit(1); }\"",
+    "postinstall": "echo '\\n✅ smoonb instalado com sucesso!\\n💡 Execute: npx smoonb backup\\n📖 Documentação: https://github.com/almmello/smoonb\\n'",
+    "lint": "eslint . --ext .js",
+    "lint:fix": "eslint . --ext .js --fix",
+    "build": "node scripts/build.js",
+    "build:check": "node scripts/build.js",
+    "prepublishOnly": "npm test && npm run lint && npm run build",
+    "test:docker": "node tests/integration/circular-restore.js"
+  },
+  "keywords": [
+    "supabase",
+    "backup",
+    "migration",
+    "postgresql",
+    "edge-functions",
+    "database",
+    "cli",
+    "tool"
+  ],
+  "author": "Goalmoon Tecnologia LTDA <https://www.smoonb.com>",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.93.0",
+    "adm-zip": "^0.5.16",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "env-paths": "^4.0.0",
+    "inquirer": "^8.2.7"
+  },
+  "type": "commonjs",
+  "devDependencies": {
+    "eslint": "^9.38.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/almmello/smoonb.git"
+  },
+  "bugs": {
+    "url": "https://github.com/almmello/smoonb/issues"
+  },
+  "homepage": "https://www.smoonb.com",
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "README.pt-BR.md",
+    "LICENSE",
+    "LICENSE.pt-BR.md",
+    "CHANGELOG.md"
+  ]
+}

package/src/commands/backup/index.js

@@ -267,7 +267,9 @@ module.exports = async (options) => {
     const dbSeparatedResult = await step03DatabaseSeparated(context);
     manifest.components.database_separated = {
       success: dbSeparatedResult.success,
-      method: 'supabase-cli',
+      method: 'supabase-cli',
+      warnings: dbSeparatedResult.warnings || [],
+      failed_files: dbSeparatedResult.failedFiles || [],
       files: dbSeparatedResult.files || [],
       total_size_kb: dbSeparatedResult.totalSizeKB || '0.0'
     };
@@ -339,7 +341,11 @@ module.exports = async (options) => {
     console.log(chalk.green(`\n🎉 ${getT('backup.complete.title')}`));
     console.log(chalk.blue(`📁 ${getT('backup.complete.location', { path: finalBackupDir })}`));
     console.log(chalk.green(`📊 ${getT('backup.complete.database', { fileName: databaseResult.fileName, size: `${databaseResult.size} KB` })}`));
-    console.log(chalk.green(`📊 ${getT('backup.complete.databaseSql', { count: dbSeparatedResult.files?.length || 0, size: `${dbSeparatedResult.totalSizeKB} KB` })}`));
+    if (dbSeparatedResult.success) {
+      console.log(chalk.green(`📊 ${getT('backup.complete.databaseSql', { count: dbSeparatedResult.files?.length || 0, size: `${dbSeparatedResult.totalSizeKB} KB` })}`));
+    } else {
+      console.log(chalk.yellow(`⚠️ ${getT('backup.steps.database.separated.incomplete', { files: (dbSeparatedResult.failedFiles || []).join(', ') })}`));
+    }
     console.log(chalk.green(`🔧 ${getT('backup.complete.databaseSettings', { fileName: databaseSettingsResult.fileName, size: `${databaseSettingsResult.size} KB` })}`));
     
     if (flags?.includeAuth && manifest.components.auth_settings) {

package/src/commands/backup/steps/03-database-separated.js

@@ -1,114 +1,161 @@
-const chalk = require('chalk');
-const path = require('path');
-const fs = require('fs').promises;
-const { spawn } = require('child_process');
-const { t } = require('../../../i18n');
-
-function runWithElapsedTicker(command, args, env, label) {
-  return new Promise((resolve, reject) => {
-    const start = Date.now();
-    const ticker = setInterval(() => {
-      const elapsed = Math.floor((Date.now() - start) / 1000);
-      process.stdout.write(`\r     ⏱ ${label} ${elapsed}s`);
-    }, 1000);
-    const proc = spawn(command, args, {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      shell: true,
-      env: { ...process.env, ...env }
-    });
-    proc.stderr.on('data', (chunk) => process.stderr.write(chunk));
-    proc.on('close', (code) => {
-      clearInterval(ticker);
-      process.stdout.write('\r' + ' '.repeat(60) + '\r');
-      if (code !== 0) reject(new Error(`Exited with code ${code}`));
-      else resolve();
-    });
-    proc.on('error', reject);
-  });
-}
-
-/**
- * Etapa 2: Backup Database Separado (SQL files para troubleshooting)
- */
-module.exports = async ({ databaseUrl, backupDir, accessToken }) => {
-  try {
-    const getT = global.smoonbI18n?.t || t;
-    console.log(chalk.white(`   - ${getT('backup.steps.database.separated.creating')}`));
-    
-    const dbUrl = databaseUrl;
-    const files = [];
-    let totalSizeKB = 0;
-    
-    // 1. Backup do Schema
-    console.log(chalk.white(`   - ${getT('backup.steps.database.separated.exportingSchema')}`));
-    const schemaFile = path.join(backupDir, 'schema.sql');
-    
-    try {
-      await runWithElapsedTicker(
-        `supabase db dump --db-url "${dbUrl}" -f "${schemaFile}"`,
-        [],
-        { SUPABASE_ACCESS_TOKEN: accessToken || '' },
-        getT('backup.steps.database.separated.exportingSchema')
-      );
-      const stats = await fs.stat(schemaFile);
-      const sizeKB = (stats.size / 1024).toFixed(1);
-      files.push({ filename: 'schema.sql', sizeKB });
-      totalSizeKB += parseFloat(sizeKB);
-      console.log(chalk.green(`     ✅ Schema: ${sizeKB} KB`));
-    } catch (error) {
-      console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.schemaError', { message: error.message })}`));
-    }
-    
-    // 2. Backup dos Dados
-    console.log(chalk.white(`   - ${getT('backup.steps.database.separated.exportingData')}`));
-    const dataFile = path.join(backupDir, 'data.sql');
-    
-    try {
-      await runWithElapsedTicker(
-        `supabase db dump --db-url "${dbUrl}" --data-only -f "${dataFile}"`,
-        [],
-        { SUPABASE_ACCESS_TOKEN: accessToken || '' },
-        getT('backup.steps.database.separated.exportingData')
-      );
-      const stats = await fs.stat(dataFile);
-      const sizeKB = (stats.size / 1024).toFixed(1);
-      files.push({ filename: 'data.sql', sizeKB });
-      totalSizeKB += parseFloat(sizeKB);
-      console.log(chalk.green(`     ✅ Data: ${sizeKB} KB`));
-    } catch (error) {
-      console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.dataError', { message: error.message })}`));
-    }
-    
-    // 3. Backup dos Roles
-    console.log(chalk.white(`   - ${getT('backup.steps.database.separated.exportingRoles')}`));
-    const rolesFile = path.join(backupDir, 'roles.sql');
-    
-    try {
-      await runWithElapsedTicker(
-        `supabase db dump --db-url "${dbUrl}" --role-only -f "${rolesFile}"`,
-        [],
-        { SUPABASE_ACCESS_TOKEN: accessToken || '' },
-        getT('backup.steps.database.separated.exportingRoles')
-      );
-      const stats = await fs.stat(rolesFile);
-      const sizeKB = (stats.size / 1024).toFixed(1);
-      files.push({ filename: 'roles.sql', sizeKB });
-      totalSizeKB += parseFloat(sizeKB);
-      console.log(chalk.green(`     ✅ Roles: ${sizeKB} KB`));
-    } catch (error) {
-      console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.rolesError', { message: error.message })}`));
-    }
-    
-    return { 
-      success: files.length > 0, 
-      files, 
-      totalSizeKB: totalSizeKB.toFixed(1) 
-    };
-    
-  } catch (error) {
-    const getT = global.smoonbI18n?.t || t;
-    console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.error', { message: error.message })}`));
-    return { success: false, files: [], totalSizeKB: '0.0' };
-  }
-};
-
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs').promises;
+const { spawn } = require('child_process');
+const { t } = require('../../../i18n');
+const { createPgDumpDiagnostics, hasReplicaRolePrologue } = require('../../../utils/pg-dump-diagnostics');
+
+function runWithElapsedTicker(command, args, env, label, collectWarnings = false) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const useTty = Boolean(process.stdout.isTTY);
+    const clearTicker = () => {
+      if (useTty) process.stdout.write('\r' + ' '.repeat(80) + '\r');
+    };
+    const diagnostics = createPgDumpDiagnostics(chunk => {
+      clearTicker();
+      process.stderr.write(chunk);
+    });
+    const ticker = useTty ? setInterval(() => {
+      const elapsed = Math.floor((Date.now() - start) / 1000);
+      process.stdout.write(`\r     ⏱ ${label} ${elapsed}s`);
+    }, 1000) : null;
+    let settled = false;
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      clearInterval(ticker);
+      clearTicker();
+      const result = diagnostics.end();
+      if (error) {
+        // A failed export must never hide the diagnostics already collected.
+        if (result.messages.length) process.stderr.write(result.messages.join('\n') + '\n');
+        reject(error);
+      } else resolve(result);
+    };
+    try {
+      const proc = spawn(command, args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        shell: true,
+        env: { ...process.env, ...env }
+      });
+      // Drain stdout as well, so a verbose CLI cannot fill its pipe and hang.
+      proc.stdout.on('data', chunk => { clearTicker(); process.stdout.write(chunk); });
+      proc.stderr.on('data', chunk => {
+        if (collectWarnings) diagnostics.write(chunk);
+        else { clearTicker(); process.stderr.write(chunk); }
+      });
+      proc.on('close', code => finish(code === 0 ? null : new Error(`Exited with code ${code}`)));
+      proc.on('error', finish);
+    } catch (error) {
+      finish(error);
+    }
+  });
+}
+
+/**
+ * Etapa 2: Backup Database Separado (SQL files para troubleshooting)
+ */
+function createDatabaseSeparatedStep(runDump = runWithElapsedTicker) {
+  return async ({ databaseUrl, backupDir, accessToken }) => {
+    try {
+      const getT = global.smoonbI18n?.t || t;
+      console.log(chalk.white(`   - ${getT('backup.steps.database.separated.creating')}`));
+
+      const dbUrl = databaseUrl;
+      const files = [];
+      let totalSizeKB = 0;
+      const warnings = [];
+      const failedFiles = [];
+
+      // 1. Backup do Schema
+      console.log(chalk.white(`   - ${getT('backup.steps.database.separated.exportingSchema')}`));
+      const schemaFile = path.join(backupDir, 'schema.sql');
+
+      try {
+        await runDump(
+          `supabase db dump --db-url "${dbUrl}" -f "${schemaFile}"`,
+          [],
+          { SUPABASE_ACCESS_TOKEN: accessToken || '' },
+          getT('backup.steps.database.separated.exportingSchema')
+        );
+        const stats = await fs.stat(schemaFile);
+        const sizeKB = (stats.size / 1024).toFixed(1);
+        files.push({ filename: 'schema.sql', sizeKB });
+        totalSizeKB += parseFloat(sizeKB);
+        console.log(chalk.green(`     ✅ Schema: ${sizeKB} KB`));
+      } catch (error) {
+        failedFiles.push('schema.sql');
+        console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.schemaError', { message: error.message })}`));
+      }
+
+      // 2. Backup dos Dados
+      console.log(chalk.white(`   - ${getT('backup.steps.database.separated.exportingData')}`));
+      const dataFile = path.join(backupDir, 'data.sql');
+
+      try {
+        const diagnostics = await runDump(
+          `supabase db dump --db-url "${dbUrl}" --data-only -f "${dataFile}"`,
+          [],
+          { SUPABASE_ACCESS_TOKEN: accessToken || '' },
+          getT('backup.steps.database.separated.exportingData'),
+          true
+        );
+        const stats = await fs.stat(dataFile);
+        if (diagnostics.circularForeignKeys) {
+          const replicaRolePrologue = await hasReplicaRolePrologue(dataFile);
+          warnings.push({ code: 'CIRCULAR_FOREIGN_KEYS', ...diagnostics, replicaRolePrologue });
+          console.log(chalk.cyan(`     ℹ️ ${getT('backup.steps.database.separated.circularSummary', { tables: diagnostics.tables.join(', ') })}`));
+          console.log(chalk.yellow(`     ⚠️ ${getT(replicaRolePrologue
+            ? 'backup.steps.database.separated.circularProtected'
+            : 'backup.steps.database.separated.circularUnprotected')}`));
+        }
+        const sizeKB = (stats.size / 1024).toFixed(1);
+        files.push({ filename: 'data.sql', sizeKB });
+        totalSizeKB += parseFloat(sizeKB);
+        console.log(chalk.green(`     ✅ Data: ${sizeKB} KB`));
+      } catch (error) {
+        failedFiles.push('data.sql');
+        console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.dataError', { message: error.message })}`));
+      }
+
+      // 3. Backup dos Roles
+      console.log(chalk.white(`   - ${getT('backup.steps.database.separated.exportingRoles')}`));
+      const rolesFile = path.join(backupDir, 'roles.sql');
+
+      try {
+        await runDump(
+          `supabase db dump --db-url "${dbUrl}" --role-only -f "${rolesFile}"`,
+          [],
+          { SUPABASE_ACCESS_TOKEN: accessToken || '' },
+          getT('backup.steps.database.separated.exportingRoles')
+        );
+        const stats = await fs.stat(rolesFile);
+        const sizeKB = (stats.size / 1024).toFixed(1);
+        files.push({ filename: 'roles.sql', sizeKB });
+        totalSizeKB += parseFloat(sizeKB);
+        console.log(chalk.green(`     ✅ Roles: ${sizeKB} KB`));
+      } catch (error) {
+        failedFiles.push('roles.sql');
+        console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.rolesError', { message: error.message })}`));
+      }
+
+      return {
+        success: files.length === 3,
+        warnings,
+        failedFiles,
+        files,
+        totalSizeKB: totalSizeKB.toFixed(1)
+      };
+
+    } catch (error) {
+      const getT = global.smoonbI18n?.t || t;
+      console.log(chalk.yellow(`     ⚠️ ${getT('backup.steps.database.separated.error', { message: error.message })}`));
+      return { success: false, files: [], warnings: [], failedFiles: ['schema.sql', 'data.sql', 'roles.sql'], totalSizeKB: '0.0' };
+    }
+  };
+}
+
+module.exports = createDatabaseSeparatedStep();
+module.exports.createDatabaseSeparatedStep = createDatabaseSeparatedStep;
+module.exports.runWithElapsedTicker = runWithElapsedTicker;

package/src/i18n/locales/en.json

@@ -411,6 +411,10 @@
   "backup.steps.database.separated.creating": "Creating separate SQL backups via Supabase CLI...",
   "backup.steps.database.separated.exportingSchema": "Exporting schema...",
   "backup.steps.database.separated.exportingData": "Exporting data...",
+  "backup.steps.database.separated.circularSummary": "Data export completed with circular foreign-key warnings: {tables}. These warnings do not mean the export failed.",
+  "backup.steps.database.separated.circularProtected": "data.sql starts with SET session_replication_role = replica. Restore schema before data, using a role allowed to change this setting and ON_ERROR_STOP=1. Test restoration before relying on this backup.",
+  "backup.steps.database.separated.circularUnprotected": "No replica-role prologue was found in data.sql. Circular references may prevent restoration. Follow the Supabase restore procedure and test in an isolated database.",
+  "backup.steps.database.separated.incomplete": "Separate SQL backup is incomplete. Failed files: {files}.",
   "backup.steps.database.separated.exportingRoles": "Exporting roles...",
 
   "backup.steps.databaseSettings.title": "Database Extensions and Settings Backup via SQL...",

package/src/i18n/locales/pt-BR.json

@@ -411,6 +411,10 @@
   "backup.steps.database.separated.creating": "Criando backups SQL separados via Supabase CLI...",
   "backup.steps.database.separated.exportingSchema": "Exportando schema...",
   "backup.steps.database.separated.exportingData": "Exportando dados...",
+  "backup.steps.database.separated.circularSummary": "Exportação dos dados concluída com avisos de chaves estrangeiras circulares: {tables}. Esses avisos não significam falha na exportação.",
+  "backup.steps.database.separated.circularProtected": "data.sql começa com SET session_replication_role = replica. Restaure o schema antes dos dados, com uma role autorizada a alterar essa configuração e ON_ERROR_STOP=1. Teste a restauração antes de depender deste backup.",
+  "backup.steps.database.separated.circularUnprotected": "O início de data.sql não contém a configuração replica. As referências circulares podem impedir a restauração. Siga o procedimento do Supabase e teste em banco isolado.",
+  "backup.steps.database.separated.incomplete": "Backup SQL separado incompleto. Arquivos que falharam: {files}.",
   "backup.steps.database.separated.exportingRoles": "Exportando roles...",
 
   "backup.steps.databaseSettings.title": "Backup das Database Extensions and Settings via SQL...",

package/src/utils/pg-dump-diagnostics.js

@@ -0,0 +1,64 @@
+const { StringDecoder } = require('string_decoder');
+const fs = require('fs').promises;
+
+// Only the exact, known pg_dump circular-FK block is consolidated. All other
+// stderr (including errors and unfamiliar/localized warnings) remains visible.
+function createPgDumpDiagnostics(writeStderr) {
+  const decoder = new StringDecoder('utf8');
+  let pending = '';
+  let inCircularWarning = false;
+  const warnings = [];
+  const tables = new Set();
+  const hints = new Set([
+    'pg_dump: hint: You might not be able to restore the dump without using --disable-triggers or temporarily dropping the constraints.',
+    'pg_dump: hint: Consider using a full dump instead of a --data-only dump to avoid this problem.'
+  ]);
+  function line(raw) {
+    const text = raw.replace(/\r?\n$/, '');
+    if (/^pg_dump: warning: there are circular foreign-key constraints (?:among these tables|on this table):$/.test(text)) {
+      inCircularWarning = true;
+      warnings.push(text);
+    } else if (inCircularWarning && text.startsWith('pg_dump: detail: ')) {
+      tables.add(text.slice('pg_dump: detail: '.length));
+      warnings.push(text);
+    } else if (inCircularWarning && hints.has(text)) {
+      warnings.push(text);
+    } else {
+      inCircularWarning = false;
+      writeStderr(raw);
+    }
+  }
+  function consume(text) {
+    pending += text;
+    let end;
+    while ((end = pending.indexOf('\n')) !== -1) {
+      line(pending.slice(0, end + 1));
+      pending = pending.slice(end + 1);
+    }
+  }
+  return {
+    write(chunk) { consume(decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))); },
+    end() {
+      consume(decoder.end());
+      if (pending) line(pending);
+      pending = '';
+      return { circularForeignKeys: warnings.length > 0, tables: [...tables], messages: warnings };
+    }
+  };
+}
+
+// Supabase prepends this command before pg_dump output. Check the first line,
+// not arbitrary table contents: a data row containing SQL is not protection.
+async function hasReplicaRolePrologue(file) {
+  const handle = await fs.open(file, 'r');
+  try {
+    const buffer = Buffer.alloc(256);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    const firstLine = buffer.toString('utf8', 0, bytesRead).split('\n')[0].replace(/^\uFEFF/, '').trim();
+    return /^SET\s+session_replication_role\s*=\s*(?:replica|'replica');$/i.test(firstLine);
+  } finally {
+    await handle.close();
+  }
+}
+
+module.exports = { createPgDumpDiagnostics, hasReplicaRolePrologue };