Middleware Express

Logger, Validation et Gestion d'erreurs

Utilisez les flĂšches, cliquez ou glissez pour naviguer

Objectifs de la leçon

1. Créer un middleware de logging

Afficher méthode, URL et temps de réponse

2. Créer un middleware de validation

Vérifier les données avant la route

3. Comprendre l'ordre d'exécution

L'ordre des app.use() est crucial

4. Bloquer une requĂȘte

Ne pas appeler next() pour arrĂȘter

Plan du cours

1

Qu'est-ce qu'un middleware ?

Un filtre entre la requĂȘte et la rĂ©ponse — chaĂźne de montage

2

Structure d'un middleware

function(req, res, next) — next() pour passer au suivant

3

L'ordre compte

app.use() dans l'ordre de dĂ©claration — logger AVANT auth

4

Middleware courants

express.json(), logger, CORS, auth — montrer chacun

5

Live coding

Créer un middleware d'authentification qui bloque sans next()

Qu'est-ce qu'un middleware ?

🏭 Une chaüne de montage

Un middleware est un filtre qui se trouve entre la requĂȘte du client et la rĂ©ponse du serveur.

RequĂȘte
→
Middleware 1
→
Middleware 2
→
Middleware 3
→
Route
→
Réponse

// Chaque middleware peut :

- Modifier la requĂȘte

- Modifier la réponse

- Bloquer la requĂȘte (authentification, validation...)

- Passer au suivant avec next()

Structure d'un middleware

3 paramĂštres obligatoires

function( req, res, next )

req

La requĂȘte HTTP entrante

res

La réponse HTTP à envoyer

next

Fonction pour passer au middleware suivant

Exemple de middleware basique

const logger = (req, res, next) => {

console.log('RequĂȘte reçue :', req.method, req.url);

// Passer au middleware suivant

next()

}

// Utiliser le middleware

app.use(logger)

✅ Avec next()

La requĂȘte continue vers la route

❌ Sans next()

La requĂȘte reste bloquĂ©e indĂ©finiment

L'ordre d'exécution est CRUCIAL

⚠ Les middleware s'exĂ©cutent dans l'ordre de dĂ©claration

L'ordre des app.use() détermine l'ordre de passage

const logger = (req, res, next) => {

console.log('1. Logger'); next();

}

const auth = (req, res, next) => {

console.log('2. Auth'); next();

}

// Ordre de déclaration

app.use(logger) // 1ïžâƒŁ S'exĂ©cute en PREMIER

app.use(auth) // 2ïžâƒŁ S'exĂ©cute en DEUXIÈME

💡 Bonne pratique : Logger en premier

Le logger doit voir TOUTES les requĂȘtes, mĂȘme celles bloquĂ©es par l'auth

Visualisation de l'ordre

1ïžâƒŁ

app.use(logger)

Loggue TOUTES les requĂȘtes

2ïžâƒŁ

app.use(express.json())

Parse le body JSON

3ïžâƒŁ

app.use(authMiddleware)

Vérifie l'authentification

4ïžâƒŁ

app.get('/api/users', ...)

La route finale

⚠ Si auth bloque (pas de next()), la route N'EST JAMAIS atteinte

express.json() : Le middleware de parsing

📩 Parse automatiquement le body JSON

C'est un middleware Express intégré

const express = require('express');

const app = express();

// Middleware intégré pour parser JSON

app.use(express.json());

// Maintenant req.body est disponible !

app.post('/api/users', (req, res) => {

console.log(req.body); // { name: "John", age: 30 }

});

💡 Pourquoi c'est un middleware ?

Il modifie req en ajoutant req.body, puis passe au suivant avec next()

Autres middleware courants

📝 Morgan (Logger)

const morgan = require('morgan');

app.use(morgan('dev'));

Loggue automatiquement les requĂȘtes HTTP

🌍 CORS

const cors = require('cors');

app.use(cors());

Autorise les requĂȘtes cross-origin

🔐 Helmet (SĂ©curitĂ©)

const helmet = require('helmet');

app.use(helmet());

Ajoute des headers de sécurité HTTP

📁 Static

app.use(express.static('public'));

Sert les fichiers statiques (CSS, JS, images)

🔐 Middleware d'authentification

Bloquer les requĂȘtes non authentifiĂ©es

Principe : Si pas de token → PAS de next() → RequĂȘte bloquĂ©e

Middleware d'authentification

const authMiddleware = (req, res, next) => {

// Récupérer le token depuis le header

const token = req.headers['authorization'];

// Si pas de token → bloquer la requĂȘte

if (!token) {

return res.status(401).json({

error: 'Token manquant'

});

// PAS de next() → requĂȘte bloquĂ©e !

}

// Token valide → passer au suivant

next()

}

đŸš« Point clĂ© : Pas de next() = requĂȘte bloquĂ©e

C'est comme ça qu'on protÚge les routes sensibles

Utiliser le middleware d'auth

// Appliquer globalement Ă  toutes les routes

app.use(authMiddleware);

// OU appliquer seulement Ă  certaines routes

app.get('/public', (req, res) => {

res.json({ message: 'AccĂšs public' });

});

app.get('/protected', authMiddleware, (req, res) => {

res.json({ message: 'AccÚs protégé' });

});

🌐 app.use(middleware)

Global : s'applique Ă  TOUTES les routes

🎯 app.get('/', middleware, ...)

Spécifique : s'applique seulement à cette route

Middleware de validation

✅ VĂ©rifier les donnĂ©es avant la route

Évite de traiter des donnĂ©es invalides

const validateUser = (req, res, next) => {

// Vérifier que les champs requis sont présents

const { name, email } = req.body;

// Si validation Ă©choue → bloquer

if (!name || !email) {

return res.status(400).json({

error: 'name et email requis'

});

}

// Validation OK → passer au suivant

next()

}

Middleware de logging avancé

⏱ Afficher le temps de rĂ©ponse

Utile pour le monitoring et le débogage

const requestLogger = (req, res, next) => {

// Enregistrer le temps de début

const startTime = Date.now();

// Écouter la fin de la rĂ©ponse

res.on('finish', () => {

// Calculer la durée une fois la réponse envoyée

const duration = Date.now() - startTime;

console.log(`${req.method} ${req.url} - ${duration}ms`);

});

// Passer au middleware suivant

next()

}

⚠ Point clĂ© : res.on('finish')

On ne peut pas calculer la durée juste aprÚs next() : la réponse n'est pas encore envoyée. Il faut attendre l'événement 'finish'. En production, morgan gÚre cela automatiquement.

🚹 Piùge #1 : Oublier next()

L'erreur la plus courante avec les middleware

❌ L'erreur

const logger = (req, res, next) => {

console.log(req.url);

// Oups ! next() oublié

}

La requĂȘte reste bloquĂ©e indĂ©finiment đŸ˜±

✅ La solution

const logger = (req, res, next) => {

console.log(req.url);

next() // ← N'oubliez pas !

}

La requĂȘte continue normalement ✅

💡 RĂšgle d'or : Si vous voulez que la requĂȘte continue, TOUJOURS appeler next()

🚹 Piùge #2 : Mauvais ordre

L'ordre des app.use() peut créer des bugs subtils

❌ Mauvais ordre

app.use(auth) // Bloque si pas de token

app.use(logger) // Jamais atteint si bloqué

Le logger ne voit pas les requĂȘtes bloquĂ©es

✅ Bon ordre

app.use(logger) // Voit TOUTES les requĂȘtes

app.use(auth) // Bloque ensuite

Le logger voit mĂȘme les requĂȘtes bloquĂ©es

💡 Bonne pratique : Logger en PREMIER, auth APRÈS

🚹 Piùge #3 : Global vs Route

Bien distinguer les deux types de middleware

🌐 Middleware Global

app.use(middleware)

S'applique Ă  TOUTES les routes

Idéal : logger, CORS, express.json()

🎯 Middleware de Route

app.get('/', middleware, handler)

S'applique seulement Ă  cette route

Idéal : auth, validation spécifique

💡 Choisir le bon type : Global pour le "toujours", route pour le "parfois"

Middleware de gestion d'erreurs

⚠ 4 paramĂštres, pas 3 !

Le middleware d'erreurs a un paramÚtre supplémentaire : err

const errorHandler = (err, req, res, next) => {

// err est l'erreur qui s'est produite

console.error(err.stack);

// Envoyer une réponse d'erreur

res.status(500).json({

error: 'Erreur serveur',

message: err.message

});

}

// Toujours placer Ă  la FIN

app.use(errorHandler);

💡 Express reconnaüt automatiquement les middleware avec 4 paramùtres comme des gestionnaires d'erreurs

À retenir !

📩 Structure

Un middleware a 3 paramĂštres : req, res, next

next() passe au suivant

đŸš« Blocage

Sans next(), la requĂȘte est bloquĂ©e

C'est comme ça qu'on protÚge les routes

📋 Ordre

L'ordre des app.use() est crucial

Logger avant auth, auth avant routes

⚠ PiĂšges

N'oubliez PAS next() !

Distinguez global vs route

express.json() est un middleware qui parse le body

C'est pour ça qu'il faut app.use(express.json()) avant les routes !