smoonb 0.0.6 → 0.0.8

package/src/services/introspect.js

@@ -0,0 +1,299 @@
+const { createClient } = require('@supabase/supabase-js');
+const { runCommand } = require('./cli');
+
+/**
+ * Serviço de introspecção do banco de dados Supabase
+ */
+class IntrospectionService {
+  constructor(config) {
+    this.config = config;
+    this.supabase = createClient(config.supabase.url, config.supabase.serviceKey);
+  }
+
+  /**
+   * Executa query SQL no banco
+   * @param {string} query - Query SQL
+   * @returns {Promise<any[]>} - Resultado da query
+   */
+  async executeQuery(query) {
+    const { data, error } = await this.supabase.rpc('exec_sql', { sql: query });
+    if (error) {
+      throw new Error(`Erro na query: ${error.message}`);
+    }
+    return data || [];
+  }
+
+  /**
+   * Obtém inventário de extensões
+   * @returns {Promise<object>} - Lista de extensões
+   */
+  async getExtensions() {
+    try {
+      const query = `SELECT extname, extversion FROM pg_extension ORDER BY extname;`;
+      const result = await this.executeQuery(query);
+      return {
+        extensions: result.map(row => ({
+          name: row.extname,
+          version: row.extversion
+        }))
+      };
+    } catch (error) {
+      console.warn('⚠️ Não foi possível obter extensões:', error.message);
+      return { extensions: [] };
+    }
+  }
+
+  /**
+   * Obtém inventário de tabelas
+   * @returns {Promise<object>} - Lista de tabelas
+   */
+  async getTables() {
+    try {
+      const query = `
+        SELECT schemaname, tablename, tableowner 
+        FROM pg_tables 
+        WHERE schemaname IN ('public', 'auth', 'storage') 
+        ORDER BY schemaname, tablename;
+      `;
+      const result = await this.executeQuery(query);
+      return {
+        tables: result.map(row => ({
+          schema: row.schemaname,
+          name: row.tablename,
+          owner: row.tableowner
+        }))
+      };
+    } catch (error) {
+      console.warn('⚠️ Não foi possível obter tabelas:', error.message);
+      return { tables: [] };
+    }
+  }
+
+  /**
+   * Obtém inventário de políticas RLS
+   * @returns {Promise<object>} - Lista de políticas
+   */
+  async getPolicies() {
+    try {
+      const query = `
+        SELECT schemaname, tablename, policyname, permissive, roles, cmd, qual, with_check
+        FROM pg_policies 
+        ORDER BY schemaname, tablename, policyname;
+      `;
+      const result = await this.executeQuery(query);
+      return {
+        policies: result.map(row => ({
+          schema: row.schemaname,
+          table: row.tablename,
+          name: row.policyname,
+          permissive: row.permissive,
+          roles: row.roles,
+          command: row.cmd,
+          qual: row.qual,
+          withCheck: row.with_check
+        }))
+      };
+    } catch (error) {
+      console.warn('⚠️ Não foi possível obter políticas:', error.message);
+      return { policies: [] };
+    }
+  }
+
+  /**
+   * Obtém inventário de configurações RLS
+   * @returns {Promise<object>} - Status RLS por tabela
+   */
+  async getRLSStatus() {
+    try {
+      const query = `
+        SELECT n.nspname as schema_name, c.relname as table_name, c.relrowsecurity, c.relforcerowsecurity
+        FROM pg_class c
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relkind = 'r' AND n.nspname IN ('public', 'auth', 'storage')
+        ORDER BY n.nspname, c.relname;
+      `;
+      const result = await this.executeQuery(query);
+      return {
+        rlsStatus: result.map(row => ({
+          schema: row.schema_name,
+          table: row.table_name,
+          rowSecurityEnabled: row.relrowsecurity,
+          forceRowSecurity: row.relforcerowsecurity
+        }))
+      };
+    } catch (error) {
+      console.warn('⚠️ Não foi possível obter status RLS:', error.message);
+      return { rlsStatus: [] };
+    }
+  }
+
+  /**
+   * Obtém inventário de publicações Realtime
+   * @returns {Promise<object>} - Lista de publicações
+   */
+  async getRealtimePublications() {
+    try {
+      const publicationsQuery = `SELECT pubname FROM pg_publication ORDER BY pubname;`;
+      const publications = await this.executeQuery(publicationsQuery);
+
+      const publicationTablesQuery = `
+        SELECT p.pubname, c.relname as table_name, n.nspname as schema_name
+        FROM pg_publication_tables pt
+        JOIN pg_publication p ON p.oid = pt.ptpubid
+        JOIN pg_class c ON c.oid = pt.ptrelid
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        ORDER BY p.pubname, n.nspname, c.relname;
+      `;
+      const publicationTables = await this.executeQuery(publicationTablesQuery);
+
+      return {
+        publications: publications.map(row => ({
+          name: row.pubname,
+          tables: publicationTables
+            .filter(pt => pt.pubname === row.pubname)
+            .map(pt => ({
+              schema: pt.schema_name,
+              table: pt.table_name
+            }))
+        }))
+      };
+    } catch (error) {
+      console.warn('⚠️ Não foi possível obter publicações Realtime:', error.message);
+      return { publications: [] };
+    }
+  }
+
+  /**
+   * Obtém inventário de buckets de Storage
+   * @returns {Promise<object>} - Lista de buckets e objetos
+   */
+  async getStorageInventory() {
+    try {
+      const { data: buckets, error: bucketsError } = await this.supabase.storage.listBuckets();
+      
+      if (bucketsError) {
+        throw new Error(bucketsError.message);
+      }
+
+      const inventory = {
+        buckets: []
+      };
+
+      for (const bucket of buckets) {
+        const bucketInfo = {
+          id: bucket.id,
+          name: bucket.name,
+          public: bucket.public,
+          file_size_limit: bucket.file_size_limit,
+          allowed_mime_types: bucket.allowed_mime_types,
+          objects: []
+        };
+
+        try {
+          // Listar objetos do bucket (sem baixar conteúdo)
+          const { data: objects, error: objectsError } = await this.supabase.storage
+            .from(bucket.name)
+            .list('', { limit: 1000 });
+
+          if (!objectsError && objects) {
+            bucketInfo.objects = objects.map(obj => ({
+              name: obj.name,
+              size: obj.metadata?.size,
+              last_modified: obj.updated_at,
+              content_type: obj.metadata?.mimetype
+            }));
+          }
+        } catch (error) {
+          console.warn(`⚠️ Não foi possível listar objetos do bucket ${bucket.name}:`, error.message);
+        }
+
+        inventory.buckets.push(bucketInfo);
+      }
+
+      return inventory;
+    } catch (error) {
+      console.warn('⚠️ Não foi possível obter inventário de Storage:', error.message);
+      return { buckets: [] };
+    }
+  }
+
+  /**
+   * Obtém inventário de Edge Functions
+   * @returns {Promise<object>} - Lista de functions
+   */
+  async getEdgeFunctions() {
+    try {
+      const { stdout } = await runCommand('supabase functions list', {
+        env: { ...process.env, SUPABASE_ACCESS_TOKEN: this.config.supabase.serviceKey }
+      });
+
+      // Parse da saída do comando
+      const functions = [];
+      const lines = stdout.split('\n');
+      
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith('NAME') && !trimmed.startsWith('-')) {
+          const parts = trimmed.split(/\s+/);
+          if (parts.length >= 2) {
+            functions.push({
+              name: parts[0],
+              version: parts[1] || 'unknown',
+              status: parts[2] || 'unknown'
+            });
+          }
+        }
+      }
+
+      return { functions };
+    } catch (error) {
+      console.warn('⚠️ Não foi possível obter Edge Functions:', error.message);
+      return { functions: [] };
+    }
+  }
+
+  /**
+   * Gera inventário completo
+   * @returns {Promise<object>} - Inventário completo
+   */
+  async generateFullInventory() {
+    console.log('🔍 Gerando inventário completo...');
+
+    const inventory = {
+      generated_at: new Date().toISOString(),
+      project_id: this.config.supabase.projectId,
+      components: {}
+    };
+
+    // Extensões
+    if (this.config.backup.includeRealtime) {
+      inventory.components.extensions = await this.getExtensions();
+    }
+
+    // Tabelas
+    inventory.components.tables = await this.getTables();
+
+    // Políticas RLS
+    inventory.components.policies = await this.getPolicies();
+    inventory.components.rlsStatus = await this.getRLSStatus();
+
+    // Realtime
+    if (this.config.backup.includeRealtime) {
+      inventory.components.realtime = await this.getRealtimePublications();
+    }
+
+    // Storage
+    if (this.config.backup.includeStorage) {
+      inventory.components.storage = await this.getStorageInventory();
+    }
+
+    // Edge Functions
+    if (this.config.backup.includeFunctions) {
+      inventory.components.functions = await this.getEdgeFunctions();
+    }
+
+    return inventory;
+  }
+}
+
+module.exports = { IntrospectionService };

package/src/utils/cli.js

@@ -0,0 +1,87 @@
+const { spawn } = require('child_process');
+const { promisify } = require('util');
+const exec = promisify(require('child_process').exec);
+
+/**
+ * Detecta se um binário está disponível no PATH
+ * @param {string} name - Nome do binário (ex: 'supabase', 'psql')
+ * @returns {Promise<string|null>} - Caminho do binário ou null se não encontrado
+ */
+async function ensureBin(name) {
+  try {
+    const command = process.platform === 'win32' ? `where ${name}` : `which ${name}`;
+    const { stdout } = await exec(command);
+    const path = stdout.trim().split('\n')[0];
+    return path || null;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Executa um comando e retorna resultado estruturado
+ * @param {string} cmd - Comando principal
+ * @param {string[]} args - Argumentos do comando
+ * @param {object} opts - Opções adicionais (cwd, env, etc.)
+ * @returns {Promise<{code: number, stdout: string, stderr: string}>}
+ */
+async function run(cmd, args = [], opts = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      ...opts
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve({ code, stdout, stderr });
+      } else {
+        const error = new Error(`Comando falhou com código ${code}: ${cmd} ${args.join(' ')}`);
+        error.code = code;
+        error.stdout = stdout;
+        error.stderr = stderr;
+        reject(error);
+      }
+    });
+
+    child.on('error', (error) => {
+      reject(new Error(`Erro ao executar comando: ${error.message}`));
+    });
+  });
+}
+
+/**
+ * Executa um comando simples (string completa)
+ * @param {string} command - Comando completo
+ * @param {object} opts - Opções adicionais
+ * @returns {Promise<{code: number, stdout: string, stderr: string}>}
+ */
+async function runCommand(command, opts = {}) {
+  try {
+    const { stdout, stderr } = await exec(command, opts);
+    return { code: 0, stdout, stderr };
+  } catch (error) {
+    return {
+      code: error.code || 1,
+      stdout: error.stdout || '',
+      stderr: error.stderr || error.message
+    };
+  }
+}
+
+module.exports = {
+  ensureBin,
+  run,
+  runCommand
+};

package/src/utils/config.js

@@ -0,0 +1,140 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Lê configuração do .smoonbrc
+ * @returns {Promise<object>} - Configuração carregada com defaults
+ */
+async function readConfig() {
+  const configPaths = [
+    path.join(process.cwd(), '.smoonbrc'),
+    path.join(os.homedir(), '.smoonbrc')
+  ];
+
+  let configContent = null;
+  let configPath = null;
+
+  for (const configPathCandidate of configPaths) {
+    try {
+      if (fs.existsSync(configPathCandidate)) {
+        configContent = fs.readFileSync(configPathCandidate, 'utf8');
+        configPath = configPathCandidate;
+        break;
+      }
+    } catch (error) {
+      // Continue para próximo caminho
+    }
+  }
+
+  if (!configContent) {
+    throw new Error('Arquivo .smoonbrc não encontrado. Execute: npx smoonb config --init');
+  }
+
+  let config;
+  try {
+    config = JSON.parse(configContent);
+  } catch (error) {
+    throw new Error(`Erro ao parsear .smoonbrc: ${error.message}`);
+  }
+
+  // Aplicar defaults
+  const defaultConfig = {
+    backup: {
+      includeFunctions: true,
+      includeStorage: true,
+      includeAuth: true,
+      includeRealtime: true,
+      outputDir: './backups'
+    },
+    restore: {
+      cleanRestore: true,
+      verifyAfterRestore: true
+    }
+  };
+
+  const mergedConfig = mergeDeep(defaultConfig, config);
+
+  // Warning para pgDumpPath deprecated
+  if (mergedConfig.backup?.pgDumpPath) {
+    console.warn('⚠️ backup.pgDumpPath será ignorado na v0.0.8 (usando Supabase CLI).');
+    delete mergedConfig.backup.pgDumpPath;
+  }
+
+  return mergedConfig;
+}
+
+/**
+ * Valida configuração para uma ação específica
+ * @param {object} config - Configuração carregada
+ * @param {string} action - Ação ('backup', 'restore', 'inventory')
+ * @throws {Error} - Se configuração inválida
+ */
+function validateFor(config, action) {
+  const errors = [];
+
+  switch (action) {
+    case 'backup':
+    case 'restore':
+      if (!config.supabase?.databaseUrl) {
+        errors.push('supabase.databaseUrl é obrigatório');
+      }
+      break;
+
+    case 'inventory':
+      if (!config.supabase?.url) {
+        errors.push('supabase.url é obrigatório');
+      }
+      if (!config.supabase?.serviceKey) {
+        errors.push('supabase.serviceKey é obrigatório');
+      }
+      break;
+  }
+
+  if (errors.length > 0) {
+    throw new Error(`Configuração inválida para ${action}: ${errors.join(', ')}`);
+  }
+}
+
+/**
+ * Merge profundo de objetos
+ * @param {object} target - Objeto destino
+ * @param {object} source - Objeto origem
+ * @returns {object} - Objeto mesclado
+ */
+function mergeDeep(target, source) {
+  const result = { ...target };
+
+  for (const key in source) {
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      result[key] = mergeDeep(target[key] || {}, source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Salva configuração no .smoonbrc
+ * @param {object} config - Configuração para salvar
+ * @param {string} targetPath - Caminho de destino (opcional)
+ */
+async function saveConfig(config, targetPath = null) {
+  const configPath = targetPath || path.join(process.cwd(), '.smoonbrc');
+  
+  // Remover pgDumpPath se existir
+  if (config.backup?.pgDumpPath) {
+    delete config.backup.pgDumpPath;
+  }
+
+  const jsonContent = JSON.stringify(config, null, 2);
+  await fs.promises.writeFile(configPath, jsonContent, 'utf8');
+}
+
+module.exports = {
+  readConfig,
+  validateFor,
+  saveConfig
+};

package/src/utils/fsx.js

@@ -0,0 +1,110 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Copia um diretório recursivamente
+ * @param {string} src - Diretório origem
+ * @param {string} dest - Diretório destino
+ * @returns {Promise<void>}
+ */
+async function copyDir(src, dest) {
+  try {
+    // Node.js 18+ tem fs.promises.cp
+    if (fs.promises.cp) {
+      await fs.promises.cp(src, dest, { recursive: true });
+      return;
+    }
+  } catch (error) {
+    // Fallback para fs-extra se disponível
+    try {
+      const fse = require('fs-extra');
+      await fse.copy(src, dest);
+      return;
+    } catch (fseError) {
+      // Fallback manual usando fs nativo
+    }
+  }
+
+  // Fallback manual usando fs nativo
+  await copyDirManual(src, dest);
+}
+
+/**
+ * Implementação manual de cópia de diretório
+ * @param {string} src - Diretório origem
+ * @param {string} dest - Diretório destino
+ */
+async function copyDirManual(src, dest) {
+  const stat = await fs.promises.stat(src);
+  
+  if (stat.isDirectory()) {
+    await fs.promises.mkdir(dest, { recursive: true });
+    const entries = await fs.promises.readdir(src);
+    
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry);
+      const destPath = path.join(dest, entry);
+      await copyDirManual(srcPath, destPath);
+    }
+  } else {
+    await fs.promises.copyFile(src, dest);
+  }
+}
+
+/**
+ * Cria diretório se não existir
+ * @param {string} dirPath - Caminho do diretório
+ * @returns {Promise<void>}
+ */
+async function ensureDir(dirPath) {
+  try {
+    await fs.promises.mkdir(dirPath, { recursive: true });
+  } catch (error) {
+    if (error.code !== 'EEXIST') {
+      throw error;
+    }
+  }
+}
+
+/**
+ * Verifica se um arquivo existe
+ * @param {string} filePath - Caminho do arquivo
+ * @returns {Promise<boolean>}
+ */
+async function exists(filePath) {
+  try {
+    await fs.promises.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Escreve JSON de forma segura
+ * @param {string} filePath - Caminho do arquivo
+ * @param {any} data - Dados para escrever
+ * @param {number} spaces - Espaços para indentação (padrão: 2)
+ */
+async function writeJson(filePath, data, spaces = 2) {
+  const json = JSON.stringify(data, null, spaces);
+  await fs.promises.writeFile(filePath, json, 'utf8');
+}
+
+/**
+ * Lê JSON de forma segura
+ * @param {string} filePath - Caminho do arquivo
+ * @returns {Promise<any>}
+ */
+async function readJson(filePath) {
+  const content = await fs.promises.readFile(filePath, 'utf8');
+  return JSON.parse(content);
+}
+
+module.exports = {
+  copyDir,
+  ensureDir,
+  exists,
+  writeJson,
+  readJson
+};

package/src/utils/hash.js

@@ -0,0 +1,40 @@
+const crypto = require('crypto');
+const fs = require('fs');
+
+/**
+ * Calcula SHA256 de um arquivo usando stream
+ * @param {string} filePath - Caminho do arquivo
+ * @returns {Promise<string>} - Hash SHA256 em hexadecimal
+ */
+async function sha256(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash('sha256');
+    const stream = fs.createReadStream(filePath);
+
+    stream.on('data', (data) => {
+      hash.update(data);
+    });
+
+    stream.on('end', () => {
+      resolve(hash.digest('hex'));
+    });
+
+    stream.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
+/**
+ * Calcula SHA256 de uma string
+ * @param {string} data - String para calcular hash
+ * @returns {string} - Hash SHA256 em hexadecimal
+ */
+function sha256String(data) {
+  return crypto.createHash('sha256').update(data).digest('hex');
+}
+
+module.exports = {
+  sha256,
+  sha256String
+};