Sistema de Gestão de Tarefas Colaborativo (TaskDeck)

🎯 Contexto & Objetivo

Um Sistema de Gestão de Tarefas Colaborativo com autenticação simples, CRUD de tarefas, comentários, atribuição e notificações. O sistema roda em monorepo e expondo uma UI limpa, responsiva e usável. O back‑end e composto por microserviços Nest que se comunicam via RabbitMQ; o acesso HTTP externo passa por um API Gateway.

📋 Documentação do Projeto

1. Arquitetura do Sistema

┌─────────────────────────────────────────────────────────────────┐
│                          USUÁRIO                                │
└─────────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────────┐
│                    WEB (React + Vite)                           │
│              TanStack Router + shadcn/ui                        │
│                   Port: 3000                                    │
└─────────────────────────────────────────────────────────────────┘
                │                                 │
                │ HTTP (REST)                     │ WebSocket
                ▼                                 │
┌───────────────────────────────┐                 │
│   API GATEWAY (NestJS)        │                 │
│   HTTP Routes + Swagger       │                 │
│   Port: 3001                  │                 │
└───────────────────────────────┘                 │
                │                                 │
    ┌───────────┼───────────┐                     │
    │           │           │                     │
    ▼           ▼           ▼                     │
┌─────────┐ ┌─────────┐  ┌─────────────────────┐  │
│  AUTH   │ │  TASKS  │  │  NOTIFICATIONS      │  │
│ SERVICE │ │ SERVICE │  │     SERVICE         │◄─┘
│ (NestJS)│ │ (NestJS)│  │   (NestJS)          │
│         │ │         │  │  • WebSocket Gateway│
└─────────┘ └─────────┘  │  • RabbitMQ Consumer│
     │           │       │   Port: 3004        │
     │           │       └─────────────────────┘
     │           │                   │
     │           │                   │
     └─────┬─────┴──────┬────────────┘
           │            │
           ▼            ▼
    ┌──────────┐  ┌──────────┐
    │PostgreSQL│  │ RabbitMQ │
    │Port: 5432│  │Port: 5672│
    │          │  │UI: 15672 │
    └──────────┘  └──────────┘

Fluxo de Comunicação:
━━━━━━━━━━━━━━━━━━━━━
1. WEB → API Gateway (HTTP) para Auth, Tasks e Comments
2. WEB → Notifications Service (WebSocket) para notificações em tempo real
3. Tasks Service → RabbitMQ (publica eventos: task.created, task.updated, etc)
4. Notifications Service → RabbitMQ (consome eventos da fila)
5. Notifications Service → WEB (emite eventos via WebSocket)

Estrutura do Monorepo

.
├── apps/
│   ├── web/
│   │   ├── src/                  # React + TanStack Router + shadcn + Tailwind
│   │   ├── Dockerfile
│   │   ├── .env.example          # variáveis de ambiente do frontend
│   │   ├── package.json
│   ├── api-gateway/
│   │   ├── src/                  # HTTP + WebSocket + Swagger
│   │   ├── Dockerfile
│   │   ├── .env.example          # variáveis do API Gateway (Nest.js)
│   │   ├── package.json
│   ├── auth-service/
│   │   ├── src/                  # Nest.js (microserviço de autenticação)
│   │   ├── Dockerfile
│   │   ├── .env.example          # variáveis do serviço de autenticação
│   │   ├── package.json
│   ├── tasks-service/
│   │   ├── src/                  # Nest.js (microserviço RabbitMQ)
│   │   ├── Dockerfile
│   │   ├── .env.example          # variáveis do serviço de tarefas
│   │   ├── package.json
│   └── notifications-service/
│       ├── src/                  # Nest.js (microserviço RabbitMQ + WebSocket)
│       ├── Dockerfile
│       ├── .env.example          # variáveis do serviço de notificações
│       ├── package.json
├── packages/
│   ├── types/
│   ├── utils/
│   ├── eslint-config/
│   └── tsconfig/
├── docker-compose.yml
├── turbo.json
├── package.json
└── README.md

2. Decisões Técnicas

Front-end

Stack Utilizada:

• React com Vite
• TanStack Router para roteamento
• shadcn/ui + Tailwind CSS para UI
• Zustand (gerenciamento de estado)
• Socket.io-client (WebSocket)
• react-hook-form + zod para validação
• Axios para requisições HTTP

Motivação:

• Zustand: Escolhido pela simplicidade em relação à Context API, menos boilerplate e melhor performance. Perfeito para gerenciar estado de autenticação e notificações
• Socket.io-client: Biblioteca padrão do NestJS para WebSocket, garante compatibilidade e facilita integração
• shadcn/ui: Componentes acessíveis, customizáveis e prontos para produção. Reduz tempo de desenvolvimento mantendo qualidade
• TanStack Router: Type-safe routing com excelente DX, validação de params e search params automática
• Vite: Build extremamente rápido, HMR instantâneo, melhor experiência de desenvolvimento

Componentes Implementados (shadcn/ui):

1. Header: Navegação principal com logo e ações do usuário
2. auth-dropdown: Dropdown com informações do usuário e logout
3. notifications: Badge de notificações com dropdown e lista de notificações em tempo real
4. mode-toggle: Toggle dark/light theme
5. protected-routes: HOC para proteção de rotas autenticadas
6. theme-initializer: Componente que inicializa o tema do sistema

Componentes UI shadcn/ui:

• Alert, Button, Calendar, Card, Checkbox
• Command, Dialog, Dropdown Menu, Input, Label
• Popover, Scroll Area, Select, Separator, Sheet
• Sonner (toast), Textarea, Date Picker

Páginas Implementadas:

• / - Board de tasks onde tem as listagem das tasks do qual o usuário logado tem participação ou e criador
• /tasks/:id - Detalhe da tarefa com comentários
• /login - Tela para a autenticação do usuário no sistema
• /register - Tela para que um novo usuário possa criar sua conta e desfrutar do sistema de tasks

Features:

• Dark mode com persistência no localStorage (theme-initializer)
• Toast notifications para feedback de ações (Sonner)
• Skeleton loaders durante carregamentos
• Formulários validados com react-hook-form + zod
• Notificações em tempo real via WebSocket com Socket.IO
• Rich text editor com BlockNote para conteúdo de tarefas
• Drag and drop com dnd-kit para organização de tarefas
• Query state management com nuqs
• Invalidação automática de queries ao receber notificações
• Date formatting com date-fns (pt-BR)

Hooks Customizados:

• useNotificationWebSocket: Gerencia conexão WebSocket e recebe notificações em tempo real
• useAuth: Gerencia estado de autenticação com Zustand
• Integração com TanStack Query para cache e invalidação automática

Back-end

Stack Utilizada:

• NestJS com TypeORM
• PostgreSQL como banco de dados
• RabbitMQ para comunicação entre microserviços
• JWT para autenticação
• bcrypt para hash de senhas
• WebSocket para notificações em tempo real

Arquitetura de Microserviços:

1. API Gateway:

   • Ponto de entrada único para todas as requisições HTTP do frontend
   • Implementa Guards de autenticação JWT para proteger rotas
   • Proxy reverso que roteia requisições para os microserviços corretos via RabbitMQ
   • Expõe documentação Swagger em /docs
   • Implementa rate limiting (10 req/seg)
   • Health checks disponíveis para monitoramento
   • Controllers para: Auth, Tasks e Comments

2. Auth Service (Porta interna):

   • Responsável por autenticação e gerenciamento de usuários
   • Implementa JWT Strategy com Passport para validação de tokens
   • Tokens: Access Token (15 min) e Refresh Token (7 dias)
   • Hash de senhas com bcryptjs (salt rounds: 10)
   • Endpoints: register, login, refresh token, validate token, CRUD de usuários
   • Comunicação via RabbitMQ com o API Gateway
   • Validação de DTOs com class-validator
   • Schema de banco: auth_service
   • Índices únicos em username e email (case-insensitive)

3. Tasks Service (Porta interna):

   • CRUD completo de tarefas com relacionamentos
   • Gerenciamento de comentários em tarefas
   • Sistema de atribuição de tarefas a múltiplos usuários (many-to-many via TaskAssignee)
   • Histórico de alterações (TaskHistory) automático com metadata JSONB
   • Publicação de eventos no RabbitMQ para as notificações quando:
     • Tarefa criada
     • Tarefa atualizada (status, prioridade, etc)
     • Comentário criado
     • Usuário atribuído
   • Suporte a paginação nas listagens (PaginationDto)
   • Filtros por status, prioridade e usuário atribuído
   • Schema de banco: task_service
   • Validação de assignees com chamada ao Auth Service via RabbitMQ
   • Transações para garantir consistência (EntityManager)

4. Notifications Service (Porta: 3004):

   • Dupla responsabilidade:
     • RabbitMQ Consumer: Consome eventos da fila de notificações
     • WebSocket Gateway: Emite notificações em tempo real para o frontend
   • Subscriber pattern do TypeORM para detectar inserção de notificações
   • Após persistir notificação, emite via WebSocket automaticamente
   • Eventos emitidos: notification.{userId} (room específica por usuário)
   • Socket.io configurado com CORS aberto (origin: '*')
   • Namespace: /notifications
   • Schema de banco: notification_service
   • Persistência de notificações para histórico
   • Índices em: assigneeIds, createdAt, taskId

Padrões de Mensageria:

• Padrão Request/Response: Gateway solicita dados aos microserviços e aguarda resposta

• Padrão Event-Driven: Tasks Service publica eventos que Notifications Service consome

• Filas RabbitMQ:

  • auth-service-queue: Comunicação com Auth Service
  • tasks-service-queue: Comunicação com Tasks Service
  • notifications-service-queue: Eventos de notificação

• Configuração:

  • Transport: RMQ (RabbitMQ)
  • Durable queues: true (mensagens persistem mesmo com restart)
  • URL padrão: amqp://admin:admin@rabbitmq:5672

• Estrutura de eventos notificação:

  {
    taskId: string,
    assigneeIds: string[],
    title: string,
    content: string,
    category: NotificationCategory // tipos de ação que geram a notificação
  }

Monorepo

Estrutura de Packages:

• @repo/types: DTOs compartilhados entre todos os serviços
• @repo/consts: Constantes globais do projeto
• @repo/logger: Serviço de logging com Winston
• @repo/eslint-config: Configurações ESLint compartilhadas
• @repo/prettier-config: Configurações Prettier
• @repo/typescript-config: Configurações TypeScript base
• @repo/jest-config: Configurações Jest para testes

Vantagens:

• Reutilização de código: DTOs, tipos e utilitários compartilhados evitam duplicação
• Consistência: Mesmas configurações de linting, formatação e TypeScript em todos os projetos
• Developer Experience: Um único pnpm install instala todas as dependências
• Type Safety: Tipos compartilhados garantem contratos entre frontend e backend
• Build otimizado: Turborepo com cache inteligente acelera builds
• Versionamento simplificado: Mudanças em packages afetam automaticamente os consumidores
• Logger centralizado: Winston logger customizado com cores ANSI para melhor visualização

Desafios encontrados e como resolveu:

• Dependências circulares: Resolvido isolando services por responsabilidade clara
• Hot reload: Configurado volumes no Docker para sincronizar código em tempo real
• Path mapping: Configurado @repo/* nos tsconfig para imports limpos
• Build order: Turborepo gerencia automaticamente a ordem de build dos packages

Principais Dependências:

Backend (NestJS):

• @nestjs/core, @nestjs/common ^11.0.0 - Framework base
• @nestjs/microservices ^11.1.7 - Comunicação entre microserviços
• @nestjs/typeorm ^11.0.0 - ORM para PostgreSQL
• @nestjs/jwt, @nestjs/passport - Autenticação JWT
• @nestjs/websockets, @nestjs/platform-socket.io - WebSocket
• @nestjs/swagger ^11.2.1 - Documentação OpenAPI
• @nestjs/throttler ^6.4.0 - Rate limiting
• typeorm ^0.3.27 - ORM
• pg ^8.16.3 - Driver PostgreSQL
• amqplib ^0.10.9 - Cliente RabbitMQ
• socket.io ^4.8.1 - WebSocket server
• bcryptjs ^3.0.2 - Hash de senhas

Frontend (React):

• react ^19.2.0, react-dom ^19.2.0 - Framework
• @tanstack/react-router ^1.132.0 - Roteamento type-safe
• @tanstack/react-query ^5.90.5 - Data fetching e cache
• zustand ^5.0.8 - State management
• axios ^1.13.1 - HTTP client
• socket.io-client ^4.8.1 - WebSocket client
• react-hook-form ^7.65.0 - Formulários
• zod ^4.1.12 - Validação de schemas
• @blocknote/react ^0.41.1 - Rich text editor
• @dnd-kit/core ^6.3.1 - Drag and drop
• tailwindcss ^4.1.15 - Styling
• sonner ^2.0.7 - Toast notifications
• date-fns ^4.1.0 - Formatação de datas
• Radix UI - Componentes primitivos acessíveis

3. Funcionalidades Implementadas

✅ Autenticação

• Registro de usuários com validação
• Login com JWT
• Access Token (15 min) e Refresh Token (7 dias)
• Endpoint de refresh token
• Hash de senha com bcrypt
• Guards de autenticação no API Gateway
• Validação de token
• Strategy JWT com Passport
• DTOs validados com class-validator

✅ Gestão de Tarefas

• CRUD completo de tarefas
• Campos: título, descrição, prazo, prioridade, status
• Atribuição de tarefas a múltiplos usuários
• Sistema de comentários
• Histórico de alterações
• Paginação na listagem
• Filtros por status e prioridade
• Relacionamento many-to-many para assignees
• Soft delete (manutenção de integridade referencial)

✅ Notificações em Tempo Real

• WebSocket Gateway
• Eventos: task:created, task:updated, comment:new
• Integração com RabbitMQ
• Persistência de notificações
• Subscriber pattern do TypeORM para auto-emissão
• Rooms por usuário (notification.{userId})
• Socket.io com namespace /notifications
• Notificações em tempo real sem polling

4. Problemas Conhecidos e Melhorias Futuras

Problemas Conhecidos

1. WebSocket reconnection: Não implementado retry automático em caso de queda de conexão
2. Migrations: Não há rollback automático em caso de falha
3. Error handling: Algumas mensagens de erro poderiam ser mais descritivas
4. Notificações persistidas: Não há endpoint para marcar notificações como lidas no backend
5. Validação de assignees: Não valida se o usuário já está atribuído antes de adicionar

Melhorias Futuras

1. Testes:

   • Implementar testes E2E completos
   • Aumentar cobertura de testes unitários
   • Testes de integração para RabbitMQ
   • Testes de carga para WebSocket

2. Performance:

   • Implementar cache com Redis para queries frequentes
   • Otimizar queries do banco de dados (eager loading seletivo)
   • Pagination cursor-based ao invés de offset

3. Funcionalidades:

   • Reset de senha
   • Upload de arquivos anexos às tarefas
   • Filtros avançados
   • Dashboard com métricas
   • Notificações por email
   • Exportação de tarefas (PDF/Excel)
   • Tags/labels nas tarefas
   • Sub-tarefas (checklist)
   • Menções em comentários (@user)

4. DevOps:

   • CI/CD com GitHub Actions
   • Testes automatizados
   • Deploy automatizado
   • Monitoramento e observabilidade
   • Logs centralizados (ELK Stack)
   • Métricas com Prometheus/Grafana
   • Alertas automáticos
   • Health checks mais robustos

5. Tempo de Desenvolvimento

Etapa	Tempo Estimado
Setup do monorepo e configuração inicial	4 horas
Implementação do Auth Service	5 horas
Implementação do Tasks Service	1 dia
Implementação do Notifications Service	1 dia
API Gateway e integração	2 dias
Front-end (UI/UX)	4 dias
Integração WebSocket	1 dia
Docker e docker-compose	3 horas
Testes e debugging	2 dias
Documentação	3 horas
TOTAL	11 dias

6. Como Executar o Projeto

Pré-requisitos

• Node.js 20+
• Docker e Docker Compose
• pnpm (gerenciador de pacotes)

Instalação

# Clonar o repositório
git clone https://github.com/WesleyDev184/fullstack-challenge
cd fullstack-challenge

# Instalar dependências
pnpm install

Configuração de Variáveis de Ambiente

Copie os arquivos .env.example para .env em cada serviço:

cp apps/web/.env.example apps/web/.env
cp apps/api-gateway/.env.example apps/api-gateway/.env
cp apps/auth-service/.env.example apps/auth-service/.env
cp apps/tasks-service/.env.example apps/tasks-service/.env
cp apps/notifications-service/.env.example apps/notifications-service/.env

Variáveis importantes:

API Gateway (.env):

PORT=3001
NODE_ENV=development
RMQ_SERVICE_URL=amqp://admin:admin@rabbitmq:5672

Auth Service (.env):

PORT=3002                                    # Porta interna (não exposta)
NODE_ENV=development
DB_HOST=db                                   # Nome do serviço no Docker
DB_PORT=5432
DB_USERNAME=postgres
DB_PASSWORD=password
DB_NAME=challenge_db
DB_SCHEMA=auth_service                       # Schema próprio do serviço
JWT_SECRET=your-secret-key-here              # Chave secreta para JWT
JWT_EXPIRES_IN=15m                           # Expiração do access token
REFRESH_TOKEN_EXPIRES_IN=7d                  # Expiração do refresh token
RMQ_SERVICE_URL=amqp://admin:admin@rabbitmq:5672

Tasks Service (.env):

PORT=3003                                    # Porta interna (não exposta)
NODE_ENV=development
DB_HOST=db
DB_PORT=5432
DB_USERNAME=postgres
DB_PASSWORD=password
DB_NAME=challenge_db
DB_SCHEMA=task_service                       # Schema próprio do serviço
RMQ_SERVICE_URL=amqp://admin:admin@rabbitmq:5672

Notifications Service (.env):

PORT=3004                                    # Porta exposta para WebSocket
NODE_ENV=development
DB_HOST=db
DB_PORT=5432
DB_USERNAME=postgres
DB_PASSWORD=password
DB_NAME=challenge_db
DB_SCHEMA=notification_service               # Schema próprio do serviço
RMQ_SERVICE_URL=amqp://admin:admin@rabbitmq:5672

Web (.env):

VITE_API_URL=http://localhost:3001/api       # URL do API Gateway
VITE_WS_URL=http://localhost:3004            # URL do WebSocket (Notifications Service)

Observações sobre configuração:

• Todos os serviços backend usam o mesmo banco PostgreSQL mas com schemas diferentes
• RabbitMQ usa credenciais padrão (admin/admin) - alterar em produção
• JWT_SECRET deve ser uma string aleatória segura - alterar em produção
• CORS está aberto (origin: '*') para desenvolvimento - restringir em produção

🐳 Docker & Compose (sugerido)

version: "3.8"

services:
  # Frontend React Application
  web:
    container_name: web
    build:
      context: .
      dockerfile: ./apps/web/Dockerfile
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - VITE_API_URL=http://localhost:3001/api
      - VITE_WEBSOCKET_URL=ws://localhost:3004
    networks:
      - challenge-network
    command: npm run dev -- --host 0.0.0.0

  # API Gateway
  api-gateway:
    container_name: api-gateway
    build:
      context: .
      dockerfile: ./apps/api-gateway/Dockerfile
    ports:
      - "3001:3001"
    volumes:
      - .:/app
      - ./packages:/app/packages
      - /app/node_modules
      - /app/apps/api-gateway/node_modules
    environment:
      - NODE_ENV=development
      - PORT=3001
      - RMQ_SERVICE_URL=amqp://admin:admin@rabbitmq:5672
    depends_on:
      db:
        condition: service_started
      rabbitmq:
        condition: service_started
    networks:
      - challenge-network

  # Auth Service
  auth-service:
    container_name: auth-service
    build:
      context: .
      dockerfile: ./apps/auth-service/Dockerfile
    volumes:
      - .:/app
      - ./packages:/app/packages
      - /app/node_modules
      - /app/apps/auth-service/node_modules
    environment:
      - NODE_ENV=development
      - DB_HOST=db
      - DB_PORT=5432
      - DB_USERNAME=postgres
      - DB_PASSWORD=password
      - DB_NAME=challenge_db
      - DB_SCHEMA=auth_service
      - JWT_SECRET=cmhinvv760001206gbiowlq9d
      - RMQ_SERVICE_URL=amqp://admin:admin@rabbitmq:5672
    depends_on:
      db:
        condition: service_started
      rabbitmq:
        condition: service_started
    networks:
      - challenge-network

  # Tasks Service
  tasks-service:
    container_name: tasks-service
    build:
      context: .
      dockerfile: ./apps/tasks-service/Dockerfile
    volumes:
      - .:/app
      - ./packages:/app/packages
      - /app/node_modules
      - /app/apps/tasks-service/node_modules
    environment:
      - NODE_ENV=development
      - DB_HOST=db
      - DB_PORT=5432
      - DB_USERNAME=postgres
      - DB_PASSWORD=password
      - DB_NAME=challenge_db
      - DB_SCHEMA=task_service
      - RMQ_SERVICE_URL=amqp://admin:admin@rabbitmq:5672
    depends_on:
      db:
        condition: service_started
      rabbitmq:
        condition: service_started
    networks:
      - challenge-network

  # Notifications Service
  notifications-service:
    container_name: notifications-service
    build:
      context: .
      dockerfile: ./apps/notifications-service/Dockerfile
    ports:
      - "3004:3004"
    volumes:
      - .:/app
      - ./packages:/app/packages
      - /app/node_modules
      - /app/apps/notifications-service/node_modules
    environment:
      - NODE_ENV=development
      - PORT=3004
      - DB_HOST=db
      - DB_PORT=5432
      - DB_USERNAME=postgres
      - DB_PASSWORD=password
      - DB_NAME=challenge_db
      - DB_SCHEMA=notification_service
      - RMQ_SERVICE_URL=amqp://admin:admin@rabbitmq:5672
    depends_on:
      db:
        condition: service_started
      rabbitmq:
        condition: service_started
    networks:
      - challenge-network

  # Postgres Database
  db:
    image: postgres:17.5-alpine3.21
    container_name: db
    attach: false
    ports:
      - "5432:5432"
    networks:
      - challenge-network
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      POSTGRES_PASSWORD: password
      POSTGRES_USER: postgres
      POSTGRES_DB: challenge_db

  # RabbitMQ
  rabbitmq:
    image: rabbitmq:3.13-management-alpine
    container_name: rabbitmq
    attach: false
    ports:
      - "5672:5672"
      - "15672:15672"
    networks:
      - challenge-network
    environment:
      RABBITMQ_DEFAULT_USER: admin
      RABBITMQ_DEFAULT_PASS: admin
    volumes: ["rabbitmq_data:/var/lib/rabbitmq"]

volumes:
  postgres_data:
    driver: local
  rabbitmq_data:
    driver: local

networks:
  challenge-network:
    driver: bridge

Executando com Docker

# Subir todos os serviços
docker compose up

# Ou em modo detached
docker compose up -d

# Ver logs
docker compose logs -f [nome-do-serviço]

# Parar todos os serviços
docker compose down

# Parar e remover volumes (reset completo)
docker compose down -v

Executando em Desenvolvimento Local

pnpm dev

Acessando os Serviços

• Web Application: http://localhost:3000
• API Gateway: http://localhost:3001/api
• Swagger Documentation: http://localhost:3001/docs
• RabbitMQ Management: http://localhost:15672 (user: admin, pass: admin)
• PostgreSQL: localhost:5432 (user: postgres, pass: password)

7. Endpoints da API

Autenticação

POST /api/auth/register
POST /api/auth/login
POST /api/auth/refresh
GET  /api/auth/users
POST /api/auth/users/emails
GET /api/auth/users/{id}
PATCH /api/auth/users/{id}
DELETE /api/auth/users/{id}

Tarefas

GET    /api/tasks?page=1&size=10
POST   /api/tasks
GET    /api/tasks/:id
PATCH    /api/tasks/:id
DELETE /api/tasks/:id

Comentários

POST /api/tasks/:id/comments
GET  /api/tasks/:id/comments?page=1&size=10

Documentação completa disponível em: http://localhost:3001/docs

8. Estrutura de Dados

User

{
  id: string                    // UUID
  username: string              // único, indexado
  email: string                 // único, indexado
  password?: string             // hash bcryptjs
  createdAt: Date
  updatedAt: Date
}

Índices:

• IDX_user_username_unique_lower (unique)
• IDX_user_email_unique_lower (unique)

Task

{
  id: string                    // UUID
  title: string
  description: string           // nullable
  content: string               // nullable
  dueAt: Date                   // prazo, nullable, indexado
  priority: TaskPriorityEnum    // LOW | MEDIUM | HIGH | URGENT
  status: TaskStatusEnum        // TODO | IN_PROGRESS | REVIEW | DONE
  createdBy: string             // UUID do usuário (sem FK - microserviço)
  createdAt: Date
  updatedAt: Date

  // Relações
  assignees: TaskAssignee[]
  comments: TaskComment[]
  history: TaskHistory[]
}

Índices:

• IDX_task_kanban_view (status, priority, dueAt) - para visualização kanban
• IDX_task_due_at
• IDX_task_created_by

Enums:

enum TaskPriorityEnum {
  LOW = "LOW",
  MEDIUM = "MEDIUM",
  HIGH = "HIGH",
  URGENT = "URGENT",
}

enum TaskStatusEnum {
  TODO = "TODO",
  IN_PROGRESS = "IN_PROGRESS",
  REVIEW = "REVIEW",
  DONE = "DONE",
}

TaskAssignee

{
  taskId: string; // UUID (PrimaryColumn)
  userId: string; // UUID (PrimaryColumn) - usuário em outro microsserviço
  assignedAt: Date; // timestamp
  task: Task; // ManyToOne, CASCADE delete
}

Índices:

• IDX_task_assignee_user (userId)

TaskHistory

{
  id: string; // UUID
  taskId: string; // UUID
  actorId: string; // UUID do usuário (nullable - pode ser ação do sistema)
  change: string; // Descrição da mudança
  metadata: Record<string, any>; // Dados adicionais em JSONB
  createdAt: Date; // timestamp indexado
  task: Task; // ManyToOne, CASCADE delete
}

Índices:

• IDX_task_history_task_created (taskId, createdAt)

Comment

{
  id: string; // UUID
  taskId: string; // UUID, indexado
  authorId: string; // UUID do usuário (sem FK - microserviço)
  content: string; // texto do comentário
  createdAt: Date;

  // Relação
  task: Task; // ManyToOne, CASCADE delete
}

Índices:

• IDX_task_comment_task_created (taskId, createdAt)

Notification

{
  id: string                    // UUID
  assigneeIds: string[]         // array de UUIDs, indexado
  taskId: string | null         // UUID, nullable, indexado
  title: string
  content: string
  category: NotificationCategoryEnum
  createdAt: Date               // indexado
}

Índices:

• IDX_notification_assignee_ids
• IDX_notification_created_at
• IDX_notification_task_id

Enums:

enum NotificationCategoryEnum {
  ASSIGNMENT = "ASSIGNMENT",
  CHANGE_STATUS = "CHANGE_STATUS",
  NEW_COMMENT = "NEW_COMMENT",
  GENERAL_UPDATE = "GENERAL_UPDATE",
}

Observações:

• Relacionamentos entre microserviços são feitos via UUIDs sem Foreign Keys
• Cada serviço tem seu próprio banco de dados/schema
• Índices otimizados para queries mais comuns (kanban view, listagens por data, etc)

9. Observações Adicionais

Segurança

• CORS: Configurado para aceitar requisições do frontend (porta 3000)
• Rate Limiting: 10 requisições por segundo no API Gateway
• JWT: Access tokens expiram em 15 minutos, refresh tokens em 7 dias
• Password Hash: bcryptjs com salt rounds padrão (10)
• Validação: Todos os DTOs são validados com class-validator
• Guards: Rotas protegidas com JWT Guard no API Gateway

Padrões de Código

• ESLint: Configuração compartilhada em @repo/eslint-config
• Prettier: Formatação automática com configuração compartilhada
• TypeScript: Strict mode habilitado

Monitoramento

• Health Checks: Endpoint /health em todos os serviços
• Logs: Winston logger configurado (package @repo/logger)
• RabbitMQ Management: Interface web disponível na porta 15672

Banco de Dados

• PostgreSQL 17.5: Versão Alpine para menor footprint
• Schemas separados: Cada microserviço tem seu próprio schema (auth_service, task_service, notification_service)
• Migrations: TypeORM migrations em cada serviço (syncronize: true em desenvolvimento)
• Conexões: Pool de conexões gerenciado pelo TypeORM
• Índices: Criados para otimizar queries comuns
  • Índices compostos para kanban view (status, priority, dueAt)
  • Índices em campos de relacionamento (taskId, userId, assigneeIds)
  • Índices únicos com transformação lowercase em username e email
• Tipos de dados: JSONB para metadata, ENUM para status/prioridade/categoria
• Cascata: DELETE CASCADE configurado em relacionamentos para manter integridade

Docker

• Multi-stage builds: Otimização de imagens Docker
• Hot reload: Volumes montados para desenvolvimento
• Networks: Todos os serviços na mesma network bridge
• Volumes persistentes: PostgreSQL e RabbitMQ com volumes nomeados

Desenvolvimento

• Turborepo: Build e desenvolvimento otimizado com cache
• pnpm: Gerenciador de pacotes rápido e eficiente (workspace protocol)
• Workspace: Packages compartilhados entre apps com workspace:*
• Hot Reload: Configurado em todos os serviços para desenvolvimento
  • Vite HMR no frontend
  • Nest.js watch mode nos microserviços
  • Volumes do Docker mapeados para sincronizar código
• DevTools: TanStack Router DevTools e React Query DevTools no frontend
• Type Generation: TanStack Router auto-gera routeTree.gen.ts

Informações de Contato

• Portfólio: wadev.com.br
• Email: wa.wesley01@gmail.com
• LinkedIn: www.linkedin.com/in/wesleyantonio
• GitHub: https://github.com/WesleyDev184