NestJS Node.js (Comment ça marche pour les développeurs)

Prise en charge TypeScript

TypeScript, un super-ensemble typé statiquement de JavaScript qui fournit un autocomplétion sophistiqué, une sécurité de type, et des fonctionnalités linguistiques modernes, est utilisé dans la construction de NestJS. Cela augmente la maintenabilité du code et aide à la détection des erreurs lors de la compilation. NestJS prend en charge JavaScript ainsi que TypeScript par défaut, offrant aux développeurs plus de liberté.

Architecture modulaire

L'organisation du code basée sur des modules est encouragée par NestJS. Il est plus facile à maintenir, à faire évoluer et à organiser le code lorsque les composants liés comme les contrôleurs, fournisseurs et services sont encapsulés dans un seul module. Les modules de l'application peuvent être utilisés dans d'autres domaines, encourageant la philosophie DRY (Don't Repeat Yourself).

Injection de dépendances

L'un des principaux atouts de NestJS qui facilite la gestion des dépendances est un système d'injection de dépendances sophistiqué. Grâce à l'utilisation d'injecter des dépendances au lieu de les coder en dur, NestJS crée des composants faiblement couplés et testables. Un code plus modulaire et une meilleure séparation des préoccupations sont également rendus possibles par ce style.

Décorateurs

Les décorateurs sont très utilisés dans NestJS pour créer et configurer des classes et leurs membres. L'utilisation de décorateurs tels que @Controller(), @Get(), @Post(), @Injectable(), et d'autres améliorent la lisibilité et l'expressivité du code en rendant évident ce que fait chaque composant de l'application et comment il se comporte.

Compatibilité avec Express et Fastify

En raison de son adaptabilité, NestJS donne aux développeurs l'option d'utiliser soit Fastify, soit Express comme serveur HTTP sous-jacent. Bien que Fastify offre de meilleures performances, Express est réputé pour être convivial et efficient. Grâce à cette polyvalence, les développeurs peuvent adapter leurs applications pour répondre à des exigences uniques.

Middleware

Les fonctionnalités de middleware similaires à Express sont prises en charge par NestJS. Avant que les requêtes n'atteignent les gestionnaires de route, le middleware peut les traiter, fournissant des fonctionnalités telles que l'analyse du corps, l'authentification et la journalisation. Cela facilite la mise en œuvre d'une logique réutilisable pour le traitement des requêtes.

Gestion des exceptions

NestJS dispose d'un système de gestion des exceptions solide qui permet aux programmeurs de créer des filtres d'exception uniques. Ces filtres peuvent améliorer la gestion des erreurs et la cohérence des réponses à travers l'application en capturant et en traitant les exceptions de manière standardisée.

Tuyaux et Gards

Tuyaux : La transformation et la validation des données sont effectuées à l'aide de tuyaux. Ils peuvent être implémentés au niveau du contrôleur, au niveau du gestionnaire de route, ou globalement. Les tuyaux de validation et de transformation sont intégrés, et des tuyaux personnalisés peuvent également être créés.

Gards : La logique pour l'autorisation et l'authentification est mise en œuvre par les gards. Ils utilisent des règles spécifiques, comme la vérification des rôles ou permissions de l'utilisateur, pour décider d'approuver une requête.

Installer le CLI NestJS

Installez d'abord le CLI NestJS globalement, soit avec Yarn soit avec npm.

npm install -g @nestjs/cli

npm install -g @nestjs/cli

Créer un Nouveau Projet

Pour démarrer un nouveau projet NestJS, utilisez le CLI. Changez "my-nest-app" en le nom du projet que vous souhaitez.

nest new my-nest-app

nest new my-nest-app

Structure du projet

Voici un bref résumé de la structure standard du projet :

src/
├── app.controller.ts
├── app.controller.spec.ts
├── app.module.ts
├── app.service.ts
├── main.ts
test/
├── app.e2e-spec.ts
└── jest-e2e.json

• app.controller.ts : Contient le principal contrôleur de l'application.
• app.service.ts : Contient le principal service de l'application.
• app.module.ts : Le module racine de l'application.
• main.ts : Le point d'entrée de l'application.

Module de Configuration

Pour gérer les configurations, installez le package @nestjs/config.

npm install @nestjs/config

npm install @nestjs/config

Ajoutez le module de configuration au fichier app.module.ts.

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true, // Make the module global
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

Pour accéder aux variables d'environnement, utilisez le service de configuration.

import { Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';

@Injectable()
export class AppService {
  constructor(private configService: ConfigService) {}

  getHello(): string {
    return `Hello World!`;
  }
}

Caractéristiques de IronPDF

npm install @ironsoftware/ironpdf

npm install @ironsoftware/ironpdf

Créer un Service PDF

Pour gérer la génération de PDFs, créez un nouveau service. Ce service convertira les informations HTML en PDFs en utilisant IronPDF.

nest generate service pdf

nest generate service pdf

Appliquez la logique de génération de PDF dans le fichier pdf.service.ts créé.

// src/pdf/pdf.service.ts
import { Injectable } from '@nestjs/common';
const IronPdf = require('@ironsoftware/ironpdf');
const document = IronPdf.PdfDocument;
var config = IronPdf.IronPdfGlobalConfig;
config.setConfig({ licenseKey: '' });

@Injectable()
export class PdfService {
  async generatePdf(htmlContent: string): Promise<Buffer> {
    const pdf = await document.fromHtml(htmlContent);
    const pdfBuffer = await pdf.saveAsBuffer();
    return pdfBuffer;
  }
}

Créer un Contrôleur PDF

Créez un contrôleur pour rendre un point de terminaison disponible pour la création de PDFs.

nest generate controller pdf

nest generate controller pdf

Créez un point de terminaison dans le fichier pdf.controller.ts résultant qui prend la saisie HTML et produit un PDF.

// src/pdf/pdf.controller.ts
import { Controller, Post, Body, Res } from '@nestjs/common';
import { PdfService } from './pdf.service';
import { Response } from 'express';

@Controller('pdf')
export class PdfController {
  constructor(private readonly pdfService: PdfService) {}

  @Post('generate')
  async generatePdf(@Body('html') htmlContent: string, @Res() res: Response) {
    const pdfBuffer = await this.pdfService.generatePdf(htmlContent);
    res.set({
      'Content-Type': 'application/pdf',
      'Content-Disposition': 'attachment; filename=generated.pdf',
      'Content-Length': pdfBuffer.length,
    });
    res.end(pdfBuffer);
  }
}

IronPDF est utilisé pour transformer le contenu HTML en un tampon PDF qui est ensuite renvoyé à l'aide du PdfService. Le PdfService utilise IronPDF pour rendre l'HTML en un PDF. Cette intégration est facilement gérée via le contrôleur NestJS. L'étape suivante est de définir un point de terminaison POST, /generate, pour recevoir le contenu HTML depuis le client. En utilisant la bibliothèque IronPDF, nous convertissons les données HTML fournies en un PDF dans l'API.

Pour être plus précis, nous créons un tampon binaire du fichier PDF en utilisant pdf.saveAsBuffer() et créons un objet PDF à partir du contenu HTML en utilisant IronPdf.fromHtml(htmlContent). Ensuite, ce tampon est renvoyé au client avec le type MIME approprié (application/pdf). Le serveur écoute sur le port 3000 et enregistre tout problème rencontré lors du processus de création de PDF. En réponse, le client reçoit un code d'état 500 en cas d'erreur. Cette configuration aide à créer des factures, des rapports ou d'autres documents pour une application web puisqu'elle permet de créer dynamiquement des PDFs à partir du contenu HTML.