cartorio-plataforma-cli/lib/module-discovery.js

CLI para gerenciar a Plataforma do Cartório de Criciúma com sistema de módulos

/**
 * Módulo para descoberta de arquivos de manifesto de módulos no projeto
 */
const fs = require('fs');
const path = require('path');

/**
 * Função para descobrir módulos com base em arquivos de manifesto
 * @param {string} rootDir - Diretório raiz do projeto onde fazer a busca
 * @returns {Object} - Objeto contendo os módulos encontrados, categorizados por tipo
 */
function discoverModules(rootDir) {
  console.log(`Iniciando busca por módulos no diretório: ${rootDir}`);
  
  const modules = {
    core: [],
    frontends: [],
    backends: [],
    infrastructure: []
  };
  
  // Lista de diretórios para ignorar
  const ignoreDirs = [
    'node_modules',
    '.git',
    'dist',
    'build',
    'coverage',
    'logs',
    'tmp',
    'temp',
    'letsencrypt'
  ];
  
  // Função para buscar manifestos recursivamente até certa profundidade
  function findManifests(dir, depth = 0) {
    if (depth > 3) return []; // Aumentar profundidade da busca para 3
    
    try {
      const items = fs.readdirSync(dir, { withFileTypes: true });
      let manifests = [];
      
      for (const item of items) {
        const itemPath = path.join(dir, item.name);
        
        if (item.isDirectory()) {
          // Pular diretórios que devem ser ignorados
          if (ignoreDirs.includes(item.name)) {
            continue;
          }
          
          // Buscar recursivamente em subdiretórios
          manifests = [...manifests, ...findManifests(itemPath, depth + 1)];
        } 
        else if (item.name === 'plataforma-manifest.js' || item.name === 'plataforma-manifest.json') {
          console.log(`✅ Manifesto encontrado: ${itemPath}`);
          manifests.push({
            path: dir,
            type: item.name.endsWith('.js') ? 'js' : 'json',
            manifestPath: itemPath
          });
        }
      }
      
      return manifests;
    } catch (error) {
      console.warn(`Aviso: Não foi possível ler o diretório ${dir}: ${error.message}`);
      return [];
    }
  }
  
  // Tentar primeiro buscar no diretório pai (projeto raiz)
  const parentDir = path.resolve(rootDir, '..');
  console.log(`Verificando manifestos no diretório raiz do projeto: ${parentDir}`);
  const projectManifests = findManifests(parentDir);
  
  // Verificar se estamos no diretório plataforma-infra dentro do diretório do projeto
  const projectParts = parentDir.split(path.sep);
  const currentParts = rootDir.split(path.sep);
  
  // Verificar se o diretório atual é "plataforma-infra" no diretório raiz do projeto
  const isInfraDir = currentParts[currentParts.length - 1] === 'plataforma-infra' && 
                     projectParts.length === currentParts.length - 1 && 
                     currentParts.slice(0, -1).join(path.sep) === projectParts.join(path.sep);
                      
  let manifestPaths = [...projectManifests];
  
  // Só verifica o diretório atual se não for plataforma-infra no diretório raiz
  if (!isInfraDir) {
    console.log(`Verificando manifestos no diretório atual: ${rootDir}`);
    const currentDirManifests = findManifests(rootDir);
    manifestPaths = [...manifestPaths, ...currentDirManifests];
  } else {
    console.log(`Diretório atual (${rootDir}) já verificado como parte do diretório raiz.`);
  }
  
  console.log(`Total de manifestos encontrados: ${manifestPaths.length}`);
  
  // Carregar e categorizar os módulos
  manifestPaths.forEach(manifestInfo => {
    try {
      let moduleConfig;
      
      if (manifestInfo.type === 'js') {
        moduleConfig = require(manifestInfo.manifestPath);
      } else {
        moduleConfig = JSON.parse(fs.readFileSync(manifestInfo.manifestPath, 'utf8'));
      }
      
      // Adicionar o caminho ao módulo
      moduleConfig.path = manifestInfo.path;
      
      // Categorizar com base no tipo
      if (moduleConfig.type === 'core') {
        modules.core.push(moduleConfig);
        console.log(`✅ Módulo core registrado: ${moduleConfig.name}`);
      } else if (moduleConfig.type === 'frontend') {
        modules.frontends.push(moduleConfig);
        console.log(`✅ Módulo frontend registrado: ${moduleConfig.name}`);
      } else if (moduleConfig.type === 'backend') {
        modules.backends.push(moduleConfig);
        console.log(`✅ Módulo backend registrado: ${moduleConfig.name}`);
      } else if (moduleConfig.type === 'infrastructure') {
        modules.infrastructure.push(moduleConfig);
        console.log(`✅ Módulo infrastructure registrado: ${moduleConfig.name}`);
      } else {
        console.warn(`⚠️ Módulo com tipo desconhecido ignorado: ${moduleConfig.name} (tipo: ${moduleConfig.type})`);
      }
    } catch (error) {
      console.warn(`Aviso: Erro ao carregar o manifesto ${manifestInfo.manifestPath}: ${error.message}`);
    }
  });
  
  return modules;
}

module.exports = { discoverModules };