Classes personnalisées, middleware global, zéro crash
Utilisez les flèches, cliquez ou glissez pour naviguer
1. Pourquoi des erreurs structurées?
Pas juste throw new Error
2. Classes d'erreur personnalisées
AppError, NotFoundError, ValidationError
3. Middleware d'erreurs global
Les 4 paramètres Express
4. Controller throw, middleware catch
Le pattern ultra-simple
5. Zéro crash serveur
Garantir que le serveur ne crashe jamais
Le problème des erreurs chaotiques
Pourquoi throw new Error ne suffit pas
Classes d'erreur personnalisées
AppError, NotFoundError, ValidationError
Middleware de gestion d'erreurs global
4 paramètres Express — err, req, res, next
Le pattern : controller throw, middleware catch
Séparation parfaite des responsabilités
Le wrapper asyncHandler
Express 4 ne catch pas les erreurs async — la solution
Dans une API Express typique, chaque route gère ses erreurs à sa façon… ou pas du tout
// ❌ Chaque route fait son propre try/catch
app.get('/api/users/:id', async (req, res) => {
try {
const user = await findUser(req.params.id);
if (!user) {
res.status(404).json({ error: 'User not found' });
return;
}
} catch (err) {
res.status(500).json({ error: err.message });
}
});
🔴 Duplication
try/catch partout
🔴 Incohérent
Statuts HTTP variés
🔴 Insécurisé
Message brut exposé
Une erreur non catchée dans une route async
= SERVEUR MORT
Un crash = tous les utilisateurs déconnectés
// ❌ Si findUser lance une erreur :
app.get('/api/users', async (req, res) => {
const users = await findUser();
// Pas de try/catch → 💥
});
Donner une structure à nos erreurs
Chaque erreur transporte un code HTTP
Le frontend sait exactement quoi faire
class AppError extends Error {
constructor(message, statusCode) {
super(message);
this.statusCode = statusCode;
this.isOperational = true;
}
}
message
Message lisible pour le client
statusCode
Code HTTP (400, 404, 500...)
isOperational
Distinguer erreur prévue vs bug
💡 isOperational permet de ne jamais exposer un bug interne au client
NotFoundError
class NotFoundError extends AppError {
constructor(resource = 'Ressource') {
super(`${resource} introuvable`, 404);
}
}
Code HTTP 404 — Ressource non trouvée
ValidationError
class ValidationError extends AppError {
constructor(message, errors = []) {
super(message, 422);
this.errors = errors;
}
}
Code HTTP 422 — Données invalides + détails
✅ Chaque erreur a une sémantique claire et son propre code HTTP
💡 Ajoutez autant de sous-classes que nécessaire : ForbiddenError, ConflictError, etc.
Un seul endroit pour tout catcher
Les 4 paramètres magiques :
err, req, res, next
Si un middleware a exactement 4 paramètres, Express le reconnaît comme gestionnaire d'erreurs
// Middleware d'erreurs global
app.use((err, req, res, next) => {
console.error(err.stack);
const statusCode = err.statusCode || 500;
const message = err.isOperational
? err.message
: 'Erreur interne du serveur';
res.status(statusCode).json({
status: 'error',
message
});
});
⚠️ Si vous oubliez un paramètre ou changez l'ordre, Express ne l'appelle jamais !
Le middleware d'erreurs doit être le dernier app.use()
// ❌ MAUVAIS — les erreurs partent dans le vide
app.use(errorHandler); // ← Trop tôt!
app.use('/api/users', usersRouter);
app.use('/api/products', productsRouter);
✅ BON — tout est attrapé
app.use('/api/users', usersRouter);
app.use('/api/products', productsRouter);
app.use(errorHandler); // ← ICI!
Le controller throw, le middleware catch
Controller
Lance l'erreur
Ne gère rien
Middleware
Attrape tout
Formate la réponse
❌ Avant : try/catch partout
app.get('/users/:id', async (req, res) => {
try {
const user = await db.findUser();
if (!user) res.status(404).json({ ... });
} catch (e) {
res.status(500).json({ ... });
}
});
✅ Après : throw uniquement
app.get('/users/:id', async (req, res) => {
const user = await db.findUser();
if (!user) throw new NotFoundError('Utilisateur');
res.json(user); // OK automatique
});
Le controller gère le succès. L'erreur, c'est le problème du middleware.
Responsabilité unique — chaque pièce fait son job
// GET /api/users/:id — Le controller est PUR
app.get('/api/users/:id', async (req, res) => {
const user = await db.Users.findById(req.params.id);
if (!user) {
throw new NotFoundError('Utilisateur');
}
if (!user.isActive) {
throw new AppError('Compte désactivé', 403);
}
res.json(user); // ✅ Succès
});
✅ Pas de try/catch — pas de res.status().json() en erreur
Le controller ne fait que throw. Le middleware s'occupe du formatage.
Express 4 ne catch PAS les erreurs des fonctions async
Une promesse rejetée non catchée
= Uncaught Promise → 💥 CRASH
// Un petit wrapper qui change tout
const asyncHandler = (fn) => (req, res, next) => {
Promise.resolve(fn(req, res, next))
.catch(next); // ← tout throwé arrive ici → next(err)
};
Sans asyncHandler
async (req, res) => { throw new Error() } → serveur mort
Avec asyncHandler
asyncHandler(async (req, res) => { throw new AppError(...) }) → next(err) → middleware catch
❌ Sans asyncHandler — CRASH
app.get('/users', async (req, res) => {
const users = await User.find();
throw new Error('Boum!');
});
// → UnhandledPromiseRejection
// → node:internal/process/promises → CRASH
✅ Avec asyncHandler — SÉCURISÉ
app.get('/users', asyncHandler(async (req, res) => {
const users = await User.find();
throw new AppError('Boum!', 500);
}));
// → next(err) automatiquement
// → middleware d'erreurs → réponse JSON
💡 asyncHandler est aussi parfois appelé catchAsync ou wrapAsync
// 1. Classes d'erreur ✨
class AppError extends Error { ... }
// 2. asyncHandler (wrapper)
const asyncHandler = fn => (req, res, next) => Promise.resolve(fn(req, res, next)).catch(next);
// 3. Routes — elles throw seulement
app.get('/users/:id', asyncHandler(async (req, res) => {
if (!user) throw new NotFoundError();
res.json(user);
}));
// 4. Middleware d'erreurs global (TOUT À LA FIN)
app.use((err, req, res, next) => { ... });
🎉 Jamais de crash. Jamais de message d'erreur interne exposé. Routes ultra-nettes.
❌ Oublier les 4 paramètres
(err, req, res, next) — pas un de moins!
✅ Vérifiez que vous avez exactement 4 paramètres
❌ Oublier asyncHandler sur les routes async
Le throw dans async devient une promesse rejetée → crash
✅ Toujours wrapper les routes async avec asyncHandler
❌ Middleware d'erreurs avant les routes
Enregistré trop tôt, il ne voit jamais les erreurs des routes
✅ Toujours enregistrer le middleware d'erreurs APRÈS les routes
❌ MAUVAIS — Fuite d'information
app.use((err, req, res, next) => {
res.status(500).json({
error: err.message // ← "Cannot read property of undefined"
});
});
Le hacker sait que c'est une référence null
✅ BON — Message générique
app.use((err, req, res, next) => {
const message = err.isOperational
? err.message
: 'Erreur interne';
res.status(err.statusCode || 500).json({
error: message
});
});
Le client reçoit "Erreur interne" — pas de détail
Règle : isOperational = vrai → messages conçus pour l'utilisateur
Bug imprévu → "Erreur interne" — loggé dans la console pour le développeur
🎯 Les routes ne gèrent JAMAIS les erreurs
Elles throw — c'est tout
🎯 Middleware d'erreurs toujours en DERNIER
Après toutes les routes et tous les autres middlewares
🎯 Ne JAMAIS exposer le vrai message d'un bug au client
isOperational = la barrière de sécurité
🎯 asyncHandler est obligatoire pour les routes async
Express 4 ne catch pas les promesses rejetées
1. Structure tes erreurs
AppError + sous-classes avec code HTTP
2. Controller throw, middleware catch
Séparation parfaite des responsabilités
3. asyncHandler + 4 paramètres
Les deux secrets pour un serveur in-crash-able
4. Sécurité : isOperational
Jamais de message de bug brut exposé
Ton serveur ne crashera plus jamais
Rappel : throw dans le controller, catch dans le middleware
Et toujours asyncHandler pour les routes async!