TypeScript Academy · Leçon

Middleware d’erreurs et types Result

Concevez un gestionnaire central des erreurs et un motif Result typé ; enveloppez les gestionnaires asynchrones pour transmettre les erreurs ; renvoyez des enveloppes d’erreur cohérentes.

Middleware d’erreurs et types Result est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 3 leçons au total.

Introduction

Objectif : centraliser les erreurs d’exécution et renvoyer une « enveloppe d’erreur » JSON cohérente. Vous allez créer un type Résultat, une enveloppe de gestionnaire asynchrone et un intergiciel d’erreurs robuste.

Résultat<T,E> discriminé
next(err) depuis les gestionnaires asynchrones
Conversion d’une erreur inconnue en erreur typée

Type résultat

Utilisez une union discriminée pour les résultats des fonctions : { ok: true; value } ou { ok: false; error }. Les appelants doivent gérer les deux branches.

// Result pattern for services and controllers
export type Ok<T> = { ok: true; value: T }
export type Err<E> = { ok: false; error: E }
export type Result<T, E = string> = Ok<T> | Err<E>

export const ok = <T>(value: T): Ok<T> => ({ ok: true, value })
export const err = <E>(error: E): Err<E> => ({ ok: false, error })

// Example usage
async function getUserName(id: string): Promise<Result<string, "NOT_FOUND" | "DB">> {
  if (id === "missing") return err("NOT_FOUND")
  try { return ok("Ada") } catch { return err("DB") }
}

Enveloppe d’erreur

Normalisez unknown dans une enveloppe concise et prévisible. Évitez de divulguer les traces de pile aux clients.

// Canonical error envelope
export type ErrorEnvelope = {
  error: string
  code?: string
  details?: unknown
}

export function mapError(u: unknown): ErrorEnvelope {
  if (u instanceof Error) return { error: u.message }
  if (typeof u === "string") return { error: u }
  try { return { error: JSON.stringify(u) } } catch { return { error: "Unknown error" } }
}

Enveloppe asynchrone et intergiciel

Enveloppez tout gestionnaire asynchrone afin que les rejets appellent next(err). L’intergiciel d’erreurs final met le JSON en forme une seule fois.

import express, { Request, Response, NextFunction } from "express"

export const asyncHandler = <P, ResBody, ReqBody, Query>(fn: (req: Request<P, ResBody, ReqBody, Query>, res: Response<ResBody>, next: NextFunction) => Promise<unknown>) => {
  return (req: Request<P, ResBody, ReqBody, Query>, res: Response<ResBody>, next: NextFunction) => {
    Promise.resolve(fn(req, res, next)).catch(next)
  }
}

export function errorMiddleware(err: unknown, _req: Request, res: Response, _next: NextFunction) {
  const env = mapError(err)
  const status = env.code === "NOT_FOUND" ? 404 : 500
  res.status(status).json(env)
}

// Usage
// app.get("/", asyncHandler(async (req, res) => { throw new Error("boom") }))
// app.use(errorMiddleware)

Routes et intégration

Combinez validation et gestion des erreurs : la validation renvoie une réponse 400 avec des détails ; les autres rejets sont interceptés par l’intergiciel central.

import express from "express"
import { z } from "zod"
import { asyncHandler, errorMiddleware } from "./errors"

const createUserSchema = z.object({ name: z.string().min(1) })

const app = express()
app.use(express.json())

app.post("/users", asyncHandler(async (req, res) => {
  const parsed = createUserSchema.safeParse(req.body)
  if (!parsed.success) {
    res.status(400).json({ error: "Invalid body", details: parsed.error.format() })
    return
  }
  res.status(201).json({ id: "u_1", name: parsed.data.name })
}))

app.use(errorMiddleware)

app.listen(3000, () => console.log("http://localhost:3000"))

Conseils

Conseils :

Consignez les détails côté serveur ; renvoyez des messages minimaux côté client.
Privilégiez un résultat typé dans les services et convertissez-le en HTTP à la frontière de l’application.
N’absorbez jamais les rejets : appelez toujours next(err).

Vérification des erreurs asynchrones

Vérification rapide : quel modèle achemine correctement les erreurs asynchrones ?

Récapitulatif

Récapitulatif : utilisez une union de résultats pour la logique métier, enveloppez les gestionnaires asynchrones afin d’appeler next et mettez les erreurs en forme une seule fois dans un intergiciel final.

Questions Fréquemment Posées

La leçon « Middleware d’erreurs et types Result » est-elle gratuite ?

Oui — le texte complet de « Middleware d’erreurs et types Result » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Middleware d’erreurs et types Result » ?

Concevez un gestionnaire central des erreurs et un motif Result typé ; enveloppez les gestionnaires asynchrones pour transmettre les erreurs ; renvoyez des enveloppes d’erreur cohérentes. Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer TypeScript Academy ?

Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 3.

Combien de temps prend la leçon « Middleware d’erreurs et types Result » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?

Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Types des gestionnaires de route et de Request/Response
Validation de schémas avec zod et inférence vers TS
Middleware d’erreurs et types Result

← Retour à TypeScript Academy