Logger, Validation et Gestion d'erreurs
Utilisez les flĂšches, cliquez ou glissez pour naviguer
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
Qu'est-ce qu'un middleware ?
Un filtre entre la requĂȘte et la rĂ©ponse â chaĂźne de montage
Structure d'un middleware
function(req, res, next) â next() pour passer au suivant
L'ordre compte
app.use() dans l'ordre de dĂ©claration â logger AVANT auth
Middleware courants
express.json(), logger, CORS, auth â montrer chacun
Live coding
Créer un middleware d'authentification qui bloque sans next()
đ 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.
// Chaque middleware peut :
- Modifier la requĂȘte
- Modifier la réponse
- Bloquer la requĂȘte (authentification, validation...)
- Passer au suivant avec next()
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
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
â ïž 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
app.use(logger)
Loggue TOUTES les requĂȘtes
app.use(express.json())
Parse le body JSON
app.use(authMiddleware)
Vérifie l'authentification
app.get('/api/users', ...)
La route finale
â ïž Si auth bloque (pas de next()), la route N'EST JAMAIS atteinte
đŠ 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()
const morgan = require('morgan');
app.use(morgan('dev'));
Loggue automatiquement les requĂȘtes HTTP
const cors = require('cors');
app.use(cors());
Autorise les requĂȘtes cross-origin
const helmet = require('helmet');
app.use(helmet());
Ajoute des headers de sécurité HTTP
app.use(express.static('public'));
Sert les fichiers statiques (CSS, JS, images)
Bloquer les requĂȘtes non authentifiĂ©es
Principe : Si pas de token â PAS de next() â RequĂȘte bloquĂ©e
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
// 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
â 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()
}
â±ïž 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.
L'erreur la plus courante avec les middleware
const logger = (req, res, next) => {
console.log(req.url);
// Oups ! next() oublié
}
La requĂȘte reste bloquĂ©e indĂ©finiment đ±
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()
L'ordre des app.use() peut créer des bugs subtils
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
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
Bien distinguer les deux types de middleware
app.use(middleware)
S'applique Ă TOUTES les routes
Idéal : logger, CORS, express.json()
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"
â ïž 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
đŠ 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 !