¿Por qué NestJS es uno de los mejores frameworks para Node?

La comunidad Javascript es una de las más grandes de desarrollo en todo el mundo, no es de extrañarse entonces que sigue siendo uno de los lenguajes más usados cada año.

Ya sea que estés desarrollando para Backend, tienes muchas opciones desde donde escoger. Si quieres hacer backend, la opción más popular por la cual van muchos desarrolladores es ExpressJS. Instalas un par de librerías en tu package.json y ya puedes comenzar la creación de tu API o vistas que retornen HTML desde el servidor.

Entonces al leer el título te preguntarás: ¿Por qué prefiero NestJS, si hay otras muchas más opciones populares como Express o Hapi?

Acá te daré algunas razones por las cuales he trabajado en algunos proyectos en NestJS y volvería a usarlo.

Es NodeJS (Javascript)

Todos sabemos las ventajas que ofrece NodeJS como framework para Backend, velocidad de ejecución y la curva de aprendizaje para las personas que vienen desde el Frontend.

NodeJs se ha consagrado como una de las tecnologías más usadas para desarrollar backend en los últimos años, puesto que programadores frontend en Javascript se sienten más cómodos trabajando sobre el backend con un lenguaje que ya conocen.

# Instalando NestJS globalmente
npm i -g @nestjs/cli
# Creando un proyecto nuevo
nest new project-name

Recomienda, pero no obliga, un orden establecido para trabajar

Y me recuerda mucho a Laravel (PHP).

Me explico, la organización de carpetas se parece mucho a Angular, no te obliga a ordenar tu código como podrías ver en los tutoriales. Pero he descubierto que cierta manera de organizar los archivos es una combinación de cualquier framework MVC + Angular. Para cualquier persona que trabajo en otro framework Backend que no sea ExpressJS, se sentirá más cómodo haciendo la transición a Nest.

// Un controlador REST común en 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);
  }
}

Bases de datos y ORMs

NestJS funciona muy bien con casi todos los motores de base de datos más populares. Ya sea MySQL, PostgreSQL, MongoDB, etc.

Viene además con soporte para distintos ORM, como TypeORM, Sequelize, MikroORM, Prisma, etc.

Las tablas o esquemas de la base de datos se pueden crear con Typescript, lo cual es muy útil para evitar errores de síntaxis.

// Un modelo de la base de datos usando TypeORM con 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;
}

Soporte para Typescript

Desde 2020 los desarrolladores que usan Typescript van en aumento. Creo que es por la dimensión de los proyectos actuales y la popularidad del frontend. Como hay muchos datos que conectar entre ambos lados del desarrollo: Backend y Frontend, es necesario promover ciertos estándares para que los nuevos integrantes de un equipo no estén confundidos de que tipo de variables o funciones se deben utilizar en todo el proyecto. Es allí donde Typescript será muy útil. Tampoco olvidar el soporte de autocompletado de acuerdo a tu editor es mucho más intuitivo.

Cuando NestJS usa Typescript, la facilidad de escribir código aumenta considerablemente, y así mismo se reducen los errores en los tipos de datos antes de compilación.

Documentación

Lo que más me encanta de un framework es la documentación y ejemplos que se presenten en su sitio web. Una mala documentación es una de las principales razones por la cual un desarrollador junior – mid no se sienta tan motivado a trabajar con un framework web y, por lo tanto, evite su uso. Creo que en este punto NestJS cumple con este requerimiento. Es una de las mejores documentaciones de framework backend que he visto junto a otros proyectos como Laravel.

Entornos de desarrollo veloces con SWC

NestJS tiene soporte para SWC , un entorno de compilación hecho en Rust, que puede incrementar la velocidad de compilación de Typescript hasta 20 veces más rápido que el compilador de Typescript por defecto.

Soporte para aplicaciones en microservicios o serverless

NestJS no sólo está hecho para ser desplegado en cualquier servidor VPS. También tiene soporte para desplegar en contenedores y aprovechar la arquitectura de microservicios.

Incluso soporta el protocolo RPC, que es muy útil para comunicar microservicios entre sí. Usa la librería gRPC.

Además, si quieres desplegar tu aplicación en un proveedor de serverless como AWS Lambda sin necesidad de cargar todas las librerías que el framework trae por defecto, NestJS te permite hacerlo.

// Ejemplo de como levantamos una app en modo RPC
const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
  transport: Transport.GRPC,
  options: {
    package: "hero",
    protoPath: join(__dirname, "hero/hero.proto"),
  },
});

Websockets

Si necesitas conexiones en tiempo real para tu aplicación, NestJS te permite hacerlo con Websockets. Soportando respuestas asíncronas, múltiple respuestas, etc.

Soporte OpenAPI con Swagger

Si necesitas documentar tu API, NestJS puede conectarse a Swagger. Swagger además te permite probar tus endpoint directamente desde el navegador sin el uso de una herramienta para testing de API como Postman.

Es también útil para compartir los endpoint con otros equipos de trabajo.

// Agregando swagger a tu aplicación
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("Cats example")
    .setDescription("The cats API description")
    .setVersion("1.0")
    .addTag("cats")
    .build();
  const document = SwaggerModule.createDocument(app, config);
  SwaggerModule.setup("api", app, document);

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

Soporte GraphQL

Si necesitas integrar GraphQL, NestJS tiene pasos sencillos para hacerlo. Sólo recuerda que en este modo, necesitas dejar de lado los controladores REST y usar los resolvers de 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

Nest agregó recientemente una herramienta para desarrolladores que permite ver la organización de tu aplicación en tiempo real. Puedes ver como tus módulos y servicios están conectados entre sí y evitar las dependencias circulares.

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

Organización de tareas (Crons)

Cuando se necesiten ejecutar tareas en segundo plano, no necesitas tener un cronjob en tu servidor. NestJS te permite hacerlo con un decorador.

Esta característica es útil si necesitas realizar tareas automáticas, como enviar un correo electrónico cada ciertas horas, o actualizar la información en la base de datos en algún momento del día.

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("Called when the current second is 45");
  }
}

Caché

Si no quieres hacer un llamado a la base de datos por pedazos de información que no cambian tan frecuentemente, NestJS permite agregar caché a tu aplicación.

No sólo agrega caché a endpoints REST, sino también a patrones como Websockets y Microservicios.

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

Encriptación y hashing

Cuando se necesita intercambiar la data entre diferentes microservicios o partes de la aplicación, es importante considerar la seguridad de la información, ya que puede ser interceptada. En NestJS, puedes encriptar la data para asegurar su confidencialidad.

Nest JS utiliza la librería nativa de criptografía de NodeJS, llamada crypto.

// Ejemplo de encriptación
import { createCipheriv, randomBytes, scrypt } from "crypto";
import { promisify } from "util";

const iv = randomBytes(16);
const password = "Password used to generate key";

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

Y muchas características más

NestJS tiene muchas más características que no he mencionado en este artículo. Haré un rápido listado de otras características que podrías encontrar útiles:

Sesiones
Protección contra ataques de CSRF
Pipes
Creación de aplicaciones CLI
Healthchecks
Soporte NATS, MQTT, Kafka, RabbitMQ, etc.

Conclusión

Estas creo que son las principales razones por las cuales en cualquier nuevo proyecto que requiera Node para el Backend, yo usaría NestJS sin ninguna duda. Por supuesto hay más features que hacen sencillo el trabajo en el backend. Todo eso te dejo que lo descubras en su documentación .