Un premier projet avec Node.js

Introduction

Le but de ce chapitre est de mettre en pratique les différentes notions apprises dans les précédents chapitres de l’ouvrage. L’objectif est de développer une API à l’aide de TypeScript et Node.js. Elle sera construite en plusieurs étapes afin de pouvoir expliquer pas à pas les concepts mis en pratique.

Pour développer cette API, il est nécessaire de s’appuyer sur une architecture REST (REpresentational State Transfer). Ce style d’architecture se base sur les verbes et codes HTTP afin de simplifier la compréhension et l’utilisation d’une API.

Dans le cadre de cette mise en pratique, vous allez créer un annuaire d’entreprise permettant de gérer les employés d’une société.

Pour manipuler une API Rest, il est nécessaire d’utiliser un client. Inutile d’installer un logiciel pour cela, car un explorateur d’API sera...

Mise en place du projet

Dans cette section, vous allez mettre en place la structure du projet.

npm init -y 

"name": "employee-directory" 

"private": true 

{ 
  "name": "employee-directory", 
  "version": "1.0.0", 
  "description": "", 
  "main": "index.js", 
  "scripts":...

Création du Framework MVC

Modèle-Vue-Contrôleur (MVC) est un patron de conception très populaire pour développer des applications web. Dans une application MVC, les responsabilités sont réparties entre les éléments suivants :

Ces parties interagissent selon le schéma suivant :

Dans cette section, vous allez créer la partie contrôleur. La partie modèle sera mise en place par la suite.

export type HttpVerb = "get"; 

Validation et OpenApi

Dans cette partie, il s’agit de mettre en place la création des employés dans l’annuaire d’entreprise. Pour ce faire, il est nécessaire de créer une action à exécuter lors d’un appel HTTP de type POST. Les données fournies dans le corps de la requête sont validées à l’aide d’un schéma JSON. Fastify implémente nativement la validation de document JSON via la spécification JSON Schema (https://json-schema.org/).

L’un des intérêts de se baser sur la validation de schéma est qu’elle permet aussi, via d’autres bibliothèques de l’écosystème Fastify, de mettre en place une description et un explorateur d’API de type OpenApi (https://www.openapis.org/).

type SchemaBaseProperty = { 
  description: string; 
}; 

type SchemaIntegerProperty = { 
 
  type: "integer"; 
  minimum?: number; 
}; 

Accès et persistance des données

Accéder et persister les données directement depuis un contrôleur est considéré comme une mauvaise pratique, car cela multiplie les responsabilités du contrôleur et ne permet pas la réutilisabilité de ce code.

Il s’agit donc d’implémenter une vraie couche d’accès aux données en utilisant le patron de conception Repository. Il permet de découpler la persistance des données du reste de l’application en offrant une couche d’abstraction (correspondant à un dépôt de données), et il est utilisable, quel que soit le mode de persistance des données (base de données SQL, fichier plat, données en mémoire…). Ce design pattern accroît la testabilité et la maintenabilité du programme. Grâce à la généricité, il centralise la manière de manipuler les différents objets métier de l’application, évitant ainsi la duplication de code.

export interface IEntity { 
  id: string; 
} 

import type { IEntity } from "../core/data/types"; 

Inversion des dépendances

Dans la section précédente, la classe Repository crée elle-même une instance de la classe MemoryStorage, afin de l’utiliser comme une abstraction dans le reste de la classe (définie par l’interface IStorage). Cette implémentation ne respecte pas le principe SOLID d’inversion des dépendances (cf. chapitre La programmation orientée objet).

Dans cette section, il s’agit de mettre en place l’injection de dépendances afin de respecter ce principe et par conséquent découpler le Repository du stockage des données. De plus, vous définirez une implémentation de l’interface IStorage permettant de persister les données dans un fichier. Cette implémentation pourra ensuite être changée au niveau d’un conteneur de dépendances afin d’être injectée dans le repository.

export class DependencyContainer { 
 
} 

static #instance: DependencyContainer; 

private constructor() { 
 
}