Por que NestJS é um dos melhores frameworks backends do NodeJS?

A comunidade JavaScript é uma das mais significativas globalmente. Não é surpresa que JavaScript é uma das linguagens mais usadas a cada ano.

Esteja você desenvolvendo para Backend, tem muitas opções para escolher. Se quer fazer Backend, a opção mais popular que os desenvolvedores escolhem é o Express JS. Instale as bibliotecas no package.json e pode começar a criação de sua API ou views que retornam HTML do servidor.

Então, quando você lê o título, você dirá: Por que preferiu NestJS sem haver opções mais populares como Express ou Hapi?

Aqui vou te dar algumas razões pelas quais trabalhei em projetos NestJS e voltaria a usá-lo.

É NodeJS (JavaScript)

Todos nós sabemos as vantagens que o NodeJS oferece como framework para Backend, a velocidade de execução e a curva de aprendizado para pessoas que vêm do Frontend.

NodeJs se consagrou como uma das tecnologias mais usadas para desenvolver backend nos últimos anos, já que programadores frontend em Javascript se sentem mais confortáveis trabalhando no backend com uma linguagem que já conhecem.

# Instalando NestJS globalmente
npm i -g @nestjs/cli
# Criando um novo projeto
nest new nome-do-projeto

Recomenda, mas não obriga, uma ordem estabelecida para trabalhar

E isso me lembra bastante o Laravel (PHP).

Deixe-me explicar, a organização das pastas é muito parecida com a do Angular, mas não obriga a ordenar o seu código como você poderia ver nos tutoriais. No entanto, descobri que uma certa maneira de organizar os arquivos é uma combinação de qualquer framework MVC + Angular. Para qualquer pessoa que tenha trabalhado com outro framework Backend que não seja o ExpressJS, a transição para o Nest será mais confortável.

// Um controlador REST comum em NestJS
@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(":id")
  update(@Param("id") id: string, @Body() updateUserDto: UpdateUserDto) {
    return this.usersService.update(+id, updateUserDto);
  }

  @Delete(":id")
  remove(@Param("id") id: string) {
    return this.usersService.remove(+id);
  }
}
y;

Bancos de dados e ORMs

NestJS funciona muito bem com quase todos os motores de banco de dados mais populares, seja MySQL, PostgreSQL, MongoDB, etc.

Além disso, ele vem com suporte para diferentes ORMs, como TypeORM, Sequelize, MikroORM, Prisma, etc.

As tabelas e esquemas do banco de dados podem ser criados com TypeScript, o que é muito útil para evitar erros de sintaxe.

// Um modelo de banco de dados usando TypeORM com TypeScript
import { Entity, Column, PrimaryGeneratedColumn } from "typeorm";

@Entity()
export class Photo {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ length: 500 })
  name: string;

  @Column("text")
  description: string;

  @Column()
  filename: string;

  @Column("int")
  views: number;

  @Column()
  isPublished: boolean;
}

Suporte para TypeScript

Desde 2020, o número de desenvolvedores que usam TypeScript tem aumentado. Acredito que isso se deva à dimensão dos projetos atuais e à popularidade do Frontend. Como existem muitos dados para conectar entre ambos os lados do desenvolvimento: Backend e Frontend, é necessário promover certos padrões para que os novos integrantes de uma equipe não fiquem confusos sobre que tipo de variáveis ou funções devem ser utilizadas em todo o projeto. É aí que o TypeScript será muito útil. Não devemos também esquecer que o suporte de autocompletar, de acordo com o seu editor, é muito mais intuitivo.

Quando o NestJS usa TypeScript, a facilidade de escrever código aumenta consideravelmente, e ao mesmo tempo, os erros nos tipos de dados são reduzidos antes da compilação.

A documentação

O que mais me encanta em um framework é a documentação e os exemplos que se apresentam em seu site.

Uma documentação ruim é uma das principais razões pelas quais um desenvolvedor júnior – intermediário não se sente tão motivado a trabalhar com um framework web e, por consequência, evita seu uso. Acredito que, neste ponto, o NestJS atende a esse requisito. É uma das melhores documentações de framework backend que já vi, ao lado de outros projetos como Laravel.

Ambientes de desenvolvimento rápidos com SWC

O NestJS tem suporte para SWC, um ambiente de compilação feito em Rust, que pode aumentar a velocidade de compilação do TypeScript até 20 vezes mais rápido que o compilador de TypeScript padrão.

Suporte para aplicações em microserviços ou serverless

O NestJS não foi feito apenas para ser implementado em qualquer servidor VPS. Ele também suporta o deploy em contêineres e tira proveito da arquitetura de microserviços.

Inclusive, suporta o protocolo RPC, que é muito útil para a comunicação entre microserviços. Utiliza a biblioteca gRPC.

Também, se você quiser fazer o deploy da sua aplicação em um provedor de serverless, como o AWS Lambda, sem a necessidade de carregar todas as bibliotecas que o framework traz por padrão, o NestJS permite que você faça isso.

// Exemplo de como iniciamos um aplicativo no modo RPC
const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
  transport: Transport.GRPC,
  options: {
    package: "hero",
    protoPath: join(__dirname, "hero/hero.proto"),
  },
});

Websockets

Se você precisa de conexões em tempo real para a sua aplicação, o NestJS permite isso com Websockets. Suportando respostas assíncronas, múltiplas respostas, etc.

Suporte OpenAPI com Swagger

Se você precisa documentar sua API, o NestJS pode se conectar ao Swagger. Além disso, o Swagger permite que você teste seus endpoints diretamente no navegador, sem a necessidade de uma ferramenta de teste de API, como o Postman.

É útil também para compartilhar os endpoints com outras equipes de trabalho.

// Adicionando Swagger à sua aplicação
import { NestFactory } from "@nestjs/core";
import { SwaggerModule, DocumentBuilder } from "@nestjs/swagger";
import { AppModule } from "./app.module";

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  const config = new DocumentBuilder()
    .setTitle("Gatos API")
    .setDescription("Descrição da API de gatos")
    .setVersion("1.0")
    .addTag("gatos")
    .build();
  const document = SwaggerModule.createDocument(app, config);
  SwaggerModule.setup("api", app, document);

  await app.listen(3000);
}
bootstrap();

Suporte GraphQL

Se você precisa integrar GraphQL, o NestJS oferece passos simples para fazê-lo. Apenas lembre-se que, ao fazer isso, você não deve usar os controladores REST e deve utilizar os resolvers do GraphQL.

import { Module } from "@nestjs/common";
import { GraphQLModule } from "@nestjs/graphql";
import { ApolloDriver, ApolloDriverConfig } from "@nestjs/apollo";

@Module({
  imports: [
    GraphQLModule.forRoot<ApolloDriverConfig>({
      driver: ApolloDriver,
    }),
  ],
})
export class AppModule {}

Devtools

O Nest adicionou recentemente uma ferramenta para desenvolvedores que permite visualizar a organização do seu aplicativo em tempo real. Você pode ver como seus módulos e serviços estão conectados entre si e evitar dependências circulares.

@Module({
  imports: [
    DevtoolsModule.register({
      http: process.env.NODE_ENV !== "production",
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

Organização de tarefas (Crons)

Quando for necessário executar tarefas em segundo plano, você não precisa ter um cronjob no seu servidor. NestJS permite que você faça isso com um decorador.

Essa característica é útil se você precisa realizar tarefas automáticas, como enviar um e-mail a cada algumas horas, ou atualizar as informações no banco de dados em algum momento do dia.

import { Injectable, Logger } from "@nestjs/common";
import { Cron } from "@nestjs/schedule";

@Injectable()
export class TasksService {
  private readonly logger = new Logger(TasksService.name);

  @Cron("45 * * * * *")
  handleCron() {
    this.logger.debug("Chamado quando o segundo atual é 45");
  }
}

Cache

Se você não quer fazer uma chamada ao banco de dados para pedaços de informação que não mudam frequentemente, o NestJS permite adicionar cache à sua aplicação.

Isso não apenas adiciona cache aos endpoints REST, mas também a padrões como Websockets e Microserviços.

@Controller()
export class AppController {
  @CacheKey("Chave personalizada")
  @CacheTTL(20)
  findAll(): string[] {
    return [];
  }
}

Criptografia e hash

Quando você precisa trocar dados entre diferentes microserviços ou partes da aplicação, é muito importante considerar a segurança da informação, pois pode ser interceptada. No NestJS, você pode criptografar os dados para garantir sua confidencialidade.

O NestJS utiliza a biblioteca nativa de criptografia do NodeJS chamada crypto.

// Exemplo de criptografia
import { createCipheriv, randomBytes, scrypt } from "crypto";
import { promisify } from "util";

const iv = randomBytes(16);
const password = "Senha utilizada para gerar uma chave";

const key = (await promisify(scrypt)(password, "salt", 32)) as Buffer;
const cipher = createCipheriv("aes-256-ctr", key, iv);

const textToEncrypt = "Nest";
const encryptedText = Buffer.concat([cipher.update(textToEncrypt), cipher.final()]);

E muitas outras características

O NestJS possui muitas outras características que não mencionei neste artigo. Aqui está uma lista rápida de outras funcionalidades que você pode achar úteis.

Sessões
Proteção contra ataques de CSRF
Pipes
Criação de aplicações CLI
Healthchecks
Suporte a NATS, MQTT, Kafka, RabbitMQ, etc.

Conclusão

Estas são as principais razões pelas quais, em qualquer novo projeto que requeira Node para o Backend, eu usaria NestJS sem qualquer dúvida. Claro, há mais recursos que facilitam o trabalho no backend. Deixo tudo isso para que descubras na documentação .