Node.js: Entendendo Controllers em NestJS

NestJS 25 de Jan de 2024

Texto de Paulo Clemente
Desenvolvedor na Rocketseat

No mundo do desenvolvimento de software, especialmente em aplicações web, a eficiência e a organização do código são fundamentais. NestJS, um framework para Node.js, tem ganhado popularidade por oferecer uma estrutura robusta e eficaz para a construção de aplicações server-side. Neste artigo, vamos explorar o conceito de Controllers no NestJS, sua definição, responsabilidades e melhores práticas, incluindo exemplos de código.

Definição e Responsabilidade dos Controllers

Controllers são o coração da interação entre a aplicação Nest.js e o mundo externo. Eles são responsáveis por lidar com as requisições e respostas HTTP. Cada controller geralmente foca em uma área específica da aplicação, como usuários ou produtos, facilitando a organização e a manutenção do código.

Para criar um controller básico, usamos classes e decorators . Os decorators associam classes aos metadados necessários e permitem que o Nest crie um mapa de roteamento.

Vamos analisar e entender um controller básico no Nest.js

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

Decorator @Controller

O @Controller() é um decorator que marca a classe como um controller, que pode lidar com requisições HTTP. Neste caso, não foi especificado nenhum caminho base para as rotas o que significa que este controller lidará com rotas na raiz do domínio. Um exemplo de um decorator com um caminho base especificado seria @Controller(’usuarios’).

Injeção de Dependência

constructor(private readonly appService: AppService) {}

O construtor da classe AppController está injetando uma instância privada de AppService. Isso é feito através da injeção de dependência, uma das principais características do Nest.js que promove o desacoplamento e a modularidade.

O uso de private readonly indica que appService só pode ser acessado dentro desta classe e não pode ser alterado após sua inicialização.

A injeção de dependência é um recurso poderoso no Nest.js, permitindo que as dependências (como serviços) sejam injetadas nos controllers através do construtor. Isso facilita o gerenciamento de dependências e promove a desacoplamento e testabilidade.

Método do Controller:

@Get()
getHello(): string {
    return this.appService.getHello();
}

O método getHello é “decorado” com o @Get(), indicando que ele responderá a requisições HTTP GET. Como não há nenhum caminho especificado no decorator, ele responde à rota raiz.

Dentro do método, ele chama getHello no serviço appService injetado. Isso sugere que há um método getHello dentro da classe AppService que retorna uma string, que é a resposta que o controller enviará de volta ao cliente quando a rota correspondente for acessada.

Então como percebemos que

Decorators como @Get, @Post, @Put, @Delete são usados para associar métodos de um controller a rotas HTTP específicas.

Parâmetros e Roteamento

No Nest.js, parâmetros de rota, query e corpo podem ser acessados usando decorators como @Param, @Query, @Body. Isso permite acessar dados específicos da requisição HTTP de maneira direta e eficiente.

Fluxo de Trabalho no Nest.js

Uma requisição HTTP é recebida por um controller.
O controller usa um serviço para acessar dados ou executar lógica de negócios.
O serviço realiza a operação necessária e retorna os dados para o controller.
O controller envia uma resposta de volta ao cliente.

Essa estrutura e abordagem de design facilitam a manutenção e escalabilidade do aplicativo, tornando-o mais modular e testável. O Nest.js aproveita o TypeScript para oferecer uma experiência de desenvolvimento robusta e produtiva.

O Nest.js é uma ferramenta poderosa para o desenvolvimento de aplicações back-end, e entender como os Controllers funcionam é fundamental para aproveitar ao máximo as capacidades do framework. Com uma estrutura clara e um forte sistema de injeção de dependências, o Nest.js facilita a construção de aplicações escaláveis e manuteníveis. Continue explorando e experimentando com Nest.js para aprofundar ainda mais seus conhecimentos!