Node.

JS

[Link] : Le [Link]

Imaginez une application avec des dizaines de routes pour les utilisateurs, les produits
et les commandes. Si vous mettez tout dans votre fichier principal ([Link]), cela devient
rapidement difficile à lire.

L'objet [Link] qui permet de structurer une application en séparant les routes
en plusieurs modules au lieu de tout écrire dans [Link].

Il permet de regrouper nos routes de manière logique dans des fichiers séparés, ce qui
rend notre code beaucoup plus propre, modulaire et facile à maintenir.

[Link] est un mini-routeur modulaire fourni par [Link].

Le processus se déroule généralement en deux étapes : la définition du routeur dans

un fichier dédié, puis son importation dans l'application principale.

Prof. Mohamed NABIL 158

 [Link]

[Link] : Le [Link]

//Sans Router //Définir des routes avec Router

[Link]('/users', ...) [Link]('/', (req, res) => {
[Link]('/users', ...) [Link]('Liste des utilisateurs');
[Link]('/products', ...) });
[Link]('/', (req, res) => {
Avec Router, on peut organiser :
[Link]('Ajouter un utilisateur');
/users → fichier [Link]
/products → fichier [Link] });
 Code plus propre // ’/ ‘: le chemin relatif au router
 Réutilisable
 Maintenable //Monter le Router dans [Link] :
//Création d’un Router import express from 'express';
import express from 'express'; const app = express();
const router = [Link](); import userRouter from './routes/[Link]';
//router fonctionne comme une mini- [Link]('/users', userRouter);
application Express. Prof. Mohamed NABIL 159
 [Link]

[Link] : Le [Link]

//routes/[Link]
import express from 'express';
const router = [Link](); //[Link]
import express from 'express';
[Link]('/', (req, res) => { const app = express();
[Link]('Tous les users'); import userRouter from './routes/[Link]';
}); [Link]('/users', userRouter);
[Link](3000);
[Link]('/:id', (req, res) => {
[Link](`User ${[Link]}`);
});

export default router;

Prof. Mohamed NABIL 160

 [Link]

[Link] : Le [Link]
//le fichier de routes (routes/[Link]) // [Link]
import express from 'express'; import express from 'express';
const router = [Link](); import userRouter from './routes/[Link]';
// Middleware spécifique à ce routeur const app = express();
[Link]((req, res, next) => { // On "monte" le routeur sur le chemin /users
[Link]('Requête reçue sur le module
[Link]('/users', userRouter);
Utilisateurs');
[Link](3000);
next();
}); GET [Link]
[Link]('/', (req, res) => { // 'Liste des utilisateurs
GET [Link]
[Link]('Liste des utilisateurs');
// Détails de l'utilisateur 2
}); La route parente ne sera pas accessible par
[Link]('/:id', (req, res) => { défaut depuis les sous-routes si elle possède des
[Link](`Détails de l'utilisateur ${[Link]}`); paramètres de chemin.
const router = [Link]({ mergeParams:
});
true })
export default router; Prof. Mohamed NABIL 161
 [Link]

[Link] : Développement de middleware

Un middleware est une fonction qui se situe entre la réception d'une requête HTTP et
l'envoi d'une réponse finale au client.
Les fonctions middleware peuvent effectuer les tâches suivantes :
 Exécuter du code.
 Modifier les objets de requête et de réponse.
 Mettre fin au cycle requête-réponse.
 Appeler le middleware suivant dans la pile.
Si la fonction middleware actuelle ne termine pas le cycle requête-réponse, elle doit
appeler next() pour passer le contrôle à la fonction middleware suivante. Sinon, la requête
restera en suspens.
À partir d'Express 5, les fonctions middleware qui renvoient une promesse appelleront
next(value) lorsqu'elles rejettent la promesse ou lèvent une erreur. next sera appelée
avec la valeur rejetée ou l'erreur levée.
Prof. Mohamed NABIL 162
 [Link]

[Link] : Développement de middleware

Fonction middleware

[Link](path, function(req, res, next) {

next():
})

[Link]('/', (req, res) => {

[Link]('Hello World!')
})

const myLogger = function (req, res, next) {

[Link]('LOGGED')
next()
}
Prof. Mohamed NABIL 163
 [Link]

Le module http : Développement de middleware

Pour charger la fonction middleware, on appelle à

import express from 'express';
const app = express() [Link]() en spécifiant la fonction middleware.
À chaque fois que l'application reçoit une requête, elle
const myLogger = function (req, res, next) {
affiche le message « LOGGED » dans le terminal.
[Link](‘Connected')
next() Les fonctions middlewares chargées en premier sont
}
également exécutées en premier.
[Link](myLogger) myLogger transmet la requête à la fonction
middleware suivante en appelant la fonction next().
[Link]('/', (req, res) => {
[Link]('Hello World!') Si myLogger est chargé après la route vers le chemin
})
racine, la requête ne l'atteint jamais et l'application
[Link](3000) n'affiche pas « LOGGED », car le gestionnaire de route
du chemin racine met fin au cycle requête-réponse.

Prof. Mohamed NABIL 164

 [Link]

Le module http : Développement de middleware

import express from 'express'; Nous allons créer une fonction

const app = express() intermédiaire appelée
requestTime et ajouter une
const requestTime = function (req, res, next) { nouvelle propriété appelée
[Link] = [Link]()
demandTime à l’objet
next()
requête.
}
L'application utilise la fonction
[Link](requestTime)
[Link]('/', (req, res) => { middleware requestTime. De
let responseText = 'Hello World!<br>' plus, la fonction callback de la
responseText += `<small>Requested at: ${[Link]}</small>` route racine utilise la
[Link](responseText) propriété que la fonction
}) middleware ajoute à l'objet
[Link](3000)
requête (req).
Prof. Mohamed NABIL 165
 [Link]

Le module http : Développement de middleware

import express from 'express';

const app = express()
Ce code illustre comment
const requestTime = function (req, res, next) { enrichir une requête avec
[Link] = [Link]()
des informations
next()
supplémentaires avant
}
[Link](requestTime)
qu'elle n'atteigne sa
[Link]('/', (req, res) => { destination finale.
let responseText = 'Hello World!<br>'
responseText += `<small>Requested at: ${[Link]}</small>`
[Link](responseText)
})
[Link](3000)

Prof. Mohamed NABIL 166

 [Link]

Le module http : Utilisation d'un middleware

Une application Express peut utiliser les types de middleware suivants :

 Middleware applicatif
 Middleware de routeur
 Middleware de gestion des erreurs
 Middleware intégré
 Middleware tiers
Vous pouvez charger les middleware applicatifs et de routeur via un chemin de montage
optionnel.
Vous pouvez également charger plusieurs fonctions middleware simultanément, créant
ainsi une sous-pile du système middleware à un point de montage.

Prof. Mohamed NABIL 167

 [Link]

Le module http : Utilisation d'un middleware

Middleware applicatif
Associez un middleware applicatif à une instance de l'objet app à l'aide des fonctions
[Link]() et [Link](), où METHOD représente la méthode HTTP de la requête
gérée par la fonction de middleware (GET, PUT ou POST), en minuscules.
Cet exemple illustre une fonction intermédiaire sans chemin de montage.
Cette fonction est exécutée à chaque fois que l'application reçoit une requête.

import express from 'express'

const app = express()
[Link]((req, res, next) => {
[Link]('Time:', [Link]())
next()
})
Prof. Mohamed NABIL 168
 [Link]

Le module http : Utilisation d'un middleware

Middleware applicatif
Cet exemple illustre une fonction intermédiaire montée sur le chemin /user/:id.
Elle est exécutée pour tout type de requête HTTP sur le chemin /user/:id.

[Link]('/user/:id', (req, res, next) => {

[Link]('Request Type:', [Link])
next()
})
Cet exemple illustre une route et sa fonction de gestion (middleware).
Elle traite les requêtes GET adressées au chemin /user/:id.

[Link]('/user/:id', (req, res, next) => {

[Link]('USER')
})
Prof. Mohamed NABIL 169
 [Link]

Le module http : Utilisation d'un middleware

Middleware applicatif
Ce code charge une série de fonctions middleware à un point de montage, avec un
chemin de montage.
Il affiche des informations de requête pour tout type de requête HTTP adressée au
chemin /user/:id.

[Link]('/user/:id', (req, res, next) => {

[Link]('Request URL:', [Link])
next()
}, (req, res, next) => {
[Link]('Request Type:', [Link])
next()
})
Prof. Mohamed NABIL 170
 [Link]

Le module http : Utilisation d'un middleware

Middleware applicatif
Les gestionnaires de routes permettent de définir plusieurs routes pour un chemin
donné.
Ce code définit deux routes pour les requêtes GET adressées au chemin /user/:id.
La seconde route ne posera aucun problème, mais elle ne sera jamais appelée car la
première route met fin au cycle requête-réponse.
Pour ignorer le reste des fonctions
[Link]('/user/:id', (req, res, next) => {
intermédiaires d'une pile de
[Link]('ID:', [Link])
middleware de routeur, appelez
next() // next('route') to skip to the next route.
next('route') pour passer le contrôle à
}, (req, res, next) => {
la route suivante.
[Link]('User Info')
next('route') ne fonctionnera que dans
})
les fonctions middleware chargées à
[Link]('/user/:id', (req, res, next) => {
l'aide des fonctions [Link]() ou
[Link]([Link])
[Link]().
}) Prof. Mohamed NABIL 171
 [Link]

Le module http : Utilisation d'un middleware

Middleware applicatif
Les middlewares peuvent également être déclarés dans un tableau pour être réutilisés.
Ce code illustre un tableau contenant une sous-pile de middlewares qui gère les requêtes
GET adressées au chemin /user/:id.
function logOriginalUrl (req, res, next) {
[Link]('Request URL:', [Link])
next()
}
function logMethod (req, res, next) {
[Link]('Request Type:', [Link])
next()
}
const logStuff = [logOriginalUrl, logMethod]
[Link]('/user/:id', logStuff, (req, res, next) => {
[Link]('User Info')
}) Prof. Mohamed NABIL 172
 [Link]

Le module http : Utilisation d'un middleware

Middleware de routeur
Le middleware de routeur fonctionne de la même manière que le middleware applicatif,
à la différence qu'il est lié à une instance de [Link]().

const router = [Link]()

Chargez le middleware de niveau routeur à l'aide des fonctions [Link]() et

[Link]().
Le code de la diapositive suivante reproduit le système de middleware applicatif en
utilisant un middleware de routeur :

Prof. Mohamed NABIL 173

 [Link]

Le module http : Utilisation d'un middleware

Middleware de routeur : Le code suivant reproduit le système de middleware applicatif
en utilisant un middleware de routeur.
import express from 'express' [Link]('/user/:id', (req, res, next) => {

const app = express() if ([Link] === '0') next('route')

else next()
const router = [Link]()
}, (req, res, next) => {
[Link]((req, res, next) => {
[Link]('regular')
[Link]('Time:', [Link]())
})
next()
[Link]('/user/:id', (req, res, next) => {
})
[Link]([Link])
[Link]('/user/:id', (req, res, next) => {
[Link]('special')
[Link]('Request URL:', [Link])
})
next()
[Link]('/', router)
}, (req, res, next) => {
[Link]('Request Type:', [Link])
next()
}) Prof. Mohamed NABIL 174
 [Link]

Le module http : Utilisation d'un middleware

Middleware de routeur :
Exécute le code suivant:

import express from 'express'

const app = express()
const router = [Link]()
[Link]((req, res, next) => {
if (![Link]['x-auth']) return next('router')
next()
})
[Link]('/user/:id', (req, res) => {
[Link]('hello, user!')
})
[Link]('/admin', router, (req, res) => {
[Link](401)
})
Prof. Mohamed NABIL 175
 [Link]

Le module http : Utilisation d'un middleware

Middleware de gestion des erreurs :
Un middleware de gestion des erreurs est une fonction spéciale définie avec quatre
arguments (err, req, res, next).
Il sert à capturer les erreurs et d’envoyer une réponse appropriée au client.
Signature unique : Doit toujours inclure err comme premier argument :
[Link]((err, req, res, next) => { ... }).
Positionnement : Il doit être défini en tout dernier, après toutes les autres routes
([Link]()) et middlewares, pour attraper les erreurs des couches précédentes.
Fonctionnement : Lorsqu'un middleware appelle next(err), Express saute tous les autres
middlewares de routage normaux et passe directement à ce gestionnaire.

Prof. Mohamed NABIL 176

 [Link]

Le module http : Création d’une API simple avec [Link]

Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned

Prof. Mohamed NABIL 177