🌭 🎙️ 🔤 Rencontrez NestJS 🤚🏼 👩‍👧 💔

Une traduction de l'article a été préparée avant le lancement du cours Node.js Developer .

Les développeurs modernes ont de nombreuses alternatives quand il s'agit de créer des services Web et d'autres applications serveur. Node est devenu un choix extrêmement populaire, cependant, de nombreux programmeurs préfèrent un langage plus robuste que JavaScript, en particulier ceux qui proviennent de langages orientés objet modernes, tels que C #, C ++ ou Java. Si TypeScript convient parfaitement à NodeJS , le cadre NestJS le porte à un tout nouveau niveau, fournissant des outils modernes au développeur principal pour créer des applications durables et hautes performances à l'aide de composants, de fournisseurs, de modules et d'autres abstractions de haut niveau utiles.

Dans cet article, nous examinerons le processus de création d'un serveur API simple sur NestJS pour traiter le scénario d'application de base: créer, stocker et récupérer une liste de produits de supermarché.
Si vous souhaitez vous familiariser avec le code source du projet, vous pouvez le trouver ici .

Création de projet

Pour travailler avec Nest, vous avez besoin d'un environnement Node. Si vous ne l’avez pas encore, accédez à leur site Web et téléchargez-le.

L'installation du framework est assez simple:

$ npm i -g @nestjs/cli

Ce projet a été créé à l'aide de la CLI Nest après avoir exécuté la commande suivante:

$ nest new nest-js-example

Une telle équipe créera un tout nouveau projet Nest avec les fichiers de configuration, la structure de dossiers et le modèle de serveur nécessaires.

Point d'entrée de l'application

Le fichier principal qui configure et démarre le serveur est src/main.ts:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

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

bootstrap();

Ce fichier importe la classe NestFactory , qui est utilisée pour créer l'application, et le fichier AppModule principal (que nous rencontrerons bientôt), puis télécharge l'application, l'instancie et écoute sur le port 3000.

Module d'application

Le fichier dans lequel les composants de l'application sont déclarés est appelé src/app.module.ts:

import { Module } from '@nestjs/common';
import { ItemsController } from './items/items.controller';
import { ItemsService } from './items/items.service';

@Module({
    imports: [],
    controllers: [ ItemsController ],
    providers: [ ItemsService ],
})

export class AppModule {}

Il s'agit du fichier dans lequel les autres composants sont importés et déclarés dans le module, qui est importé dans le fichier précédent ( main.ts ). Les outils Nest CLI mettront automatiquement à jour ce fichier si nécessaire lorsque vous serez invité à créer un nouveau composant. Ici, le contrôleur et le service pour les articles sont importés et ajoutés au module.

Contrôleur d'articles

Le prochain dossier que nous allons examiner est src/items/items.controller.ts:

import { Controller, Req, Get, Post, Body } from '@nestjs/common'
import { CreateItemDto } from './dto/create-item.dto'
import { ItemsService } from './items.service'
import { Item } from './items.interface'

@Controller('items')
export class ItemsController {

    constructor(private readonly itemsService: ItemsService) {}

    @Post()
    create(@Body() data: CreateItemDto): Object {
        return this.itemsService.create(data)
    }

    @Get()
    findAll(): Array<Item> {
        return this.itemsService.findAll()
    }
}

Ce fichier définit le contrôleur pour créer des éléments et obtenir une liste de ceux créés précédemment. Plusieurs composants clés sont importés ici:

CreateItemDto : un objet de transfert de données qui définit comment les données d'élément seront envoyées sur le réseau (c'est-à-dire qu'il s'agit d'une structure de données JSON);
ItemsService: fournisseur qui gère la manipulation ou le stockage des données des articles ;
Article : Une interface qui définit la structure de données interne pour l' article ;

Le décorateur @Controller('items')indique au framework que cette classe servira le point de terminaison REST / items , et le constructeur ItemsController prend une instance de ItemsService , qui est utilisée en interne pour servir deux méthodes HTTP:

POST / items (crée un nouvel élément à partir d'une requête JSON);
GET / items (obtention d'une liste des éléments créés précédemment).

Les demandes pour ces deux méthodes sont traitées par les méthodes create et FindAll, qui sont liées aux méthodes HTTP correspondantes à l'aide des décorateurs @Post()et @Get(). Des méthodes supplémentaires peuvent également être prises en charge par les décorateurs d'une manière similaire, par exemple, @Put()ou @Delete(), etc.

Interfaces d'objets d'objet

Ensuite, nous traiterons de deux fichiers qui définissent des interfaces pour le stockage de l' élément , un pour un usage interne, comme la vérification de type au moment de la compilation ( Item ), et une interface externe pour déterminer la structure attendue de JSON ( CreateItemDto) entrant :

export interface Item {
	
    name: string,
    description: string,
    price: number
}

export class CreateItemDto {

    @IsNotEmpty()
    readonly name: string;

    @IsNotEmpty()
    readonly description: string;

    @IsNotEmpty()
    readonly price: number;
}

L'interface Article définit trois propriétés d'un produit de magasin standard: nom, description et prix. Cela garantit qu'il n'y a pas de confusion dans l'architecture de l'application concernant ce qu'est un élément et ses propriétés.

La classe CreateItemDto reflète les propriétés de l' élément , décorant chaque propriété @IsNotEmpty()pour garantir que toutes ces propriétés sont demandées par le point de terminaison de l'API REST.

Toutes les propriétés des deux classes sont fortement typées, ce qui est l'un des principaux avantages de TypeScript (d'où le nom). À première vue, cela augmente le niveau de compréhension du contexte et réduit considérablement le temps de développement s'il est utilisé correctement avec des outils d'analyse de code (comme IntelliSense dans VSCode). Cela est particulièrement vrai pour les grands projets avec des centaines voire des milliers de classes et d'interfaces différentes. Pour ceux qui n'ont pas une mémoire photographique parfaite avec une capacité infinie (par exemple, pour moi), c'est beaucoup plus facile que d'essayer de se souvenir de milliers de détails spécifiques.

Service d'articles

Le plus récent est un service de création et de réception items: items.service.dart:

import { Injectable } from '@nestjs/common'
import { Item } from './items.interface'

@Injectable()
export class ItemsService {

    private items: Array<Item> = []

    create(item: Item): Object {

        this.items.push(item) 
        return { id: this.items.length.toString() }
    }

    findAll(): Array<Item> {

        return this.items;
    }
}

La classe ItemsService définit un tableau simple d'objets Item qui servira de magasin de données en mémoire pour notre exemple de projet. Deux méthodes qui écrivent et lisent à partir de ce référentiel sont:

create (enregistre l' élément dans la liste et renvoie son identifiant);
findAll (renvoie une liste des objets Item créés précédemment ).

Essai

Pour démarrer le serveur, utilisez la commande standard npm run start . Lorsque l'application est lancée, elle peut être testée en envoyant des requêtes HTTP via CURL :

$ curl -X POST localhost:3000/items -d '{"name":"trinket", "description":"whatever", "price": 42.0}'

L'exécution de cette commande renvoie une réponse JSON avec l' ID généré par l' élément . Pour afficher une liste des éléments déjà créés, utilisez:

$ curl localhost:3000/items

La demande GET à / items ci-dessus renverra une réponse JSON avec des informations sur les éléments qui sont déjà en mémoire. La réponse devrait ressembler à ceci:

[{"{\"name\":\"trinket\", \"description\":\"whatever\", \"price\": 42.0}":""}]

Conclusion

NestJS est une solution relativement nouvelle dans le domaine du développement backend, avec un large éventail de fonctions pour créer et déployer rapidement des services d'entreprise qui répondent aux exigences des clients d'applications modernes et adhèrent aux principes de SOLID et à l'application de douze facteurs .

Pour en savoir plus, visitez le site Web de NestJS .
Merci d'avoir lu mon article. Bon codage!

Rencontrez NestJS