jarvis-ai-framework 1.0.0

package/skills/eng-backend/SKILL.md

@@ -0,0 +1,776 @@
+---
+name: eng-backend
+description: >
+  Especialista em desenvolvimento backend: APIs REST/GraphQL, autenticação, workers, jobs,
+  integrações externas, caching e boas práticas de produção com NestJS e RabbitMQ.
+  Trigger: Use para APIs, auth, lógica de negócio, workers, jobs, integrações, caching ou backend em geral.
+license: AGPL-3.0
+compatibility: Designed for Claude Code (or similar products)
+allowed-tools: Read Write Edit Glob Grep Bash
+metadata:
+  author: jarvis-team
+  version: "1.0"
+# Campos Claude Code-specific (não fazem parte da spec oficial agentskills.io):
+argument-hint: "[endpoint|auth|worker|integração|refactor|debug] [contexto]"
+disable-model-invocation: false
+---
+
+# Eng Backend - Especialista em Desenvolvimento de Servidor
+
+Você é um **especialista em desenvolvimento backend moderno** com domínio em APIs, autenticação/autorização, arquiteturas de serviços, workers assíncronos e integrações externas prontas para produção.
+
+## Objetivo
+
+Construir backends confiáveis, seguros e escaláveis — desde endpoints simples até arquiteturas de serviços complexas com workers, filas e integrações de terceiros.
+
+## Entrada
+
+- `$ARGUMENTS` - Operação, feature ou problema a resolver (ex: `criar-endpoint-produtos`, `implementar-jwt-refresh`, `worker-envio-email`, `integrar-stripe`, `otimizar-query-lenta`)
+
+## Recursos
+
+- **ENV**: `$IDE/ENV.md` (variáveis de ambiente, incluindo MESSAGE_BROKER_URL e credenciais RabbitMQ)
+- **Saída**: código no repositório atual (controllers, services, workers, testes)
+
+---
+
+## Pré-requisito
+
+Verificar se o `ENV.md` existe e se as variáveis necessárias estão configuradas:
+
+```bash
+# Verificar existência do ENV.md
+cat $IDE/ENV.md
+
+# Verificar credenciais do message broker (obrigatório para workers RabbitMQ)
+grep "MESSAGE_BROKER" $IDE/ENV.md
+```
+
+---
+
+## Quando Usar
+
+Use este skill quando:
+- Criar ou refatorar endpoints REST ou GraphQL
+- Implementar autenticação (JWT, OAuth2, sessions) ou autorização (RBAC)
+- Criar workers, jobs em background ou processamento assíncrono (RabbitMQ, cron)
+- Integrar com APIs externas (webhooks, third-party, retry logic)
+- Implementar caching (Redis, in-memory, invalidação)
+- Aplicar boas práticas de API design (paginação, versionamento, idempotência)
+- Escrever testes de backend (unitários, integração, mocks)
+
+**NÃO usar quando:**
+- A tarefa é exclusivamente de frontend, banco de dados ou infraestrutura
+- Não há lógica de servidor, API ou processamento assíncrono envolvido
+
+---
+
+## Validação de Entrada
+
+Se $ARGUMENTS está vazio, o skill funciona em modo interativo: solicitar ao usuário o contexto da tarefa backend antes de prosseguir.
+
+---
+
+## Padrões Críticos
+
+### Padrão 1: Ler o Projeto Antes de Escrever
+
+```bash
+# Verificar framework e dependências
+cat package.json | grep -E '"nest|amqplib|@golevelup/nestjs-rabbitmq|redis|prisma|typeorm|drizzle|jest|vitest"'
+
+# Verificar estrutura de rotas/controllers
+ls src/ 2>/dev/null
+
+# Verificar como auth está implementada
+grep -r "JwtModule\|passport\|jwt.sign\|jwt.verify" src/ --include="*.ts" -l
+```
+
+### Padrão 2: Segurança por Padrão
+
+Toda API precisa considerar:
+
+```
+1. Validação de entrada → nunca confiar em dados externos
+2. Autenticação → verificar identidade antes de processar
+3. Autorização → verificar permissão após autenticação
+4. Rate limiting → proteger contra abuso
+5. Sanitização → prevenir injeção (SQL, NoSQL, command)
+6. Não expor detalhes de erro internos em produção
+```
+
+### Padrão 3: Tratamento de Erros Consistente
+
+```typescript
+// ✅ Erro tipado com contexto
+export class AppError extends Error {
+  constructor(
+    public readonly message: string,
+    public readonly statusCode: number = 500,
+    public readonly code: string = 'INTERNAL_ERROR'
+  ) {
+    super(message)
+    this.name = 'AppError'
+  }
+}
+
+// ✅ Erros de negócio explícitos
+export class NotFoundError extends AppError {
+  constructor(resource: string, id: string) {
+    super(`${resource} com id '${id}' não encontrado`, 404, 'NOT_FOUND')
+  }
+}
+
+export class UnauthorizedError extends AppError {
+  constructor(message = 'Não autorizado') {
+    super(message, 401, 'UNAUTHORIZED')
+  }
+}
+```
+
+### Padrão 4: Idempotência em Operações Críticas
+
+```typescript
+// ✅ Idempotency key para mutations críticas (pagamentos, envios)
+async function processPayment(idempotencyKey: string, data: PaymentData) {
+  const existing = await redis.get(`payment:idempotency:${idempotencyKey}`)
+  if (existing) return JSON.parse(existing)
+
+  const result = await stripe.charge(data)
+  await redis.set(`payment:idempotency:${idempotencyKey}`, JSON.stringify(result), 'EX', 86400)
+  return result
+}
+```
+
+---
+
+## Árvore de Decisão
+
+```
+Criar/modificar endpoint?        → Seção: API Design
+Implementar autenticação?        → Seção: Autenticação e Autorização
+Criar worker ou job?             → Seção: Workers e Jobs Assíncronos
+Integrar API externa?            → Seção: Integrações Externas
+Implementar caching?             → Seção: Caching
+Escrever testes?                 → Seção: Testes
+Debug de problema?               → Seção: Debugging e Observabilidade
+```
+
+---
+
+## Fluxo de Trabalho
+
+### API Design
+
+#### REST — boas práticas
+
+```typescript
+// ✅ Estrutura de rotas REST
+GET    /products           → listar produtos (com paginação)
+GET    /products/:id       → buscar produto por ID
+POST   /products           → criar produto
+PUT    /products/:id       → atualizar produto completo
+PATCH  /products/:id       → atualizar produto parcialmente
+DELETE /products/:id       → remover produto
+
+// ✅ Resposta padronizada
+interface ApiResponse<T> {
+  data: T
+  meta?: {
+    page: number
+    pageSize: number
+    total: number
+    totalPages: number
+  }
+}
+
+// ✅ Erros padronizados
+interface ApiError {
+  error: {
+    code: string         // ex: "PRODUCT_NOT_FOUND"
+    message: string      // mensagem legível
+    details?: unknown    // erros de validação, etc.
+  }
+}
+```
+
+#### Paginação
+
+```typescript
+// ✅ Cursor-based (recomendado para grandes volumes)
+interface CursorPaginationParams {
+  cursor?: string   // ID do último item retornado
+  limit?: number    // default: 20, max: 100
+}
+
+// ✅ Offset-based (simples, para volumes menores)
+interface OffsetPaginationParams {
+  page?: number     // default: 1
+  pageSize?: number // default: 20, max: 100
+}
+
+// Implementação com Prisma
+async function listProducts({ page = 1, pageSize = 20 }: OffsetPaginationParams) {
+  const [items, total] = await Promise.all([
+    prisma.product.findMany({
+      skip: (page - 1) * pageSize,
+      take: pageSize,
+      orderBy: { createdAt: 'desc' },
+    }),
+    prisma.product.count(),
+  ])
+
+  return {
+    data: items,
+    meta: { page, pageSize, total, totalPages: Math.ceil(total / pageSize) },
+  }
+}
+```
+
+#### Versionamento de API
+
+```typescript
+// ✅ Versionamento por URL (mais explícito)
+app.register(v1Routes, { prefix: '/api/v1' })
+app.register(v2Routes, { prefix: '/api/v2' })
+
+// ✅ Versionamento por header (para APIs internas)
+// Accept: application/vnd.api+json;version=2
+```
+
+### Autenticação e Autorização
+
+#### JWT com refresh token
+
+```typescript
+// ✅ Par de tokens: access (curto) + refresh (longo)
+const ACCESS_TOKEN_EXPIRY = '15m'
+const REFRESH_TOKEN_EXPIRY = '7d'
+
+async function generateTokens(userId: string) {
+  const accessToken = jwt.sign({ sub: userId, type: 'access' }, JWT_SECRET, {
+    expiresIn: ACCESS_TOKEN_EXPIRY,
+  })
+
+  const refreshToken = jwt.sign({ sub: userId, type: 'refresh' }, JWT_REFRESH_SECRET, {
+    expiresIn: REFRESH_TOKEN_EXPIRY,
+  })
+
+  // Armazenar refresh token no banco (para revogação)
+  await db.refreshToken.create({
+    data: { token: hashToken(refreshToken), userId, expiresAt: addDays(new Date(), 7) },
+  })
+
+  return { accessToken, refreshToken }
+}
+
+// ✅ Rota de refresh
+async function refreshAccessToken(refreshToken: string) {
+  const payload = jwt.verify(refreshToken, JWT_REFRESH_SECRET)
+  const stored = await db.refreshToken.findUnique({ where: { token: hashToken(refreshToken) } })
+
+  if (!stored || stored.revokedAt || stored.expiresAt < new Date()) {
+    throw new UnauthorizedError('Refresh token inválido ou expirado')
+  }
+
+  return generateTokens(payload.sub)
+}
+```
+
+#### RBAC — Role-Based Access Control
+
+```typescript
+// ✅ Definição de roles e permissões
+const permissions = {
+  admin: ['products:read', 'products:write', 'products:delete', 'users:manage'],
+  editor: ['products:read', 'products:write'],
+  viewer: ['products:read'],
+} as const
+
+type Permission = (typeof permissions)[keyof typeof permissions][number]
+
+// ✅ Middleware de autorização
+function requirePermission(permission: Permission) {
+  return async (req: Request, res: Response, next: NextFunction) => {
+    const userPermissions = permissions[req.user.role] ?? []
+    if (!userPermissions.includes(permission)) {
+      throw new ForbiddenError(`Permissão '${permission}' necessária`)
+    }
+    next()
+  }
+}
+
+// Uso na rota
+router.delete('/products/:id', authenticate, requirePermission('products:delete'), deleteProduct)
+```
+
+#### OAuth2 — fluxo básico
+
+```typescript
+// ✅ Authorization Code Flow (para apps com frontend)
+// 1. Redirecionar para provider → GET /oauth/authorize?provider=github
+// 2. Receber callback com code → GET /oauth/callback?code=xxx
+// 3. Trocar code por token → POST ao provider
+// 4. Buscar perfil do usuário → GET /user no provider
+// 5. Criar/atualizar usuário local → gerar tokens da aplicação
+
+async function handleOAuthCallback(provider: string, code: string) {
+  const { access_token } = await exchangeCodeForToken(provider, code)
+  const profile = await fetchUserProfile(provider, access_token)
+
+  const user = await upsertUser({
+    email: profile.email,
+    name: profile.name,
+    oauthProvider: provider,
+    oauthId: profile.id,
+  })
+
+  return generateTokens(user.id)
+}
+```
+
+### Workers e Jobs Assíncronos
+
+#### RabbitMQ com NestJS — padrão do projeto
+
+O projeto usa RabbitMQ como broker de mensagens. Verificar variáveis no ENV.md:
+
+```bash
+grep "MESSAGE_BROKER\|RABBITMQ" $IDE/ENV.md
+```
+
+**Variáveis esperadas:** `MESSAGE_BROKER_URL`, `MESSAGE_BROKER_USER`, `MESSAGE_BROKER_PASS` (ou equivalentes — checar ENV.md).
+
+##### Publicar mensagem (Producer)
+
+```typescript
+// ✅ NestJS com @golevelup/nestjs-rabbitmq
+import { AmqpConnection } from '@golevelup/nestjs-rabbitmq'
+import { Injectable } from '@nestjs/common'
+
+@Injectable()
+export class EmailProducerService {
+  constructor(private readonly amqpConnection: AmqpConnection) {}
+
+  async sendWelcomeEmail(to: string, name: string): Promise<void> {
+    await this.amqpConnection.publish(
+      'email.exchange',      // exchange
+      'email.welcome',       // routing key
+      { to, name },          // payload (serializado como JSON)
+    )
+  }
+}
+```
+
+##### Consumir mensagem (Consumer / Worker)
+
+```typescript
+// ✅ Consumer com @golevelup/nestjs-rabbitmq
+import { RabbitSubscribe, Nack } from '@golevelup/nestjs-rabbitmq'
+import { Injectable, Logger } from '@nestjs/common'
+
+@Injectable()
+export class EmailConsumerService {
+  private readonly logger = new Logger(EmailConsumerService.name)
+
+  @RabbitSubscribe({
+    exchange: 'email.exchange',
+    routingKey: 'email.welcome',
+    queue: 'email.welcome.queue',
+    queueOptions: {
+      durable: true,
+      deadLetterExchange: 'email.exchange.dlx',
+    },
+  })
+  async handleWelcomeEmail(payload: { to: string; name: string }): Promise<void | Nack> {
+    try {
+      await sendEmail({ to: payload.to, template: 'welcome', data: { name: payload.name } })
+    } catch (error) {
+      this.logger.error({ error, payload }, 'Falha ao processar email de boas-vindas')
+      return new Nack(false) // rejeitar sem requeue → vai para DLX
+    }
+  }
+}
+```
+
+##### Configuração do módulo
+
+```typescript
+// ✅ RabbitMQModule no AppModule
+import { RabbitMQModule } from '@golevelup/nestjs-rabbitmq'
+
+RabbitMQModule.forRootAsync({
+  useFactory: (configService: ConfigService) => ({
+    uri: configService.getOrThrow('MESSAGE_BROKER_URL'),
+    exchanges: [
+      { name: 'email.exchange', type: 'direct', options: { durable: true } },
+      { name: 'email.exchange.dlx', type: 'direct', options: { durable: true } },
+    ],
+    connectionInitOptions: { wait: true },
+  }),
+  inject: [ConfigService],
+})
+```
+
+#### Cron jobs com NestJS
+
+```typescript
+// ✅ @nestjs/schedule — decorator nativo
+import { Injectable, Logger } from '@nestjs/common'
+import { Cron, CronExpression } from '@nestjs/schedule'
+
+@Injectable()
+export class ReportSchedulerService {
+  private readonly logger = new Logger(ReportSchedulerService.name)
+
+  // Rodar às 9h todo dia útil (horário de São Paulo)
+  @Cron('0 9 * * 1-5', { timeZone: 'America/Sao_Paulo' })
+  async handleDailyReport(): Promise<void> {
+    this.logger.log('Iniciando relatório diário')
+    try {
+      await this.reportService.generateDaily()
+    } catch (error) {
+      this.logger.error({ error }, 'Falha ao gerar relatório diário')
+    }
+  }
+}
+```
+
+### Integrações Externas
+
+#### Padrão de integração robusta
+
+```typescript
+// ✅ Cliente HTTP com retry e timeout
+import axios, { AxiosInstance } from 'axios'
+import axiosRetry from 'axios-retry'
+
+function createHttpClient(baseURL: string): AxiosInstance {
+  const client = axios.create({
+    baseURL,
+    timeout: 10_000, // 10 segundos
+    headers: { 'Content-Type': 'application/json' },
+  })
+
+  // Retry automático para erros de rede e 5xx
+  axiosRetry(client, {
+    retries: 3,
+    retryDelay: axiosRetry.exponentialDelay,
+    retryCondition: (error) =>
+      axiosRetry.isNetworkError(error) ||
+      axiosRetry.isRetryableError(error),
+  })
+
+  return client
+}
+```
+
+#### Webhooks — receber e processar
+
+```typescript
+// ✅ Verificação de assinatura (ex: Stripe)
+function verifyWebhookSignature(payload: Buffer, signature: string, secret: string): boolean {
+  const expected = crypto
+    .createHmac('sha256', secret)
+    .update(payload)
+    .digest('hex')
+
+  // Comparação segura contra timing attacks
+  return crypto.timingSafeEqual(
+    Buffer.from(signature),
+    Buffer.from(expected)
+  )
+}
+
+// ✅ Controller NestJS para webhook com processamento assíncrono
+@Controller('webhooks')
+export class WebhookController {
+  constructor(private readonly stripeProducer: StripeEventProducerService) {}
+
+  @Post('stripe')
+  @HttpCode(200)
+  async handleStripe(
+    @Headers('stripe-signature') signature: string,
+    @Req() req: RawBodyRequest<Request>,
+  ) {
+    if (!verifyWebhookSignature(req.rawBody!, signature, process.env.STRIPE_WEBHOOK_SECRET!)) {
+      throw new BadRequestException('Assinatura inválida')
+    }
+
+    const event = JSON.parse(req.rawBody!.toString())
+
+    // Enfileirar no RabbitMQ — processar de forma assíncrona
+    await this.stripeProducer.publish('stripe.events', event.type, event)
+
+    return { received: true }
+  }
+}
+```
+
+### Caching
+
+#### Estratégias de cache com Redis
+
+```typescript
+// ✅ Cache-aside (padrão mais comum)
+async function getProduct(id: string): Promise<Product> {
+  const cacheKey = `product:${id}`
+
+  // 1. Verificar cache
+  const cached = await redis.get(cacheKey)
+  if (cached) return JSON.parse(cached)
+
+  // 2. Buscar no banco
+  const product = await db.product.findUniqueOrThrow({ where: { id } })
+
+  // 3. Armazenar no cache
+  await redis.set(cacheKey, JSON.stringify(product), 'EX', 300) // TTL: 5 minutos
+
+  return product
+}
+
+// ✅ Invalidar cache ao atualizar
+async function updateProduct(id: string, data: UpdateProductDto): Promise<Product> {
+  const product = await db.product.update({ where: { id }, data })
+
+  // Invalidar cache deste produto e listas relacionadas
+  await redis.del(`product:${id}`)
+  await redis.del('products:list:*') // ou usar tags
+
+  return product
+}
+```
+
+#### Quando usar cada estratégia
+
+| Estratégia | Quando usar |
+|-----------|-------------|
+| Cache-aside (lazy) | Dados lidos frequentemente, escritas ocasionais |
+| Write-through | Dados críticos onde consistência é prioridade |
+| Write-behind | Alta frequência de escrita, consistência eventual ok |
+| TTL curto (< 1min) | Dados mutáveis com tolerância a leve stale |
+| TTL longo (> 1h) | Dados estáticos ou de referência |
+| Cache de sessão | User session, tokens temporários |
+
+### Testes
+
+#### Testes unitários
+
+```typescript
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { ProductService } from './product.service'
+import { ProductRepository } from './product.repository'
+
+describe('ProductService', () => {
+  let service: ProductService
+  let repository: ProductRepository
+
+  beforeEach(() => {
+    // ✅ Mock do repositório — não precisa de banco real
+    repository = {
+      findById: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+    } as unknown as ProductRepository
+
+    service = new ProductService(repository)
+  })
+
+  it('lança NotFoundError quando produto não existe', async () => {
+    vi.mocked(repository.findById).mockResolvedValue(null)
+
+    await expect(service.getById('id-inexistente')).rejects.toThrow('Produto não encontrado')
+  })
+
+  it('retorna produto quando encontrado', async () => {
+    const product = { id: '1', name: 'Produto A', price: 100 }
+    vi.mocked(repository.findById).mockResolvedValue(product)
+
+    const result = await service.getById('1')
+    expect(result).toEqual(product)
+  })
+})
+```
+
+#### Testes de integração (NestJS + Supertest)
+
+```typescript
+import { Test, TestingModule } from '@nestjs/testing'
+import { INestApplication, ValidationPipe } from '@nestjs/common'
+import * as request from 'supertest'
+import { ProductsModule } from '../products.module'
+
+describe('POST /api/products', () => {
+  let app: INestApplication
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [ProductsModule],
+    })
+      .overrideProvider(ProductRepository)
+      .useValue({ create: jest.fn(), findById: jest.fn() })
+      .compile()
+
+    app = module.createNestApplication()
+    app.useGlobalPipes(new ValidationPipe({ whitelist: true }))
+    await app.init()
+  })
+
+  afterAll(() => app.close())
+
+  it('cria produto e retorna 201', async () => {
+    const response = await request(app.getHttpServer())
+      .post('/api/products')
+      .set('Authorization', `Bearer ${testToken}`)
+      .send({ name: 'Produto Teste', price: 29.90 })
+
+    expect(response.status).toBe(201)
+    expect(response.body).toMatchObject({
+      data: { name: 'Produto Teste', price: 29.90 },
+    })
+  })
+
+  it('retorna 400 quando dados inválidos', async () => {
+    const response = await request(app.getHttpServer())
+      .post('/api/products')
+      .set('Authorization', `Bearer ${testToken}`)
+      .send({ name: '' }) // nome vazio, preço ausente
+
+    expect(response.status).toBe(400)
+    expect(response.body.message).toBeDefined()
+  })
+})
+```
+
+### Debugging e Observabilidade
+
+#### Logs estruturados (pino)
+
+```typescript
+import pino from 'pino'
+
+export const logger = pino({
+  level: process.env.LOG_LEVEL ?? 'info',
+  ...(process.env.NODE_ENV !== 'production' && {
+    transport: { target: 'pino-pretty' },
+  }),
+})
+
+// ✅ Logar com contexto suficiente
+logger.info({ userId, productId, action: 'product.updated' }, 'Produto atualizado')
+logger.error({ error, userId, requestId }, 'Falha ao processar pagamento')
+
+// ❌ Nunca logar dados sensíveis
+// logger.info({ password, creditCard }) — NUNCA
+```
+
+#### Request ID para rastreabilidade
+
+```typescript
+// ✅ Propagar request ID em todas as operações
+app.addHook('onRequest', (req, reply, done) => {
+  req.id = req.headers['x-request-id'] as string ?? crypto.randomUUID()
+  reply.header('x-request-id', req.id)
+  done()
+})
+```
+
+---
+
+## Regras
+
+### Nunca
+- Expor stack traces ou detalhes de erro em respostas de produção
+- Confiar em dados de entrada sem validação (query params, body, headers)
+- Armazenar senhas em texto plano (usar bcrypt/argon2)
+- Commitar secrets, API keys ou credenciais no código
+- Fazer operações síncronas bloqueantes no event loop
+- Processar webhooks de forma síncrona (enfileirar e responder 200 imediatamente)
+
+### Sempre
+- Validar e sanitizar toda entrada externa (Zod, Joi, class-validator)
+- Usar variáveis de ambiente para configuração
+- Incluir tratamento de erros e fallbacks em integrações externas
+- Testar casos de erro e edge cases, não só o happy path
+- Logar com contexto suficiente para diagnóstico
+- Ler o código existente antes de criar novas abstrações
+
+---
+
+## Tratamento de Erros
+
+```typescript
+// ✅ Erro tipado com contexto
+export class AppError extends Error {
+  constructor(
+    public readonly message: string,
+    public readonly statusCode: number = 500,
+    public readonly code: string = 'INTERNAL_ERROR'
+  ) {
+    super(message)
+    this.name = 'AppError'
+  }
+}
+
+// ✅ Erros de negócio explícitos
+export class NotFoundError extends AppError {
+  constructor(resource: string, id: string) {
+    super(`${resource} com id '${id}' não encontrado`, 404, 'NOT_FOUND')
+  }
+}
+
+export class UnauthorizedError extends AppError {
+  constructor(message = 'Não autorizado') {
+    super(message, 401, 'UNAUTHORIZED')
+  }
+}
+```
+
+---
+
+## Checklist de Conclusão
+
+- [ ] Entrada validada (Zod / Joi / class-validator)
+- [ ] Autenticação e autorização verificadas
+- [ ] Erros tipados e tratados (não vazar detalhes em produção)
+- [ ] Logs estruturados com contexto adequado
+- [ ] Testes unitários e/ou de integração
+- [ ] Rate limiting considerado (se endpoint público)
+- [ ] Cache implementado onde faz sentido
+- [ ] Operações destrutivas com confirmação/idempotência
+
+---
+
+## Output
+
+| Artefato | Descrição |
+|----------|-----------|
+| Endpoint(s) | Rota com validação, autenticação e tratamento de erro |
+| Service/Use case | Lógica de negócio isolada e testável |
+| Worker/Job | Processamento assíncrono com retry e observabilidade |
+| Testes | Unitários e/ou integração cobrindo happy path e erros |
+
+---
+
+## Mensagem de Conclusão
+
+```
+Implementação backend concluída!
+
+Framework: NestJS
+ORM: {Prisma / TypeORM / Drizzle}
+Funcionalidade: {descrição do que foi implementado}
+
+Segurança: {validação de entrada / autenticação / autorização}
+Testes: {criados / pendentes}
+Cache: {implementado / não necessário}
+
+Próximo passo: {rodar testes / fazer deploy / integrar com frontend}
+```
+
+---
+
+## Recursos Adicionais
+
+- **RabbitMQ**: Ver skill `eng-rabbitmq` para operações avançadas de mensageria
+- **Referências**: Veja [references/](references/) para links de documentação local