cartorio-plataforma-cli/commands/stop.js

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

const inquirer = require('inquirer');
const chalk = require('chalk');
const { execSync } = require('child_process');
const ora = require('ora');
const path = require('path');
const boxen = require('boxen');
const ModuleRegistry = require('../lib/module-registry');
const DockerCommandGenerator = require('../lib/docker-command-generator');

/**
 * Função que para os componentes da plataforma
 */
module.exports = async function stop(options) {
  let env = options.env || 'local';
  
  // Carregar o registro de módulos - mesmo que não seja usado diretamente,
  // é útil para encontrar o diretório do projeto
  const registry = new ModuleRegistry();
  
  // Criar gerador de comandos
  const commandGenerator = new DockerCommandGenerator(registry);
  
  // Encontra o diretório raiz do projeto
  const projectDir = commandGenerator.findProjectDir();
  
  // Carregar os módulos usando o diretório do projeto encontrado
  registry.loadModules(projectDir);

  // Modo interativo
  if (options.interactive) {
    // Escolher ambiente
    const { selectedEnv } = await inquirer.prompt([
      {
        type: 'list',
        name: 'selectedEnv',
        message: 'Selecione o ambiente para parar serviços:',
        choices: [
          { name: 'Desenvolvimento (dev)', value: 'dev' },
          { name: 'Local (local)', value: 'local' },
          { name: 'Produção (prod)', value: 'prod' }
        ],
        default: env
      }
    ]);
    
    env = selectedEnv;
    
    // Obter a lista de serviços em execução
    const spinner = ora('Obtendo serviços em execução...').start();
    let containers = [];
    
    try {
      const composeCommand = commandGenerator.createCommand(
        projectDir, 
        `docker compose --profile ${env} --env-file .env.${env} ps --format json`
      );
      
      const containerList = execSync(composeCommand).toString();
      
      // Verificar se a resposta está vazia
      if (containerList.trim()) {
        containers = JSON.parse(`[${containerList.trim().split('\n').join(',')}]`);
      }
      
      spinner.succeed('Serviços em execução obtidos com sucesso!');
    } catch (error) {
      spinner.fail('Erro ao obter serviços em execução');
      console.error(error);
      return;
    }
    
    // Se não houver contêineres em execução
    if (containers.length === 0) {
      console.log(chalk.yellow('\nNenhum serviço em execução no ambiente selecionado.'));
      return;
    }
    
    // Agrupar os serviços
    const infraServices = ['consul', 'postgres', 'traefik'];
    const coreServices = ['root-config', 'plataforma-frontend', 'plataforma-backend'];
    const moduleServices = ['modulo1', 'minutador', 'senhas'];
    
    // Criar lista de choices
    const choices = [
      { name: 'Todos os serviços', value: 'all' },
      new inquirer.Separator('--- Grupos de Serviços ---'),
      { name: '⚙️  Serviços de Infraestrutura', value: 'infra' },
      { name: '🔵 Serviços Core', value: 'core' },
      { name: '🟢 Serviços de Módulos', value: 'modules' },
      new inquirer.Separator('--- Serviços Específicos ---')
    ];
    
    // Adicionar serviços específicos
    containers.forEach(container => {
      const name = container.Service;
      choices.push({ name: `${name}`, value: name });
    });
    
    // Perguntar quais serviços parar
    const { serviceToStop, confirm } = await inquirer.prompt([
      {
        type: 'list',
        name: 'serviceToStop',
        message: 'Quais serviços você deseja parar?',
        choices: choices,
        default: 'all'
      },
      {
        type: 'confirm',
        name: 'confirm',
        message: answers => {
          if (answers.serviceToStop === 'all') {
            return 'Tem certeza que deseja parar TODOS os serviços?';
          } else if (answers.serviceToStop === 'infra') {
            return 'Tem certeza que deseja parar os serviços de infraestrutura? (Consul, Postgres, Traefik)';
          } else if (answers.serviceToStop === 'core') {
            return 'Tem certeza que deseja parar os serviços core? (Root Config, Plataforma Frontend, Plataforma Backend)';
          } else if (answers.serviceToStop === 'modules') {
            return 'Tem certeza que deseja parar os serviços de módulos? (Módulo 1, Minutador, Senhas)';
          } else {
            return `Tem certeza que deseja parar o serviço ${answers.serviceToStop}?`;
          }
        },
        default: false
      }
    ]);
    
    // Se não confirmou, retornar
    if (!confirm) {
      console.log(chalk.yellow('Operação cancelada pelo usuário.'));
      return;
    }
    
    // Comando base
    let command = `ENVIRONMENT=${env} docker compose --profile ${env} --env-file .env.${env}`;
    
    // Adicionar o comando correto baseado na seleção
    if (serviceToStop === 'all') {
      command += ' down';
    } else if (['infra', 'core', 'modules'].includes(serviceToStop)) {
      // Preparar serviços específicos
      let services = [];
      
      if (serviceToStop === 'infra') {
        services = infraServices;
      } else if (serviceToStop === 'core') {
        services = coreServices;
      } else if (serviceToStop === 'modules') {
        services = moduleServices;
      }
      
      // Construir lista de serviços para parar
      const serviceList = containers
        .filter(container => {
          const serviceName = container.Service;
          return services.some(s => serviceName.includes(s));
        })
        .map(container => container.Service)
        .join(' ');
      
      if (serviceList.length > 0) {
        command += ` stop ${serviceList}`;
      } else {
        console.log(chalk.yellow('Nenhum serviço encontrado para parar.'));
        return;
      }
    } else {
      command += ` stop ${serviceToStop}`;
    }
    
    // Criar o comando completo com o diretório correto
    const fullCommand = commandGenerator.createCommand(projectDir, command);
    
    // Executar o comando
    const stopSpinner = ora(`Parando ${serviceToStop === 'all' ? 'todos os serviços' : serviceToStop}...`).start();
    
    try {
      execSync(fullCommand, { stdio: 'inherit' });
      stopSpinner.succeed(chalk.green(`Serviços parados com sucesso!`));
    } catch (error) {
      stopSpinner.fail(chalk.red('Erro ao parar serviços!'));
      console.error(error);
    }
    
    return;
  }

  // Modo não interativo (original)
  console.log(
    boxen(
      chalk.red(`⏹️  Parando componentes da plataforma`) + 
      '\n\n' +
      chalk.white(`Ambiente: ${chalk.green(env)}`),
      { padding: 1, borderColor: 'red', borderStyle: 'round' }
    )
  );

  try {
    console.log(chalk.bold('\n📋 Parando serviços...\n'));
    
    const command = `ENVIRONMENT=${env} docker compose --profile ${env} --env-file .env.${env} down`;
    const fullCommand = commandGenerator.createCommand(projectDir, command);
    
    console.log(chalk.dim(`Executando: ${fullCommand}\n`));
    
    execSync(fullCommand, { 
      stdio: 'inherit',
    });
    
    console.log(chalk.green('\n✅ Serviços parados com sucesso!'));
  } catch (error) {
    console.error(chalk.red('Erro ao parar serviços!'));
    console.error(error);
    process.exit(1);
  }
};