Skip to content

Viniciustda/OiTenta / .agents/skills/spec-backend-auth-basic

spec-backend-auth-basic

Unverified

Orquestra a criacao da base de autenticacao do backend, incluindo modulo de dominio, agregados, entidades, repositorios, casos de uso, persistencia, autenticacao JWT e integracao com o NestJS, reaproveitando as skills especializadas do projeto.

Spec Backend Auth Basic

Esta skill e uma orquestradora. Ela existe para conduzir, de forma deterministica, a criacao ou evolucao da base de autenticacao do backend e do banco de dados sem reimplementar o trabalho detalhado das skills especializadas do catalogo.

O foco desta primeira versao e somente:

  • backend
  • dominio
  • persistencia
  • banco de dados
  • autenticacao JWT
  • infraestrutura compartilhada do NestJS para rotas autenticadas

Nao incluir frontend por padrao.

Objetivo

Construir a base de autenticacao do backend da aplicacao de forma orientada por especificacao, coordenando uma sequencia previsivel de skills menores para entregar:

  • modulo de autenticacao criado ou evoluido
  • agregado principal de usuario
  • entidade de usuario
  • contrato de repositorio de usuario
  • casos de uso de registro e login
  • persistencia Prisma
  • provider de criptografia
  • provider de JWT
  • controllers de autenticacao
  • infraestrutura compartilhada do NestJS para proteger endpoints

Natureza da skill

  • Esta skill delega para skills especializadas.
  • Esta skill nao deve duplicar os workflows detalhados das skills filhas.
  • Esta skill deve verificar o resultado de cada etapa antes de avancar.
  • Esta skill deve parar de forma explicita quando faltar uma skill critica do catalogo local.
  • Esta skill deve respeitar a estrutura real do repositorio e evoluir implementacoes existentes antes de recriar do zero.

Entradas obrigatorias

Antes de executar a orquestracao, confirme que estas entradas estao claras:

  1. nome do modulo de autenticacao, quando nao for simplesmente auth
  2. nome do agregado principal de usuario
  3. nome da entidade principal
  4. especificacao minima dos atributos do usuario
  5. confirmacao de que o fluxo inclui, no minimo:
    • cadastro
    • login

Entradas opcionais

Se o usuario informar, incorporar tambem:

  • nome dos casos de uso
  • nome dos endpoints
  • estrutura do payload JWT
  • campos de login
  • regras adicionais de autenticacao
  • se deve usar e-mail como login
  • se deve usar username, telefone ou outro identificador
  • campos obrigatorios de cadastro
  • regras especificas de senha
  • claims desejadas no JWT
  • tempo de expiracao do token
  • se deve haver refresh token nesta primeira versao
  • nomes especificos de arquivos, classes ou rotas

Escopo minimo obrigatorio

Esta skill so esta completa quando a cadeia final contem, no minimo:

  1. endpoint de registro de usuario
  2. endpoint de login
  3. persistencia do usuario
  4. senha protegida por provider tecnico apropriado
  5. geracao de JWT
  6. estrutura para proteger endpoints autenticados
  7. acesso ao usuario autenticado via decorator compartilhado
  8. tratamento centralizado de erro respeitando packages/shared

Limites

  • Nao incluir frontend nesta versao.
  • Nao tentar resolver refresh token, autorizacao por perfil, recuperacao de senha ou confirmacao por e-mail, salvo pedido explicito.
  • O objetivo padrao e autenticacao basica, solida e extensivel.
  • Se o usuario pedir extensoes, mante-las incrementais e simples.

Validacao obrigatoria do catalogo

Antes de qualquer implementacao, verifique a existencia das skills necessarias dentro de .agents/skills.

Procure pelos arquivos:

  • .agents/skills/config-new-module/SKILL.md
  • .agents/skills/config-package-shared/SKILL.md
  • .agents/skills/module-aggregate/SKILL.md
  • .agents/skills/config-module-entity/SKILL.md
  • .agents/skills/module-entity/SKILL.md
  • .agents/skills/module-repository/SKILL.md
  • .agents/skills/module-use-case/SKILL.md
  • .agents/skills/shared-validation-rule/SKILL.md
  • .agents/skills/backend-provider-implementation/SKILL.md
  • .agents/skills/backend-prisma-sync-module/SKILL.md
  • .agents/skills/backend-prisma-repository/SKILL.md
  • .agents/skills/backend-nest-config/SKILL.md
  • .agents/skills/backend-nest-controller/SKILL.md

Regra de resolucao de dependencia por papel

Resolva as skills por papel, nesta ordem:

  1. scaffold de modulo:
    • config-new-module
  2. base compartilhada:
    • config-package-shared
  3. scaffold de agregado:
    • module-aggregate
  4. entidade:
    • preferir config-module-entity
    • se ela nao existir, usar module-entity
    • se nenhuma das duas existir, parar
  5. repositorio de dominio:
    • module-repository
  6. casos de uso:
    • module-use-case
  7. regras compartilhadas:
    • shared-validation-rule, quando necessario
  8. providers tecnicos do backend:
    • backend-provider-implementation
  9. sincronizacao Prisma:
    • backend-prisma-sync-module
  10. implementacao Prisma do repositorio:
  • backend-prisma-repository
  1. infraestrutura compartilhada do Nest:
  • backend-nest-config
  1. controllers do Nest:
  • backend-nest-controller

Comportamento em caso de ausencia

  • Se faltar uma skill obrigatoria, parar imediatamente.
  • Informar exatamente qual skill faltou e para qual papel ela era necessaria.
  • Nao improvisar a implementacao detalhada de uma skill critica ausente.
  • So aceitar fallback quando esta skill o definir explicitamente, como no caso config-module-entity -> module-entity.

Leituras minimas de contexto antes da orquestracao

Antes de chamar as skills filhas, ler o contexto real do repositorio:

  • modules/auth/src/index.ts
  • modules/auth/src/user/model/user.entity.ts
  • modules/auth/src/user/provider/index.ts
  • modules/auth/src/user/provider/user.repository.ts
  • modules/auth/src/user/provider/crypto.provider.ts
  • modules/auth/src/user/usecase/register-user.usecase.ts
  • apps/backend/src/modules/auth/auth.module.ts
  • apps/backend/src/modules/auth/auth.controller.ts
  • apps/backend/src/modules/auth/user.prisma.ts
  • packages/shared/src/error/index.ts
  • packages/shared/src/validation/index.ts
  • packages/shared/src/usecase/index.ts

Tambem procure no backend por:

  • jwt
  • token
  • claims
  • AuthGuard
  • CurrentUser
  • request.user
  • Authorization

O objetivo desta leitura e descobrir se a autenticacao ja existe parcialmente, para evoluir a estrutura encontrada em vez de recriar tudo.

Regras de coerencia de nomes

Durante todo o fluxo:

  • manter consistencia entre nome do modulo, agregado, entidade, repositorio, casos de uso, providers, payload JWT e controllers
  • preferir nomes simples e previsiveis
  • reaproveitar o naming ja existente no repositorio quando houver implementacao parcial
  • evitar criar uma arquitetura paralela ao padrao atual do projeto

Regra especial sobre o modulo

Esta skill deve preferir evoluir o modulo existente antes de criar um novo scaffold.

Fluxo:

  1. se modules/<modulo> e apps/backend/src/modules/<modulo> ja existirem, evoluir a estrutura atual
  2. se o modulo nao existir:
    • tentar usar config-new-module
    • se o catalogo atual so oferecer scaffold que toca frontend, trate isso como efeito colateral tolerado do bootstrap inicial
    • nao expandir, nao evoluir e nao considerar o frontend como parte da entrega desta skill
  3. se o scaffold disponivel nao permitir criar o minimo necessario para seguir com seguranca, parar e reportar a limitacao do catalogo

Sequencia deterministica de orquestracao

Execute as etapas abaixo em ordem. Nao pule validacoes intermediarias.

1. Garantir a base do projeto e do modulo

  • verificar se o projeto ja contem packages/shared, apps/backend, modules/ e apps/backend/src/modules/
  • se o modulo de autenticacao nao existir, acionar config-new-module
  • ao fim, validar que existem:
    • modules/<modulo>/
    • apps/backend/src/modules/<modulo>/
    • apps/backend/src/modules/<modulo>/<modulo>.module.ts

2. Garantir a base compartilhada quando necessario

  • verificar se packages/shared ja contem os contratos e erros necessarios
  • se a base compartilhada estiver ausente ou claramente incompleta para a autenticacao, acionar config-package-shared
  • ao fim, validar a existencia de erros de dominio, validacao, base de UseCase e regras compartilhadas relevantes

3. Criar ou preparar o agregado principal do usuario

  • acionar module-aggregate para o agregado principal do usuario
  • preferir um agregado simples, orientado ao fluxo de autenticacao
  • ao fim, validar estrutura minima do agregado:
    • model/
    • provider/
    • usecase/
    • index.ts

4. Criar a entidade principal do usuario

  • acionar a skill de entidade resolvida no catalogo:
    • config-module-entity, se existir
    • senao module-entity
  • passar nome do modulo, agregado, entidade e atributos minimos
  • incluir validacoes coerentes com:
    • identificador de login
    • senha ou senha em hash
    • campos obrigatorios de cadastro
  • ao fim, validar:
    • arquivo da entidade criado ou atualizado
    • teste da entidade criado ou atualizado
    • regras compartilhadas reutilizadas ou justificadas

5. Criar o contrato de repositorio do usuario

  • acionar module-repository
  • garantir operacoes minimas para o fluxo:
    • criar usuario
    • buscar por identificador de login
    • buscar por id, quando necessario para claims e rotas protegidas
  • ao fim, validar:
    • contrato exportado no agregado
    • fake repository disponivel para testes dos casos de uso

6. Criar os casos de uso principais

  • acionar module-use-case para o caso de uso de registro
  • acionar module-use-case para o caso de uso de login
  • os nomes podem variar conforme a especificacao, mas o fluxo minimo deve continuar cobrindo:
    • cadastro
    • login
  • no caso de registro, garantir orquestracao de validacao do usuario, protecao de senha e persistencia
  • no caso de login, garantir validacao de credenciais e geracao de JWT ou token equivalente definido para o backend
  • ao fim, validar:
    • contratos In e Out coerentes
    • testes dos casos de uso presentes
    • coverage exigida pela skill filha atendida

7. Criar ou reutilizar regras compartilhadas necessarias

  • so acionar shared-validation-rule quando faltar uma regra realmente generica e reutilizavel
  • preferir regras ja existentes em packages/shared/src/validation/rules
  • exemplos possiveis:
    • regra de login por e-mail
    • regra de senha forte
    • regra de hash bcrypt, quando a entidade armazenar somente hash
  • ao fim, validar:
    • nova regra exportada corretamente
    • testes da regra criados

8. Sincronizar o dominio com Prisma e banco de dados

  • acionar backend-prisma-sync-module
  • alinhar entidades do modulo com:
    • apps/backend/prisma/models/<modulo>.model.prisma
    • migrations incrementais do modulo
  • ao fim, validar:
    • schema Prisma atualizado
    • migration gerada
    • banco aplicavel pelo fluxo padrao do projeto

9. Criar a implementacao Prisma do repositorio

  • acionar backend-prisma-repository para o contrato de repositorio principal do usuario
  • garantir implementacoes minimas para:
    • create
    • findById
    • busca por login
    • operacoes adicionais realmente exigidas pelos casos de uso
  • ao fim, validar:
    • classe concreta criada em apps/backend/src/modules/<modulo>/
    • modulo Nest registrando a implementacao concreta

10. Criar implementacoes concretas de providers tecnicos

  • acionar backend-provider-implementation para o provider de criptografia
  • acionar backend-provider-implementation para o provider de JWT
  • o provider de JWT deve cobrir, no minimo:
    • geracao de token
    • validacao de token ou suporte claro para a strategy compartilhada do backend
  • ao fim, validar:
    • implementacoes concretas registradas no modulo Nest
    • dependencias externas instaladas somente se forem necessarias
    • testes adicionados quando houver comportamento observavel relevante

11. Configurar a base compartilhada do NestJS

  • acionar backend-nest-config
  • garantir ao menos:
    • filtro global de erros
    • auth guard JWT
    • decorator de usuario autenticado
    • utilitarios compartilhados para payload ou request autenticado
  • ao fim, validar:
    • controllers nao precisam mais de try/catch repetido apenas para traduzir erro
    • bootstrap do Nest integra a infraestrutura compartilhada

12. Criar os controllers da autenticacao

  • acionar backend-nest-controller para expor os endpoints principais
  • criar ou evoluir o controller de auth para:
    • registro
    • login
  • manter os controllers enxutos e focados em HTTP
  • ao fim, validar:
    • endpoints criados
    • DTOs e contratos coerentes com os casos de uso
    • rotas publicas e rotas protegidas claramente diferenciadas quando necessario

13. Validar a integracao final do backend

  • confirmar que o backend esta pronto para proteger endpoints fechados com usuario autenticado
  • confirmar que ha um caminho claro para request.user ou equivalente via decorator compartilhado
  • validar que o login retorna o token esperado
  • validar que o registro persiste o usuario corretamente

Regras de orquestracao

  • delegar para a skill especializada em vez de repetir suas instrucoes detalhadas
  • sempre passar para a skill filha o resultado concreto da etapa anterior
  • verificar arquivos e testes gerados em cada etapa antes de seguir
  • preferir estruturas simples e faceis de manter
  • manter o fluxo incremental e reversivel
  • respeitar o padrao atual do projeto e o contexto real do repositorio

Regras especificas para autenticacao basica

Na ausencia de instrucao mais forte do usuario, adote defaults simples:

  • login por e-mail quando o identificador nao for informado
  • senha armazenada apenas em formato protegido por provider tecnico
  • JWT com claims minimas e estaveis, como sub e identificador principal de login, quando isso for compativel com o projeto
  • expiracao simples e configuravel do token
  • sem refresh token nesta primeira versao

Se o usuario informar outro identificador principal, adapte todas as etapas para manter coerencia entre entidade, repositorio, caso de uso, persistencia e controller.

Regras de teste e validacao final

Esta skill deve garantir que as skills filhas cumpram seus proprios contratos de teste.

Ao final, validar no minimo:

  1. testes relevantes da entidade
  2. testes relevantes do repositorio de dominio e de seus fakes
  3. testes relevantes dos casos de uso
  4. testes relevantes dos providers tecnicos, quando houver
  5. build do backend
  6. testes relevantes do backend e do modulo auth

Se alguma skill filha exigir coverage de 100% para seu escopo, respeite essa exigencia.

Esta skill nao precisa duplicar os testes das skills filhas, mas precisa verificar que a cadeia final esta consistente.

Condicoes de parada obrigatoria

Pare e reporte com clareza quando ocorrer qualquer um destes casos:

  • falta de skill obrigatoria do catalogo
  • ambiguidade real sobre modulo, agregado, entidade ou provider alvo
  • conflito serio entre a especificacao do usuario e a estrutura atual do repositorio
  • impossibilidade de montar o fluxo minimo de autenticacao sem improvisar arquitetura paralela
  • falha em testes obrigatorios ou build final

Formato do relatorio final

Ao concluir a execucao desta skill, entregar um resumo objetivo com:

  1. skills utilizadas
  2. arquivos principais criados ou alterados
  3. testes executados
  4. o que foi validado com sucesso
  5. pendencias, limitacoes ou proximos passos

Saida esperada

  1. modulo de autenticacao funcional no backend
  2. estrutura de dominio criada ou atualizada
  3. persistencia integrada ao Prisma
  4. providers tecnicos implementados
  5. configuracao Nest compartilhada aplicada
  6. controllers principais da autenticacao criados
  7. JWT integrado
  8. base pronta para proteger endpoints autenticados de outros modulos
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 464kUpdated Claude CodeCodexVerifiedInstall
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 464kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 318kUpdated Claude CodeCodexUnverifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 318kUpdated Claude CodeCodexUnverifiedInstall