Pourquoi NestJs est l'un des meilleurs frameworks pour Node?

La communauté de JavaScript est l’une des plus importantes partout dans le monde entier, ce n’est pas étonnant que ce soit l’une des langues les plus utilisées chaque année.

Même si tu développes pour le Backend, tu as beaucoup d’options à choisir. Si tu veux faire du Backend, l’option la plus populaire est ExpressJS. Tu dois installer des plugins dans ton package.json et ensuite commencer à créer une API ou des views qui renvoient du HTML depuis le serveur.

Probablement, tu te poses la question : “Et pourquoi tu préfères NestJS, s’il y a beaucoup d’options populaires comme Express ou Hapi?”

Ici, je te donnerai quelques raisons pour lesquelles j’ai travaillé avec NestJS et pourquoi je le referais encore.

C’est NodeJS (Javascript)

On connaît tous les avantages qu’offre Node.js en tant que framework Backend, comme la vitesse d’exécution et la courbe d’apprentissage pour les personnes qui arrivent depuis le Frontend.

# Installer NestJS globalement
npm i -g @nestjs/cli
# Créer un nouveau projet
nest new project-name

Il recommande, mais ce n’est pas obligatoire, d’avoir un ordre établi pour fonctionner.

Et cela me rappelle Laravel (PHP).

Je voudrais dire que l’organisation des dossiers ressemble à Angular, il ne vous oblige pas à utiliser la méthode MVC, mais c’est suggéré pour maintenir l’ordre. J’ai trouvé qu’une bonne organisation est la combinaison d’un framework MVC + Angular. Toute personne travaillant sur un autre framework Backend (sauf Express JS) se sentira plus à l’aise avec la transition vers Nest.

// Un contrôleur REST commun dans 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);
  }
}

Base de données et les ORMs

Nest fonctionne très bien avec presque tous les moteurs de base de données populaires. Que vous utilisiez MySQL, PostgreSQL, MongoDB, etc.

Il est également compatible avec différents ORMs tels que TypeORM, Sequelize, MikroORM, Prisma, etc.

On peut créer les tables ou schémas de la base de données avec TypeScript, ce qui est très utile pour éviter les erreurs de syntaxe.

// Un modèle de base de données qui utilise TypeORM avec 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;
}

Support pour TypeScript

Depuis 2020, le nombre de développeurs utilisant TypeScript a augmenté. Je pense que cela est dû à la complexité croissante des projets en cours et à la popularité du frontend. Il y a beaucoup de données à connecter entre le backend et le frontend. Il est donc nécessaire de promouvoir des normes afin d’éviter toute confusion concernant les types de variables ou les valeurs renvoyées par les fonctions. C’est là que TypeScript devient très utile.

Lorsque NestJS utilise TypeScript, cela facilite considérablement l’écriture du code et réduit les erreurs liées aux types de données avant la transpilation (ou la compilation).

La documentation

Ce que j’aime dans un framework, ce sont la documentation et les exemples qui sont présentés. Une mauvaise documentation est la principale raison pour laquelle un développeur junior ou mid ne se sent pas très motivé pour travailler sur un framework web, donc pour l’utiliser. Je crois que NestJS répond à cette exigence. C’est l’une des meilleures documentations que j’ai vues avec Laravel.

Environnement de développement très rapide sur SWC

NestJS est livré avec le support de SWC, un outil de compilation réalisé en Rust qui peut augmenter la vitesse de compilation jusqu’à 20 fois plus rapide que le compilateur TypeScript par défaut.

Supports pour des applications sur microservices ou serverless

NestJS n’est pas destiné à être déployé uniquement sur n’importe quel serveur VPS. Il prend aussi en charge le déploiement dans des conteneurs et profite de l’architecture sans serveur.

Il prend même en charge le protocole RPC, ce qui est pratique pour communiquer entre les microservices. Il utilise la bibliothèque gRPC.

Et si tu veux déployer ton application sur un fournisseur sans serveur comme AWS Lambda et éviter de charger toutes les bibliothèques NestJS, NestJS te le permet.

// Comment configurer une application en mode RPC
const app = await NestFactory.createMicroservice<MicroserviceOptions>(AppModule, {
  transport: Transport.GRPC,
  options: {
    package: "hero",
    protoPath: join(__dirname, "hero/hero.proto"),
  },
});

Websockets

Si tu as besoin de connexions en temps réel pour ton application, NestJS offre le support des WebSockets. Il supporte les réponses asynchrones, les réponses multiples, etc.

Support OpenAPI avec Swagger

Si tu as besoin de documenter ton API, NestJS peut se connecter à Swagger. Swagger te permet également d’essayer les points d’extrémité directement depuis le navigateur sans avoir besoin d’un outil de test d’API comme Postman.

C’est aussi utile si tu veux partager les points d’extrémité avec d’autres équipes.

// Ajout de Swagger à ton application
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();

Support pour GraphQL

Si t’as besoin d’intégrer GraphQL, NestJS offre des étapes faciles pour le faire. Faut juste te rappeler que dans cette approche, tu devras abandonner les contrôleurs REST et utiliser plutôt des résolveurs 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

NestJS a récemment ajouté un outil de développement qui te permet de vérifier l’organisation de ton application en temps réel. Tu peux voir comment tes modules et services sont connectés entre eux et éviter les dépendances circulaires.

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

Planificateur de tâches (Cron)

Quand t’as besoin d’exécuter des tâches en arrière-plan, t’as pas besoin d’un cron job qui tourne sur ton serveur. NestJS te permet de le faire avec un décorateur.

Cette fonctionnalité est aussi utile si t’as besoin d’exécuter des tâches automatiques, comme envoyer un email toutes les quelques heures spécifiques ou mettre à jour les informations de ta base de données à n’importe quel moment de la journée.

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

Mise en cache

Si t’as pas envie d’interroger la base de données pour des informations qui ne sont pas souvent mises à jour, NestJS ajoute le support de mise en cache à ton application.

Il n’ajoute pas seulement le support de mise en cache aux endpoints REST, mais aussi aux Websockets et Microservices.

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

Chiffrement et hachage

Quand t’as besoin d’échanger des données entre différents microservices ou parties de ton application, il est important de considérer la sécurité des informations, car elles peuvent être interceptées. Dans NestJS, tu peux chiffrer les données pour assurer leur confidentialité.

NestJS utilise la bibliothèque de cryptographie native de NodeJS, appelée crypto.

// Un exemple de chiffrement avec NestJS
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()]);

Et plus de fonctionnalités

NestJS offre plusieurs autres fonctionnalités qui n’ont pas été mentionnées dans cet article. Voici une liste rapide de ces fonctionnalités qui pourraient t’être utiles :

• Sessions
• Protection CSRF
• Pipes
• Création d’applications CLI
• Healthchecks
• Support pour NATS, MQTT, Kafka, RabbitMQ, etc.

Conclusion

Je pense que ce sont les raisons les plus importantes pour choisir NestJS pour tout nouveau projet nécessitant Node pour le backend. Sans aucun doute, je recommanderais d’utiliser NestJS. Il offre des fonctionnalités supplémentaires qui rendent le développement backend aussi simple et amusant que possible. Je t’encourage à explorer davantage ces fonctionnalités dans la documentation .