Middleware degli errori e tipi Result
Progetti un gestore centrale degli errori e un pattern Result tipizzato; racchiuda i gestori asincroni per inoltrare gli errori; restituisca envelope di errore coerenti.
Middleware degli errori e tipi Result è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 3 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 3 lezioni in totale.
Introduzione
Obiettivo: centralizzare gli errori a runtime e restituire un “involucro degli errori” JSON coerente. Creerà un tipo Result, un wrapper per gli handler asincroni e un solido middleware degli errori.
- Result<T,E> discriminato
- next(err) dagli handler asincroni
- Mappatura da Unknown a errore tipizzato
Tipo Result
Usi una unione discriminata per i risultati delle funzioni: { ok: true; value } oppure { ok: false; error }. Chi chiama la funzione deve gestire entrambi i rami.
// 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") }
}Involucro degli errori
Normalizzi unknown in un involucro piccolo e prevedibile. Eviti di esporre gli stack trace ai client.
// 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" } }
}Wrapper asincrono + middleware
Avvolga qualsiasi handler async in modo che i rifiuti chiamino next(err). Il middleware finale degli errori formatta il JSON una sola volta.
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)Route + integrazione
Combini validazione e gestione degli errori: la validazione restituisce 400 con i dettagli; gli altri rifiuti vengono intercettati dal middleware centralizzato.
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"))Suggerimenti
Suggerimenti:
- Registri i dettagli lato server; restituisca ai client messaggi minimi.
- Preferisca un Result tipizzato nei servizi e lo mappi a HTTP al confine dell'applicazione.
- Non ignori mai i rifiuti: chiami sempre
next(err).
Verifica degli errori asincroni
Verifica rapida: quale schema inoltra correttamente gli errori asincroni?
Riepilogo
Riepilogo: usi un'unione Result per la logica di dominio, avvolga gli handler asincroni in modo che chiamino next e formatti gli errori una sola volta in un middleware finale.
Domande Frequenti
La lezione «Middleware degli errori e tipi Result» è gratuita?
Sì — il testo completo di «Middleware degli errori e tipi Result» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 3 lezioni in totale.
Cosa imparerò in «Middleware degli errori e tipi Result»?
Progetti un gestore centrale degli errori e un pattern Result tipizzato; racchiuda i gestori asincroni per inoltrare gli errori; restituisca envelope di errore coerenti. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare TypeScript Academy?
Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 3.
Quanto tempo richiede la lezione «Middleware degli errori e tipi Result»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?
Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Tipizzazione dei gestori del router, Request/Response
- Validazione degli schemi con zod e inferenza in TS
- Middleware degli errori e tipi Result