14 minutos de leitura
Autor(a)
Um amante de tecnologia, leitura e da cultura geek, formado Ciência da Computação na Universidade Federal do Tocantins e atualmente cursando Pós-graduação de Arquitetura e Desenvolvimento Java na FIAP. Faço parte do time do Suporte Educacional aqui na Alura.
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
O desenvolvimento backend moderno exige muito mais do que criar rotas e conectar banco de dados. À medida que as aplicações crescem, surgem desafios reais de organização, escalabilidade e manutenção, e é exatamente para isso que o NestJS foi criado.
Neste artigo, você vai entender o que é o NestJS, para que ele serve e por que ele se tornou um dos frameworks Node.js mais adotados por times ao redor do mundo.
Também vai conhecer os conceitos fundamentais da arquitetura, como módulos, controllers, providers, decorators, pipes, guards e interceptors.
Na parte prática, você vai seguir um guia de instalação, aprender boas práticas de organização de código, implementar autenticação com JWT, integrar bancos de dados com Prisma e TypeORM, e entender estratégias de deploy com Docker.
NestJS é um framework progressivo para Node.js, construído sobre TypeScript, projetado para criar aplicações backend de forma rápida, escaláveis e de fácil manutenção.
Inspirado na arquitetura do Angular, o Nest organiza o código em módulos bem definidos, trazendo ordem e previsibilidade a projetos que, de outra forma, poderiam crescer de forma desorganizada.
Avalie este artigo
Diferente de bibliotecas minimalistas como o Express, o NestJS é um framework completo, pois vem com estrutura definida, sistema de injeção de dependência, suporte nativo a TypeScript e abstrações para as tarefas mais comuns do backend.
Apesar disso, é construído sobre o Express por padrão (podendo ser trocado pelo Fastify), o que significa que toda a flexibilidade dessas bibliotecas continua disponível.
A arquitetura do NestJS é baseada em três pilares fundamentais: módulos (que organizam o código em domínios), controllers (que recebem as requisições HTTP) e providers (que encapsulam a lógica de negócio).
O NestJS serve para construir qualquer tipo de aplicação backend moderna. Seja uma API REST simples, uma API GraphQL complexa, um sistema de microsserviços distribuído ou um servidor em tempo real com WebSockets, o framework oferece as ferramentas e abstrações necessárias para cada caso.
Na prática, as equipes de desenvolvimento usam NestJS para:
O framework é especialmente indicado para projetos que precisam crescer ao longo do tempo sem perder qualidade. A modularidade do NestJS permite que novas funcionalidades sejam adicionadas de forma isolada, sem quebrar o que já existe.
Em nosso canal do Youtube, respondemos essa e mais outras perguntas sobre NestJS com ainda mais profundidade:
Quando se trata de escolher um framework para o backend em Node.js, a pergunta mais comum é: por que NestJS em vez de Express puro? A resposta está em escalabilidade, manutenibilidade e experiência do desenvolvedor.
O Express é extremamente flexível e minimalista. Ele resolve o problema imediato, mas deixa decisões arquiteturais para o desenvolvedor: como organizar rotas, onde colocar a lógica de negócio, como gerenciar dependências.
Em projetos pequenos, isso é ótimo, mas em projetos grandes com equipes maiores, essa liberdade vira caos.
O NestJS resolve esse problema com convenções claras e uma estrutura predefinida. Com ele, qualquer desenvolvedor que conhece o framework sabe exatamente onde encontrar cada parte do código, independentemente do projeto.
Além disso, o NestJS oferece nativamente:
Antes de começar a codificar, é fundamental entender os blocos de construção do NestJS. Cada conceito tem um papel específico na arquitetura e, juntos, eles formam uma base sólida para qualquer aplicação.
Injeção de dependência (DI) é um padrão de design em que objetos não criam suas próprias dependências, elas são fornecidas externamente. O NestJS possui um IoC container (Inversion of Control) que gerencia automaticamente a criação e o ciclo de vida dos objetos.
Na prática, isso significa que um serviço não precisa instanciar outro serviço manualmente. O framework cuida disso, tornando o código mais testável, mais desacoplado e mais fácil de manter.
@Injectable()
export class UserService {
constructor(private readonly repo: UserRepository) {}
}Módulos são a unidade organizacional central do NestJS. Cada módulo agrupa um conjunto relacionado de funcionalidades: seus controllers, providers, serviços e imports. A aplicação inteira é uma árvore de módulos, com o `AppModule` na raiz.
A modularidade é um dos maiores diferenciais do framework. Ela permite que times trabalhem de forma isolada em funcionalidades distintas (usuários, pagamentos, notificações) sem interferir uns nos outros.
Controllers são responsáveis por receber as requisições HTTP e retornar respostas. Eles definem as rotas da aplicação usando decoradores como `@Get()`, `@Post()`, `@Put()` e `@Delete()`. A lógica de negócio não deve ficar nos controllers, esse é o papel dos serviços (providers).
@Controller('users')
export class UsersController {
@Get(':id')
findOne(@Param('id') id: string) {
return this.usersService.findOne(id);Providers são classes anotadas com `@Injectable()` que podem ser injetadas em controllers ou em outros providers. Serviços, repositórios, factories e helpers são todos providers. É neles que vive a lógica de negócio da aplicação.
Decoradores (decorators) são funções especiais do TypeScript que adicionam metadados a classes, métodos, propriedades e parâmetros. O NestJS usa decoradores extensivamente para definir rotas `@Get` `@Post`, injetar dependências `@Inject`, aplicar guards `@UseGuards` e muito mais.
Eles tornam o código extremamente expressivo e legível — uma das razões pelas quais desenvolvedores vindos do Angular se adaptam rapidamente ao Nest.
DTOs (Data Transfer Objects) são classes que definem a estrutura dos dados que entram e saem da aplicação. Combinados com a biblioteca `class-validator`, eles permitem validar automaticamente o payload das requisições antes que chegue ao controller.
export class CreateUserDto {
@IsEmail()
email: string;
@MinLength(8)
password: string;
}Pipes são transformadores e validadores que operam nos dados da requisição antes que cheguem ao handler. O pipe mais comum é o `ValidationPipe`, que usa os DTOs para validar automaticamente os dados de entrada e retornar erros descritivos quando a validação falha.
Guards são responsáveis por decidir se uma requisição pode ou não prosseguir. Eles são o mecanismo de autorização do NestJS, verificam se o usuário está autenticado, se possui as permissões necessárias (roles), ou qualquer outra condição de acesso.
Interceptors permitem interceptar a execução de um método antes e depois do seu processamento. São usados para logging, transformação de respostas, tratamento de erros, cache e medição de desempenho. Funcionam de forma similar a um middleware, mas com acesso ao contexto de execução do Nest.
Com os conceitos fundamentais claros, é hora de colocar a mão na massa. O NestJS possui uma CLI oficial que torna a criação e o scaffolding de projetos muito simples.
Certifique-se de ter o Node.js (versão 20 ou superior) instalado. Em seguida, instale a CLI do NestJS globalmente:
npm install -g @nestjs/cli
Com a CLI instalada, crie um projeto:
nest new meu-projetoA CLI vai perguntar qual gerenciador de pacotes usar (npm, yarn ou pnpm). Após a escolha, ela baixa as dependências e cria a estrutura inicial do projeto.
Ao criar um projeto com a nestjs/cli e abri-lo em um editor de texto/IDE, você encontrará a seguinte estrutura:
src/
App.controller.spec.ts # arquivo de teste do Controller
app.controller.ts # Controller principal
app.module.ts # Módulo raiz da aplicação
app.service.ts # Serviço principal
main.ts # Ponto de entrada da aplicação
test/ # Testes e2e
.gitignore # Ignora arquivos para envio do Git
.prettierrc # Configuração de formatação
eslint.config.mjs # Configuração do Eslint
nest-cli.json # Configuração do CLI do Nest
tsconfig.json # Configuração do TypeScript
Para rodar o servidor em modo de desenvolvimento:
npm run start:devO servidor iniciará na porta 3000 por padrão. Acesse http://localhost:3000 e você verá 'Hello World!', sua primeira aplicação NestJS funcionando.
O NestJS já vem com TypeScript configurado. O tsconfig.json do projeto tem configurações essenciais para que os decoradores funcionem corretamente:
"experimentalDecorators": true,
"emitDecoratorMetadata": true,Essas duas opções são obrigatórias para que o sistema de injeção de dependência e os decoradores do NestJS funcionem. Jamais as remova do tsconfig.
Para gerar novos recursos com a CLI, use os comandos de scaffolding:
nest generate module users
nest generate controller users
nest generate service usersEsses três comandos criam automaticamente os arquivos necessários e já registram o controller e o service no módulo correspondente.
À medida que a aplicação cresce, a organização do código se torna cada vez mais importante. O NestJS incentiva uma estrutura por domínio de negócio, em que cada feature tem sua própria pasta com seus módulos, controllers, services e DTOs.
src/
users/
dto/
entities/
users.controller.ts
users.module.ts
users.service.ts
auth/
auth.module.ts
auth.service.ts
jwt.strategy.tsSeguir o princípio de separação de responsabilidades (Separation of Concerns) é fundamental. Controllers apenas roteiam; services contêm a lógica; repositórios acessam o banco. Quando cada camada tem um papel claro, o código fica mais fácil de testar e manter.
O NestJS facilita a implementação de autenticação JWT com o pacote `@nestjs/passport`. O fluxo típico envolve uma estratégia JWT que valida o token e um guard que protege as rotas:
@UseGuards(JwtAuthGuard)
@Get('profile')
getProfile(@Request() req) {
return req.user;
}Para autorização baseada em roles (nestjs authentication com perfis), use um guard customizado que verifica as permissões do usuário:
@Roles('admin')
@UseGuards(JwtAuthGuard, RolesGuard)
@Delete(':id')
remove(@Param('id') id: string) { ... }Para segurança geral da API, instale o helmet (para headers HTTP seguros) e configure rate limiting com `@nestjs/throttler` para prevenir ataques de força bruta.
Entre as possibilidades de integração entre bancos de dados e ORMs, podem-se citar:
TypeORM é o ORM mais popular no ecossistema NestJS. A integração é feita via `@nestjs/typeorm` e permite definir entidades como classes TypeScript com decoradores:
@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number;
@Column({ unique: true })
email: string;
}O Prisma é uma alternativa moderna ao TypeORM que usa um schema declarativo para definir o banco de dados. A integração com NestJS é feita criando um `PrismaService` que estende o `PrismaClient`:
npm install prisma @prisma/client
npx prisma initO Prisma oferece type-safety extrema, cada query retorna tipos gerados automaticamente a partir do schema, eliminando toda uma categoria de bugs relacionados ao banco de dados. Para projetos novos, o Prisma é a escolha preferida pela Developer Experience superior.
Tanto TypeORM quanto Prisma suportam migrations, que versionam as alterações no schema do banco de forma controlada, essencial em qualquer projeto de produção.
Aplicações NestJS em produção se beneficiam de diversas estratégias de otimização. Para cache, o pacote `@nestjs/cache-manager` integra Redis ou cache em memória com uma única linha de configuração.
Para logging estruturado, o NestJS inclui um Logger nativo que pode ser substituído por bibliotecas como Pino ou Winston para logging em JSON, essencial para sistemas de observabilidade como Datadog ou ELK Stack.
O deployment de uma aplicação NestJS com Docker é direto: o projeto gerado pela CLI já suporta a geração de builds otimizados com o comando `npm run build`, que compila o TypeScript para JavaScript puro na pasta dist/.
FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY dist/ ./dist/
CMD ['node', 'dist/main.js']Para CI/CD, o NestJS se integra nativamente com GitHub Actions, GitLab CI e outras ferramentas. A estrutura modular com testes unitários facilita a criação de pipelines que rodam os testes automaticamente a cada pull request.
Para ilustrar o NestJS em ação, veja como criar um endpoint completo de CRUD de usuários, um dos padrões mais comuns em qualquer aplicação backend:
O código abaixo vem do pressuposto da criação da entidade usuário e da camada lógica de service já construídas.
Os métodos do controller não se distanciam em quase nada comparados aos feitos em outras frameworks, mas vale destacar a característica `’:id’` nos decorators para realizar a captura de IDs como parâmetros.
Sendo necessário utilizar o decorator `@Param(‘id’)` para capturar o ID passado como parâmetro de entrada para o método.
// users.controller.ts
@Controller('users')
export class UsersController {
constructor(private readonly usersService: UsersService) {}
@Post()
create(@Body() createUserDto: CreateUserDto) {
return this.usersService.create(createUserDto);
}
@Get()
findAll() { return this.usersService.findAll(); }
@Get(':id')
findOne(@Param('id') id: string) {
return this.usersService.findOne(+id);
}
@Patch()
(() : string, () : UpdateUserDto) {
(+id, dto);
}
@()
(() : string) {
(+id);
}
}Para APIs GraphQL, instale `@nestjs/graphql` e `@nestjs/apollo`. O NestJS suporta tanto a abordagem code-first (em que o schema é gerado a partir do código TypeScript) quanto schema-first. Na abordagem code-first, resolvers substituem os controllers:
@Resolver(() => User)
export class UsersResolver {
@Query(() => [User])
users() { return this.usersService.findAll(); }
@Mutation(() => User)
createUser(@Args('input') input: CreateUserInput) {
return this.usersService.create(input);
}
}O suporte a microservices é nativo no NestJS. Com pouquíssima configuração, é possível transformar um módulo em um microservice que se comunica via TCP, Redis, RabbitMQ ou Kafka:
const app = await NestFactory.createMicroservice(AppModule, {
transport: Transport.RMQ,
options: { urls: ['amqp://localhost'], queue: 'orders_queue' },
});O ponto de partida oficial é a documentação do NestJS, que é uma das mais completas do ecossistema Node.js. Use a documentação como uma companheira de jornada, sempre ande com ela debaixo do braço para onde você for.
Uma forma eficaz de aprendizado é construir um projeto do zero: comece com uma API REST simples com um banco de dados com Prisma, outro com TypeORM, depois adicione a camada de segurança com autenticação JWT.
Adicione complexidades, relacionamentos entre entidades, basicamente, dê sua cara ao projeto.
Para quem deseja mergulhar mais nesse mundo do NestJS, há a carreira Desenvolvimento Backend NodeJS que cobre desde os primeiros passos até casos de uso avançados. E conheça as graduações da FIAP que ajudarão a elevar seus conhecimentos ao nível máximo.
Se você já conhece TypeScript e tem alguma experiência com Node.js, a curva de aprendizado é suave. Os conceitos como injeção de dependência e modularidade podem ser novos, mas a documentação oficial é excelente e há muitos tutoriais disponíveis.
Sim, embora TypeScript seja altamente recomendado. O NestJS funciona com JavaScript, mas perde muitos de seus benefícios mais poderosos, como tipagem forte nos decoradores e a integração com class-validator.
Sim, mas pode parecer excessivo para APIs muito simples. Se o projeto for crescer, NestJS é uma ótima escolha desde o início. Para scripts de uso único ou prototipação veloz, Express ou Fastify podem ser mais ágeis.
Sim. Existe o pacote `@nestjs/platform-fastify` e adaptadores para serverless que permitem rodar aplicações NestJS em ambientes como AWS Lambda, Google Cloud Functions e Vercel.
O NestJS inclui suporte nativo ao Jest. A estrutura modular facilita muito os testes unitários, cada serviço pode ser testado isoladamente, usando mocks das suas dependências. O TestingModule do Nest cria um módulo de teste que replica o ambiente real da aplicação.
