cartorio-plataforma-cli/lib/manifest-utils.js

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

/**
 * Utilitários para validação e geração de arquivos de manifesto
 */
const fs = require('fs');
const path = require('path');

/**
 * Valida um manifesto de módulo
 * @param {Object} manifest - Objeto de manifesto a ser validado
 * @returns {Object} - Resultado da validação com erros, se houver
 */
function validateManifest(manifest) {
  const errors = [];
  
  // Campos obrigatórios
  if (!manifest.id) {
    errors.push('O manifesto deve conter um ID');
  }
  
  if (!manifest.name) {
    errors.push('O manifesto deve conter um nome');
  }
  
  if (!manifest.type) {
    errors.push('O manifesto deve especificar um tipo (core, frontend, backend, infrastructure)');
  } else if (!['core', 'frontend', 'backend', 'infrastructure'].includes(manifest.type)) {
    errors.push('O tipo de módulo deve ser core, frontend, backend ou infrastructure');
  }
  
  // Validar profiles para cada ambiente
  if (!manifest.profiles) {
    errors.push('O manifesto deve definir profiles para os ambientes');
  } else {
    const requiredEnvs = ['dev', 'local', 'prod'];
    const missingEnvs = requiredEnvs.filter(env => !manifest.profiles[env]);
    
    if (missingEnvs.length > 0) {
      errors.push(`Faltam definições de profiles para os ambientes: ${missingEnvs.join(', ')}`);
    }
  }
  
  // Validar configurações do Docker para tipos não-infrastructure
  if (manifest.type !== 'infrastructure' && !manifest.docker) {
    errors.push('Módulos não-infrastructure devem conter configurações do Docker');
  } else if (manifest.type !== 'infrastructure') {
    if (!manifest.docker.dockerfile) {
      errors.push('A configuração Docker deve incluir dockerfile');
    }
    
    if (!manifest.docker.context) {
      errors.push('A configuração Docker deve incluir context');
    }
  }
  
  return {
    isValid: errors.length === 0,
    errors
  };
}

/**
 * Cria um arquivo de manifesto em um diretório
 * @param {string} directory - Diretório onde criar o manifesto
 * @param {Object} manifest - Dados do manifesto
 * @param {string} format - Formato do arquivo (js ou json)
 * @returns {boolean} - Sucesso da operação
 */
function createManifestFile(directory, manifest, format = 'js') {
  try {
    // Validar o manifesto antes de criar
    const validation = validateManifest(manifest);
    if (!validation.isValid) {
      console.error('Manifesto inválido:');
      validation.errors.forEach(err => console.error(`- ${err}`));
      return false;
    }
    
    const filePath = path.join(directory, `plataforma-manifest.${format}`);
    
    if (format === 'js') {
      // Criar arquivo JavaScript com module.exports
      const content = `module.exports = ${JSON.stringify(manifest, null, 2)};`;
      fs.writeFileSync(filePath, content, 'utf8');
    } else {
      // Criar arquivo JSON
      fs.writeFileSync(filePath, JSON.stringify(manifest, null, 2), 'utf8');
    }
    
    return true;
  } catch (error) {
    console.error(`Erro ao criar arquivo de manifesto: ${error.message}`);
    return false;
  }
}

/**
 * Gera um template de manifesto com base no tipo de módulo
 * @param {string} id - ID do módulo
 * @param {string} name - Nome do módulo
 * @param {string} type - Tipo do módulo
 * @returns {Object} - Template de manifesto
 */
function generateManifestTemplate(id, name, type) {
  const baseManifest = {
    id,
    name,
    type,
    description: `${name} (${type})`,
    profiles: {
      dev: `${id}-${type}-dev`,
      local: `${id}-${type}-local`,
      prod: `${id}-${type}-prod`
    }
  };
  
  // Adicionar configurações específicas por tipo
  if (type === 'frontend') {
    return {
      ...baseManifest,
      dependencies: ["plataforma-frontend"],
      docker: {
        dockerfile: {
          dev: "Dockerfile.dev",
          prod: "Dockerfile"
        },
        context: "./"
      }
    };
  } else if (type === 'backend') {
    return {
      ...baseManifest,
      dependencies: ["plataforma-backend"],
      docker: {
        dockerfile: {
          dev: "Dockerfile.dev",
          prod: "Dockerfile"
        },
        context: "./"
      },
      services: [
        {
          name: "api",
          port: 3000,
          healthcheck: "/health"
        }
      ]
    };
  } else if (type === 'core') {
    return {
      ...baseManifest,
      docker: {
        dockerfile: {
          dev: "Dockerfile.dev",
          prod: "Dockerfile"
        },
        context: "./"
      }
    };
  } else if (type === 'infrastructure') {
    return {
      ...baseManifest,
      services: [
        {
          name: id,
          port: 0, // Porta a ser definida
          healthcheck: "/healthz"
        }
      ]
    };
  }
  
  return baseManifest;
}

module.exports = {
  validateManifest,
  createManifestFile,
  generateManifestTemplate
};