O NestJS é um framework de back-end robusto e eficiente que está ganhando popularidade entre os desenvolvedores Node.js. Escrito em TypeScript, ele oferece uma arquitetura de aplicação escalável e confiável, inspirada no Angular, que facilita a construção de aplicações server-side eficientes e organizadas. Ele também vem com um sistema de injeção de dependências integrado, o que simplifica a gestão de dependências e promove um código mais limpo e testável.
Principais funcionalidades
Modules
No core do NestJS estão os modules, que são unidades fundamentais de organização de código. Cada módulo encapsula uma parte da lógica da aplicação e pode conter componentes como controladores, serviços e entidades.
Controllers
Controllers são responsáveis por manipular as solicitações e respostas HTTP e outros métodos de comunicação. Eles definem rotas e lidam com a lógica de negócios necessária para processar as solicitações dos clientes.
Services
Services no NestJS são classes que encapsulam a lógica de negócios e podem ser reutilizadas em diferentes partes da aplicação. Eles são uma parte crucial do princípio de separação de responsabilidades que o NestJS promove.
Providers
Providers são classes com comportamentos diversos, como repositórios. Você consegue reutilizar essa classe em qualquer módulo que necessite, desde que faça a injeção dela no mesmo, um exemplo seria uma classe de repositório.
Dependency Injection
A injeção de dependência é um design pattern que o NestJS utiliza para aumentar a eficiência e modularidade do código. Ela permite que as classes recebam suas dependências de uma forma controlada e testável.
Primeiro projeto com NestJS
Para iniciar um projeto NestJS, você precisará ter o Node.js instalado em sua máquina. Após isso, a criação de um novo projeto é simples com o uso do CLI (Command Line Interface) do NestJS. Basta seguir os seguintes passos:
1. Instale o CLI do NestJS globalmente:
npm i -g @nestjs/cli
2. Crie um novo projeto:
nest new primeiro-projeto
3. Entre na pasta do projeto:
cd primeiro-projeto
4. Inicie o servidor de desenvolvimento:
npm run start:dev
5. No navegador, ou Postman, acesse a URL: http://localhost:3000
Você deve ver o seguinte resultado:
Mais adiante vamos entender como esse resultado foi gerado.
Estrutura de pasta e arquivos
O NestJS possui a seguinte estrutura de pasta e arquivos, sendo que todo código fonte fica localizado na pasta src. A seguir, vamos entender um pouco melhor dos principais pontos envolvidos no funcionamento do projeto recém-criado:
app.controller.ts: Classe responsável por lidar com requisições HTTP da aplicação, fazendo uso da anotação @Controller(). Note a existência de um método com a anotação @Get, e cujo retorno é uma chamada à classe AppService. Esse é o método que responde à requisição que fizemos na URL localhost:3000 (usando o verbo GET).
import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';
@Controller()
export class AppController {
constructor(private readonly appService: AppService) {}
@Get()
getHello(): string {
return this.appService.getHello();
}
}
app.service.ts: classe responsável por encapsular lógicas e regras. É aqui onde serão injetadas outras classes como os repositórios, utilizando a anotação @Injectable(). Observe o retorno “Hello World!”, que vimos anteriormente no browser quando acessamos a aplicação.
import { Injectable } from '@nestjs/common';
@Injectable()
export class AppService {
getHello(): string {
return 'Hello World!';
}
}
app.module: também conhecido como coração do projeto, é aqui onde é feita toda orquestração de modules, controllers, services, providers entre muitos outros. Como se trata aqui de um projeto recém-criado, temos apenas a declaração do AppController e do AppService, que vimos anteriormente.
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
@Module({
imports: [],
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}
main.ts: arquivo responsável por orquestrar a execução do app.module e iniciar o servidor em uma porta específica (note o uso da porta 3000 que acessamos anteriormente). Este é o ponto de entrada da aplicação.
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
async function bootstrap() {
const app = await NestFactory.create(AppModule);
await app.listen(3000);
}
bootstrap();
Conclusão
O NestJS se destaca como uma opção moderna e eficaz para desenvolvimento de back-end. A modularidade e o sistema de injeção de dependências do NestJS garantem um código organizado, testável e fácil de manter. Se você deseja construir aplicações server-side robustas e escaláveis, esta é uma escolha inteligente que pode impulsionar sua carreira e projetos a novos patamares.