Pular para conteúdo

Entendendo a Estrutura do Nosso Projeto Monorepo

Bem-vindo(a) ao projeto! Você está entrando em um ambiente de desenvolvimento moderno e organizado, que utiliza uma estrutura de monorepo com vários serviços. Não se preocupe em entender tudo de uma vez. Este documento é um guia prático para você se familiarizar com a arquitetura e saber onde encontrar o que precisa. Muitas das técnicas e padrões serão aprendidas no dia a dia.

1. Visão Geral do Monorepo

Nosso projeto é um monorepo, o que significa que todo o código-fonte (frontend, backend, gateway) vive em um único repositório. Isso facilita a colaboração e a consistência entre os diferentes módulos.

Ele é composto por:

  • 1 Frontend: Construído com Next.js (React).
  • 5 Microserviços de Backend:
    • 3 em Java: Usando Spring Boot.
    • 1 em Python: Usando FastAPI e Peewee.
    • 1 Gateway em Node.js: Usando Express e um Nginx como reverse proxy.

2. Estrutura de Pastas e Componentes

Vamos mergulhar na organização das pastas para você saber onde encontrar cada parte do projeto.

2.1. frontend/ (Next.js)

Aqui reside toda a aplicação web que os usuários finais interagem.

  • src/: Contém o código-fonte principal do Next.js.
    • app/: As rotas do Next.js.
      • (private)/: Páginas que exigem autenticação para acesso (ex: feedback/, userlist/).
      • (public)/: Páginas de acesso público (ex: login/, setpassword/).
    • components/: Componentes React reutilizáveis por diversas páginas (ex: NavBar/).
    • dtos/: Modelos de dados (Data Transfer Objects) que definem a estrutura das informações trocadas com o backend.
    • services/: Funções para fazer chamadas à API do backend. É onde você vai configurar como o frontend "conversa" com os microserviços.
    • utils/: Funções utilitárias gerais.
    • __tests__/: Pasta para os testes da aplicação frontend.
  • Arquivos de Configuração: package.json, next.config.ts, tsconfig.json, Dockerfile etc. são arquivos de configuração do projeto Next.js e do ambiente de execução.

2.2. java_backend/ (Spring Boot)

Esta pasta agrupa os três microserviços Java.

  • libs/: Contém bibliotecas compartilhadas entre os microserviços Java.
    • security/: Uma biblioteca de segurança customizada (JWT) que é reutilizada pelos outros microserviços. É aqui que está a lógica para lidar com tokens de autenticação.
  • microservices/: Cada subpasta aqui é um microserviço Java independente:
    • feedbackrequest/: Responsável por gerenciar as solicitações de feedback.
    • feedbackresponse/: Lida com as respostas de feedback.
    • usermanagement/: Gerencia usuários (colaboradores, PDMs, administradores).
  • Dentro de cada microserviço Java, você encontrará a seguinte estrutura prática (seguindo camadas de DDD simplificado):
    • controller/: Recebe as requisições HTTP do frontend (ou do gateway), valida a entrada e chama a camada de service.
    • service/: Contém a lógica de negócio principal. É aqui que você vai implementar as regras de como as coisas funcionam no nosso domínio. Ele usa os repositorys para interagir com os dados.
    • entity/: Representa as entidades do domínio, ou seja, os objetos que possuem uma identidade única e são persistidos no banco de dados (ex: User, FeedbackRequest).
    • repository/: Interfaces que definem como o service vai salvar, buscar ou atualizar as entitys no banco de dados. Ele abstrai os detalhes de como a comunicação com o banco de dados funciona.
    • dto/: Classes para Data Transfer Objects (DTOs), usadas para receber dados das requisições e enviar dados nas respostas, facilitando a comunicação entre as camadas.
    • exceptions/: Classes para tratar erros específicos da aplicação.
    • configuration/: Configurações específicas do microserviço (ex: segurança, banco de dados).
  • pom.xml: Arquivos de configuração do Maven para cada microserviço e para o módulo java_backend como um todo, definindo as dependências.
  • Dockerfile: Arquivos para construir as imagens Docker dos microserviços.

2.3. python_backend/ (FastAPI)

Aqui está o microserviço Python, que provavelmente cuida da visualização das respostas de feedback.

  • feedbackresponseview/: O diretório raiz do microserviço.
    • app/: Contém o código-fonte da aplicação FastAPI.
      • routes/: Onde você definirá os endpoints da API (equivalente aos controllers em Java).
      • services/: Contém a lógica de negócio (similar à camada service em Java).
      • models/: Representa as entidades e modelos de dados para o Peewee (equivalente a entity e dto em Java, mas para Python/ORM).
      • repositories/: Onde estará a lógica para interagir com o banco de dados usando Peewee (similar à camada repository em Java).
      • config/: Configurações da aplicação, como conexão com o banco de dados.
      • auth/, exceptions/, middleware/: Outras pastas para organização de funcionalidades de autenticação, tratamento de erros e middlewares.
    • tests/: Pasta para os testes unitários e de integração do microserviço Python.
    • pyproject.toml: Arquivo de configuração de projeto e dependências (similar ao pom.xml ou package.json).
  • Dockerfile: Arquivo para construir a imagem Docker do microserviço Python.

2.4. node_backend/ (Express Gateway)

Este é o nosso Gateway de API, construído com Node.js e Express.

  • api_gateway/: O diretório do gateway.
    • src/: Contém o código do gateway.
      • app.ts, index.ts: Arquivos principais onde a lógica de roteamento e proxy para os microserviços é definida.
      • app.spec.ts: Testes para o gateway.
  • package.json, tsconfig.json: Arquivos de configuração do projeto Node.js.
  • Dockerfile: Arquivo para construir a imagem Docker do gateway.

2.5. gateway/ (Nginx)

Esta pasta contém o arquivo de configuração do Nginx, que atua como um reverse proxy para direcionar as requisições para o Gateway Node.js e, posteriormente, para os microserviços corretos.

  • nginx.conf: O arquivo de configuração principal do Nginx.

3. Ferramentas e Padrões Essenciais

Nosso projeto segue algumas convenções e utiliza ferramentas específicas:

  • Monorepo: Tudo no mesmo lugar.
  • Docker e Docker Compose: Usamos para padronizar o ambiente de desenvolvimento e produção. Você encontrará docker-compose-dev.yml (para desenvolvimento) e docker-compose.yml (para produção) na raiz.
  • Estrutura de Camadas (Controller, Service, Entity/Model, Repository): Esta é a organização principal de cada microserviço backend para separar responsabilidades.
    • Controller: Lida com a entrada e saída da API (HTTP).
    • Service: Contém a lógica de negócio.
    • Entity/Model: Representa os dados e seu comportamento.
    • Repository: Abstrai a comunicação com o banco de dados.
  • JWT (JSON Web Tokens): Para autenticação de usuários, garantindo que apenas pessoas autorizadas acessem certas funcionalidades.
  • Bitbucket Pipelines: Para automação de CI/CD (integração e entrega contínua), configurado no bitbucket-pipelines.yml.

4. Próximos Passos e Onde Encontrar Ajuda

Não se sinta sobrecarregado(a)! A beleza do monorepo e da organização por camadas é que você pode focar em uma parte por vez.

  • Para Começar: Concentre-se nas tarefas que lhe forem atribuídas. Entenda o controller, service e repository daquele microserviço específico.
  • Documentação: Temos uma vasta documentação interna. Não hesite em consultá-la ou perguntar ao seu Tutor Tech Lead ou a um colega de equipe. Eles estão aqui para ajudar!
  • Aprenda no Dia a Dia: Muitas das técnicas e padrões (como DDD, JWT, e os detalhes de cada framework) serão compreendidas à medida que você for desenvolvendo as funcionalidades. Não é necessário dominar tudo antes de começar.

Você está pronto(a) para embarcar nesta jornada. Qual parte da aplicação você está mais curioso(a) para explorar primeiro?