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

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

/**
 * Módulo para registrar e gerenciar módulos da plataforma
 */
const { discoverModules } = require('./module-discovery');

/**
 * Classe que gerencia o registro de módulos da plataforma
 */
class ModuleRegistry {
  constructor() {
    this.modules = {
      core: [],
      frontends: [],
      backends: [],
      infrastructure: []
    };
    this.moduleMap = new Map(); // Para busca rápida por ID
    this.moduleLocations = {}; // Registro de localizações dos módulos
  }
  
  /**
   * Carrega todos os módulos encontrados no diretório
   * @param {string} rootDir - Diretório raiz do projeto
   */
  loadModules(rootDir) {
    this.moduleLocations = {
      rootDir: rootDir,
      modules: {}
    };
    
    const discoveredModules = discoverModules(rootDir);
    
    // Registrar os módulos descobertos
    Object.keys(discoveredModules).forEach(category => {
      discoveredModules[category].forEach(module => {
        // Verificar se o módulo já foi registrado
        const uniqueId = `${module.id}-${module.type}`;
        if (!this.moduleMap.has(uniqueId)) {
          this.registerModule(category, module);
          
          // Registrar localização
          this.moduleLocations.modules[uniqueId] = module.path;
        } else {
          console.warn(`⚠️ Módulo duplicado encontrado: ${uniqueId} em ${module.path}. Usando a primeira ocorrência.`);
        }
      });
    });
    
    // Resolver dependências
    this.resolveDependencies();
  }
  
  /**
   * Registra um módulo em uma categoria
   * @param {string} category - Categoria do módulo (core, frontends, backends, infrastructure)
   * @param {Object} module - Configuração do módulo
   */
  registerModule(category, module) {
    this.modules[category].push(module);
    // Criar um identificador único que combina id e tipo
    const uniqueId = `${module.id}-${module.type}`;
    this.moduleMap.set(uniqueId, module);
  }
  
  /**
   * Resolve as dependências entre os módulos
   */
  resolveDependencies() {
    // TODO: Implementar lógica para resolver ordem de dependências
    // Por exemplo, ordenar módulos com base em suas dependências declaradas
  }
  
  /**
   * Obtém módulos de uma categoria específica
   * @param {string} category - Categoria desejada
   * @returns {Array} - Lista de módulos na categoria
   */
  getModulesByCategory(category) {
    return this.modules[category] || [];
  }
  
  /**
   * Obtém todos os módulos registrados
   * @returns {Array} - Lista de todos os módulos
   */
  getAllModules() {
    return [
      ...this.modules.infrastructure,
      ...this.modules.core,
      ...this.modules.frontends,
      ...this.modules.backends
    ];
  }
  
  /**
   * Busca um módulo por ID e tipo
   * @param {string} id - ID do módulo
   * @param {string} type - Tipo do módulo (frontend, backend, etc.) - opcional
   * @returns {Object|null} - Configuração do módulo ou null se não encontrado
   */
  getModuleById(id, type = null) {
    let foundModule = null;
    
    // Se o tipo for fornecido, usamos a busca composta
    if (type) {
      const uniqueId = `${id}-${type}`;
      foundModule = this.moduleMap.get(uniqueId);
      
      if (!foundModule) {
        console.log(`Debug: Módulo não encontrado com ID '${uniqueId}'`);
      }
    } else {
      // Buscar apenas pelo ID do módulo
      for (const [key, module] of this.moduleMap.entries()) {
        if (module.id === id) {
          foundModule = module;
          break;
        }
      }
      
      if (!foundModule) {
        console.log(`Debug: Módulo não encontrado com ID '${id}'`);
        console.log(`Debug: Módulos disponíveis:`);
        for (const [key, value] of this.moduleMap.entries()) {
          console.log(`  - ${key}: ${value.name} (id: ${value.id})`);
        }
      }
    }
    
    return foundModule;
  }
  
  /**
   * Obtém módulos com configurações específicas para um ambiente
   * @param {string} env - Ambiente (dev, local, prod)
   * @returns {Array} - Lista de módulos com configurações para o ambiente
   */
  getModulesForEnv(env) {
    return this.getAllModules().map(module => {
      return {
        ...module,
        profile: module.profiles && module.profiles[env] ? module.profiles[env] : null
      };
    }).filter(module => module.profile !== null);
  }
  
  /**
   * Retorna o diretório raiz do projeto
   * @returns {string} - Diretório raiz do projeto
   */
  getProjectRoot() {
    return this.moduleLocations.rootDir;
  }
  
  /**
   * Retorna informações sobre a localização dos módulos
   * @returns {Object} - Objeto com informações sobre a localização dos módulos
   */
  getModuleLocations() {
    return this.moduleLocations;
  }
}

module.exports = ModuleRegistry;