Gestion d'Erreurs dans Express

Classes personnalisées, middleware global, zéro crash

Utilisez les flèches, cliquez ou glissez pour naviguer

Objectifs de la leçon

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

Plan du cours

1

Le problème des erreurs chaotiques

Pourquoi throw new Error ne suffit pas

2

Classes d'erreur personnalisées

AppError, NotFoundError, ValidationError

3

Middleware de gestion d'erreurs global

4 paramètres Express — err, req, res, next

4

Le pattern : controller throw, middleware catch

Séparation parfaite des responsabilités

5

Le wrapper asyncHandler

Express 4 ne catch pas les erreurs async — la solution

Le problème : les erreurs chaotiques

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é

⚠️ Le cauchemar : le serveur qui crashe

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 → 💥

});

Classes d'erreur personnalisées

Donner une structure à nos erreurs

Chaque erreur transporte un code HTTP

Le frontend sait exactement quoi faire

AppError — La classe de base

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

Sous-classes spécialisées

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

Hiérarchie des classes d'erreur

Error (natif JS)
AppError
NotFoundError
HTTP 404
ValidationError
HTTP 422
UnauthorizedError
HTTP 401

💡 Ajoutez autant de sous-classes que nécessaire : ForbiddenError, ConflictError, etc.

Middleware d'erreurs global

Un seul endroit pour tout catcher

Les 4 paramètres magiques :

err, req, res, next

Les 4 paramètres — Le secret d'Express

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 !

🔴 Règle d'or : enregistré en DERNIER

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 pattern

Le controller throw, le middleware catch

Controller

Lance l'erreur

Ne gère rien

Middleware

Attrape tout

Formate la réponse

Avant vs Après

❌ 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

Exemple complet d'une route

// 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.

Le problème des routes async

Express 4 ne catch PAS les erreurs des fonctions async

Une promesse rejetée non catchée

= Uncaught Promise → 💥 CRASH

asyncHandler — Le wrapper salvateur

// 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

asyncHandler en action

❌ 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

Architecture finale — Zéro crash

// 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.

Pièges courants

❌ 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

⚠️ Piège : Ne jamais exposer les bugs au client

❌ 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

Points clés à retenir

🎯 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

✅ À retenir !

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é

Questions ?

Ton serveur ne crashera plus jamais

Rappel : throw dans le controller, catch dans le middleware

Et toujours asyncHandler pour les routes async!