Configuração.md

-:rocket: Quickstart
+A configuração do projeto é dividida nas seguintes etapas:
 
-Guia rápido para rodar o projeto em ambiente local. :clipboard:Pré-requisitos
+- [Pré-requisitos](#-pr%C3%A9-requisitos)
+- [Configuração Rápida com Docker Compose](#-configura%C3%A7%C3%A3o-r%C3%A1pida-com-docker-compose)
+- [Executando Serviços Individualmente](#-executando-servi%C3%A7os-individualmente)
+- [Executando Testes](#-executando-testes)
+- [Guia para Novos Desenvolvedores](#-guia-para-novos-desenvolvedores)
 
-Antes de começar, certifique-se de ter instalado:
+##  Pré-requisitos
 
-```plaintext
-Docker (com Docker Desktop ou equivalente rodando)
-Java JDK 21
-Node.js
-pnpm
+### Para desenvolvimento com Docker (Recomendado)
+
+- [Docker](https://www.docker.com/) v20.10+
+- [Docker Compose](https://docs.docker.com/compose/) v2.0+
+
+### Para desenvolvimento local
+
+- [Java JDK 21](https://www.oracle.com/java/technologies/downloads/#java21)
+- [Node.js](https://nodejs.org/) v18+
+- [pnpm](https://pnpm.io/) v8+
+- [PostgreSQL](https://www.postgresql.org/) 16+ (opcional, pode usar Docker)
+
+## Configuração Rápida com Docker Compose
+
+### Desenvolvimento (Recomendado)
+
+Execute toda a aplicação com um único comando:
+
+```shell
+# Clona o repositório
+git clone <repository-url>
+cd conexao-treinamento
+
+# Inicia todos os serviços
+docker compose up -d
+
+# Para acompanhar os logs
+docker compose logs -f
 ```
 
-Será necessário abrir 3 terminais diferentes. :package: Terminal 1: Banco de Dados (Docker)
+Isso iniciará:
+
+- **PostgreSQL**: `localhost:5432`
+- **Backend**: `localhost:8080`
+- **Frontend**: `localhost:3000`
 
-cd backend docker compose build # Necessário apenas na primeira vez ou caso sejam feitas alterações docker compose up
+### Comandos Úteis do Docker Compose
 
-Para remover todos os dados do banco e começar do zero (não deve ser necessário, mas é bom saber):
+```shell
+# Rebuild e restart dos serviços
+docker compose up -d --build
 
-docker compose down -v # Apaga todos os dados
+# Parar todos os serviços
+docker compose down
 
-:wrench: Terminal 2: Backend Pré-requisitos:
+# Remover volumes (apaga dados do banco)
+docker compose down -v
 
-```plaintext
-Java JDK 21 instalado
-Verifique com:
+# Ver status dos serviços
+docker compose ps
 
-java -version
-# Deve aparecer algo como:
-# java version "22.0.2" 2024-07-16
-# Java(TM) SE Runtime Environment (build 22.0.2+9-70)
-# Java HotSpot(TM) 64-Bit Server VM (build 22.0.2+9-70, mixed mode, sharing)
+# Logs de um serviço específico
+docker compose logs -f backend
+docker compose logs -f frontend
+docker compose logs -f postgres
 ```
 
-Passos: :penguin:Linux:
+### Ambiente de Testes
 
-cd backend chmod +x ./mvnw # ou chmod +x mvn ./mvnw spring-boot:run # em alguns casos pode ser "mvn spring-boot:run"
+Para executar testes em containers isolados:
 
-🪟 Windows:
+```shell
+# Configurar arquivo de ambiente de teste (se necessário)
+cp .env.example .env.test
 
-cd backend .\\mvnw.cmd spring-boot:run # em alguns casos pode ser "mvn spring-boot:run"
+# Executar testes
+docker compose -f docker-compose.test.yml up --build
+```
 
-:computer: Terminal 3: Frontend Pré-requisitos:
+## Executando Serviços Individualmente
 
-```plaintext
-Node.js instalado
+### 1. Banco de Dados (PostgreSQL)
 
-pnpm instalado
+#### Opção A: Com Docker (Recomendado)
 
-Verifique com:
+```shell
+# Apenas o PostgreSQL
+docker compose up postgres -d
 
-node -v
-# Deve aparecer algo como:
-# v22.14.0
-pnpm -v
-# Deve aparecer algo como:
-# 10.15.1
+# Verificar se está rodando
+docker compose ps postgres
 ```
 
-Passos:
+#### Opção B: PostgreSQL Local
+
+```shell
+# Instalar PostgreSQL e criar banco
+createdb conexaotreinamento
+psql -d conexaotreinamento -c "CREATE USER postgres WITH PASSWORD 'postgres123';"
+```
+
+### 2. Backend (Spring Boot)
+
+```shell
+cd backend
+
+# Linux/macOS
+chmod +x ./mvnw
+./mvnw clean install
+./mvnw spring-boot:run
+
+# Windows
+.\mvnw.cmd clean install
+.\mvnw.cmd spring-boot:run
+
+# Ou usando Maven instalado globalmente
+mvn clean install
+mvn spring-boot:run
+```
+
+**Configurações de ambiente para o backend:**
+
+```shell
+# Variáveis de ambiente (opcional)
+export SPRING_PROFILES_ACTIVE=dev
+export SPRING_DATASOURCE_URL=jdbc:postgresql://localhost:5432/conexaotreinamento
+export SPRING_DATASOURCE_USERNAME=postgres
+export SPRING_DATASOURCE_PASSWORD=postgres123
+```
+
+O backend estará disponível em: `http://localhost:8080`
+
+### 3. Frontend (Next.js)
+
+```shell
+cd web
+
+# Instalar dependências
+pnpm install
+
+# Modo desenvolvimento
+pnpm dev
+
+# Ou modo produção
+pnpm build
+pnpm start
+```
+
+**Configurações de ambiente para o frontend:**
+
+```shell
+# Criar arquivo .env.local
+echo "NEXT_PUBLIC_API_URL=http://localhost:8080" > .env.local
+```
+
+O frontend estará disponível em: `http://localhost:3000`
+
+## Executando Testes
+
+### Testes do Backend
+
+```shell
+cd backend
+
+# Executar todos os testes
+./mvnw test
+
+# Executar testes com relatório de cobertura
+./mvnw test jacoco:report
+
+# Executar apenas testes unitários
+./mvnw test -Dtest="**/*Test.java"
+
+# Executar apenas testes de integração
+./mvnw test -Dtest="**/*IntegrationTest.java"
+
+# Executar testes com perfil específico
+./mvnw test -Dspring.profiles.active=test
+```
+
+### Testes do Frontend
+
+```shell
+cd web
+
+# Verificação de tipos
+pnpm type-check
+
+# Linting
+pnpm lint
+
+# Formatação de código
+pnpm format:check
+pnpm format
+
+# Testes (quando implementados)
+pnpm test:smoke
+pnpm test:integration
+```
 
-cd web pnpm install pnpm dev
+### Testes com Docker
 
-:tools: Estrutura do Projeto
-├── backend/ # Código do backend 
-├── docs/    # Documentação \
-└── web/     # Código do frontend
\ No newline at end of file
+```shell
+# Executar testes em ambiente isolado
+docker compose -f docker-compose.test.yml up --build --abort-on-container-exit
+
+# Limpar após testes
+docker compose -f docker-compose.test.yml down -v
+```
+
+##  Guia para Novos Desenvolvedores
+
+### 1. Primeiro Setup
+
+```shell
+# 1. Clone o repositório
+git clone <repository-url>
+cd conexao-treinamento
+
+# 2. Inicie com Docker (mais fácil)
+docker compose up -d
+
+# 3. Aguarde todos os serviços subirem
+docker compose logs -f
+```
+
+### 2. Verificando se está funcionando
+
+- **Frontend**: Acesse <http://localhost:3000>
+- **Backend API**: Acesse <http://localhost:8080/swagger-ui.html>
+- **Database**: Conecte em `localhost:5432` (postgres/postgres123)
+
+### 3. Fluxo de Desenvolvimento
+
+#### Workflow Recomendado
+
+```shell
+# 1. Sincronizar com a branch principal
+git checkout develop
+git pull origin develop
+
+# 2. Criar nova branch a partir da develop
+git checkout -b feature/nova-funcionalidade
+
+# 3. Fazer alterações no código
+# ... desenvolver sua feature ...
+
+# 4. Executar testes e validações
+# Backend
+cd backend && ./mvnw test
+
+# Frontend  
+cd web && pnpm type-check && pnpm lint
+
+# 5. Commit das alterações (seguindo Conventional Commits)
+git add .
+git commit -m "feat: adiciona nova funcionalidade"
+
+# 6. Antes de fazer push - sincronizar com develop
+git checkout develop
+git pull origin develop
+git checkout feature/nova-funcionalidade
+
+# 7. Resolver conflitos se houver
+git rebase develop
+# Se houver conflitos, resolva-os e continue:
+# git add .
+# git rebase --continue
+
+# 8. Push da branch
+git push origin feature/nova-funcionalidade
+
+# 9. Abrir Pull Request no GitHub/GitLab
+# Aguardar review e aprovação antes do merge
+```
+
+#### Padrão de Commits (Conventional Commits)
+
+Use os seguintes prefixos para seus commits:
+
+- `feat:` - Nova funcionalidade
+- `fix:` - Correção de bug
+- `docs:` - Alterações na documentação
+- `style:` - Formatação, sem mudança de lógica
+- `refactor:` - Refatoração de código
+- `test:` - Adição ou correção de testes
+- `chore:` - Tarefas de manutenção
+
+**Exemplos:**
+
+```shell
+git commit -m "feat: adiciona endpoint para listar exercícios"
+git commit -m "fix: corrige validação de email no cadastro"
+git commit -m "docs: atualiza README com instruções de deploy"
+```
+
+### 4. Comandos Úteis do Dia a Dia
+
+```shell
+# Ver logs em tempo real
+docker compose logs -f backend
+docker compose logs -f frontend
+
+# Reiniciar apenas um serviço
+docker compose restart backend
+
+# Executar comando dentro do container
+docker compose exec backend bash
+docker compose exec postgres psql -U postgres -d conexaotreinamento
+
+# Limpar cache e rebuild
+docker compose down
+docker compose up -d --build
+```
+
+### 5. Debugando Problemas Comuns
+
+#### Backend não inicia
+
+```shell
+# Verificar logs
+docker compose logs backend
+
+# Verificar se PostgreSQL está rodando
+docker compose ps postgres
+
+# Reiniciar com rebuild
+docker compose up backend --build
+```
+
+#### Frontend não carrega
+
+```shell
+# Verificar se backend está respondendo
+curl http://localhost:8080/actuator/health
+
+# Verificar variáveis de ambiente
+docker compose exec frontend env | grep NEXT_PUBLIC
+```
+
+#### Banco de dados com problemas
+
+```shell
+# Resetar banco (CUIDADO: apaga dados)
+docker compose down -v
+docker compose up postgres -d
+```
\ No newline at end of file