NestJS: o que é, como usar, para que serve, como instalar

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. 

O que é NestJS? 

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. 

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).  

Para que serve o NestJS? 

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: 

• Criar APIs RESTful robustas e bem-organizadas; 
• Desenvolver sistemas de autenticação e autorização com JWT e Guards; 
• Integrar bancos de dados via TypeORM, Prisma, Mongoose e outros ORMs; 
• Construir arquiteturas de microservices com filas (RabbitMQ, Redis, Kafka); 
• Implementar APIs GraphQL com o módulo @nestjs/graphql; 
• Criar tarefas agendadas, workers e scripts de processamento em background. 

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:

Por que usar o NestJS? 

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. 

NestJS vs Express: qual a diferença? 

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: 

• Suporte total ao TypeScript, com tipagem forte em toda a aplicação; 
• Sistema de injeção de dependência (IoC container) inspirado em frameworks enterprise; 
• Testes unitários e de integração facilitados pela estrutura modular; 
• Decoradores expressivos que tornam o código mais legível e declarativo; 
• Documentação automática com Swagger via `@nestjs/swagger`. 

Conceitos importantes do NestJS 

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. 

O que é injeção de dependência? 

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) {} 
}

O que são módulos? 

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. 

O que são controllers? 

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);

O que são providers? 

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. 

O que são decorators? 

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. 

O que são DTOs? 

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; 
}

O que são pipes? 

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. 

O que são guards? 

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. 

O que são interceptors? 

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. 

Guia de instalação e primeiros passos 

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. 

Instalação do NestJS CLI 

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-projeto

A 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. 

Estrutura de pastas do NestJS 

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:dev

O servidor iniciará na porta 3000 por padrão. Acesse http://localhost:3000 e você verá 'Hello World!', sua primeira aplicação NestJS funcionando. 

Configuração do TypeScript no NestJS 

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 users

Esses três comandos criam automaticamente os arquivos necessários e já registram o controller e o service no módulo correspondente. 

Boas práticas, padrões de código e organização 

À 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.ts

Seguir 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. 

Autenticação, autorização e segurança 

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. 

Integração com bancos de dados e ORMs 

Entre as possibilidades de integração entre bancos de dados e ORMs, podem-se citar:

NestJS com TypeORM 

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; 
}

NestJS com Prisma 

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 init

O 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. 

Desempenho, observabilidade e deployment 

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. 

Casos de uso reais e exemplos de código 

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: 

API REST com NestJS 

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); 
  } 
}

NestJS com GraphQL 

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); 
  } 
}

NestJS Microservices 

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' }, 
});

Como aprender mais sobre NestJS 

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. 

FAQ | Perguntas frequentes sobre NestJS 

1. NestJS é difícil de aprender? 

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. 

2. Posso usar NestJS com JavaScript puro? 

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. 

3. NestJS é adequado para projetos pequenos? 

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. 

4. NestJS funciona com AWS Lambda/serverless? 

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. 

5. Como fazer testes no NestJS? 

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.