Express

Initialisation

Express est un framework qui permet de faciliter la création de serveur http. En effet nous pourrions créer notre propre serveur web de A à Z en redéfinissant chaque méthode HTTP, chaque route possible mais il faut l'avouer Express mâche tellement le travail des développeur qu'il est devenu un incontournable à connaître pour le milieu du backend NodeJS.

Pour commencer nous allons installer express avec la commande:

npm install express @types/express

Ensuite dans notre fichier main (souvent index.js) nous allons ajouter les lignes suivantes:

import express from 'express';

export const app = express();

const port = 3000;

app.listen(port, () => {
  console.log(`Mon serveur démarre sur le port ${port}`);
});

Remarque: Cette parte de code est pour le moment très similaire à ce que nous faisions précedemment avec le package http, mais patience c'est après qu'express va révéler son intêret.

Remarque Nous exportons notre application express pour pouvoir l'utiliser dans d'autres fichiers. Cela se révèlera utile lorsque nous voudrons tester notre application plus tard.

Routes

Pour le moment Express nous a permis de créer un serveur, ce que le package HTTP pouvait déjà faire. Mais pour créer réellement une API il va falloir gérer des cas de lecture, écriture, modification, suppression, ...

Afin de gérer ces cas nous allons passer par des requêtes HTTP, dont chacune correspondra à un de nos besoins. Lorsque je voudrai accéder à une donnée je réaliserai une requête GET sur mon API (c'est à dire mon serveur NodeJS). De même si je souhaite supprimer une donnée en particulier je ferai une requête DELETE en précisant la donnée que je veux supprimer.

C'est là qu'Express prend toute sa valeur, car le framework possède déjà une liste de fonction permettant de gérer ces cas.

Sur les documentations vous trouverez souvent les routes définies de cette manière: GET:/non-de-la-route. Cela signifie que pour accéder à cette route il faudra faire une requête GET sur /nom-de-la-route.

Lecture via GET

Admettons que je travaille sur une API permettant de gérer une liste d'élèves. Mon application front à besoin d'accéder à cette liste d'élèves et va donc demander une requête GET à mon API (notre serveur hebergé sur localhost:3000) et ce dernier devra lui rendre la fameuse liste. Mais je vais aussi parfois avoir besoin d'obtenir seulement un seul élève. Et dans les deux cas il s'agit d'une requête GET. Afin de différencier ces cas nous allons créer des routes, qui sont en fait des url supplémentaires.

Pour définir une route GET nous allons utiliser la méthode du même nom d'express.

import { Request, Response } from 'express';

// Route pour obtenir la liste des utilisateurs
app.get('/users', (_req: Request, res: Response) => {
  res.status(200).send('Liste des utilisateurs');
});

// Route pour obtenir un utilisateur en particulier
app.get('/user/:id', (_req: Request, res: Response) => {
  res.status(200).send(`Utilisateur ${req.params.id}`);
});

Création via POST

Pour créer une ressource nous allons utiliser la méthode POST. Cette méthode est utilisée pour envoyer des données au serveur. Par exemple, dans le cas d'un formulaire d'inscription, les données du formulaire seront envoyées au serveur avec une requête POST.

import { Request, Response } from 'express';

app.post('/user', (req: Request, res: Response) => {
  res.send(`Ajout de l'utilisateur ${req.body.name}`);
});

Middleware

Les middlewares sont des morceaux de code qui seront executés lors de CHAQUE requête. Les middlewares peuvent se révéler utile lorsque vous avez des opérations communes à réaliser avant ou après chaque requête. Imaginons que je souhaite mettre en place un système d'horodatage des requêtes'.

import { Request, Response, NextFunction } from 'express';

app.use((req: Request, res: Response, next: NextFunction) => {
  const timestamp = new Date().toISOString();
  console.log(`[${timestamp}] Requête reçue : ${req.method} ${req.url}`);
  next(); // Passe à la prochaine fonction middleware ou route
});

Body Parsing

Vous pouvez avoir des soucis lorsque votre requête va essayer de lire votre body. Dans ce cas il faut utiliser un parser qui va formatter la chaîne de caractère reçue pour qu'elle soit interprêtable par Express. Plus de détails sur le body-parser ici.

On va ensuite simplement ajouter un middleware à Express qui demandera d'utiliser ce parser. Par exemple je veux parser un body qui est au format JSON. Ainsi toutes les requêtes qui arriveront sur mon serveur seront parsées.

import express from 'express';
import { Request, Response } from 'express';

export const app = express();
app.use(express.json());

app.post('/user', (req: Request, res: Response) => {
  res.send(`Ajout de l'utilisateur ${req.body.name}`);
});