Bun bietet mehrere Möglichkeiten, Fehler in HTTP-Servern zu behandeln.

Try-Catch in Routen

Verwenden Sie try-catch-Blöcke, um Fehler in Ihren Routen-Handlern zu behandeln:

Bun.serve({
  routes: {
    "/users/:id": async req => {
      try {
        const userId = req.params.id;
        const user = await db.getUser(userId);
        
        if (!user) {
          return new Response("Benutzer nicht gefunden", { status: 404 });
        }
        
        return Response.json(user);
      } catch (error) {
        console.error("Fehler beim Abrufen des Benutzers:", error);
        return new Response("Interner Serverfehler", { status: 500 });
      }
    },
  },
});

Globaler Error-Handler

Verwenden Sie die error-Option in Bun.serve(), um einen globalen Error-Handler zu definieren:

Bun.serve({
  routes: {
    "/": () => new Response("Hallo Welt"),
    "/error": () => {
      throw new Error("Etwas ist schiefgelaufen!");
    },
  },
  error(error) {
    console.error("Globaler Fehler:", error);
    return new Response("Interner Serverfehler", { 
      status: 500,
      headers: { "Content-Type": "text/plain" }
    });
  },
});

Custom Error Classes

Erstellen Sie benutzerdefinierte Fehlerklassen für spezifische Fehlerszenarien:

class NotFoundError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "NotFoundError";
  }
}

class ValidationError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "ValidationError";
  }
}

Bun.serve({
  routes: {
    "/users/:id": async req => {
      const userId = req.params.id;
      
      if (!userId) {
        throw new ValidationError("Benutzer-ID ist erforderlich");
      }
      
      const user = await db.getUser(userId);
      
      if (!user) {
        throw new NotFoundError("Benutzer nicht gefunden");
      }
      
      return Response.json(user);
    },
  },
  error(error) {
    if (error instanceof NotFoundError) {
      return new Response(error.message, { status: 404 });
    }
    
    if (error instanceof ValidationError) {
      return new Response(error.message, { status: 400 });
    }
    
    console.error("Unbekannter Fehler:", error);
    return new Response("Interner Serverfehler", { status: 500 });
  },
});

Async Error Handling

Bei asynchronen Routen können Fehler mit .catch() oder try-catch behandelt werden:

Bun.serve({
  routes: {
    "/data": async req => {
      return fetchData()
        .then(data => Response.json(data))
        .catch(error => {
          console.error("Fehler beim Abrufen der Daten:", error);
          return new Response("Daten konnten nicht abgerufen werden", { status: 500 });
        });
    },
  },
});

Error Middleware

Erstellen Sie Middleware-Funktionen zur zentralen Fehlerbehandlung:

function errorHandler(fn: Function) {
  return async (req: Request) => {
    try {
      return await fn(req);
    } catch (error) {
      console.error("Middleware-Fehler:", error);
      return new Response("Fehler aufgetreten", { status: 500 });
    }
  };
}

Bun.serve({
  routes: {
    "/protected": errorHandler(async req => {
      // Geschützte Route
      const data = await getProtectedData();
      return Response.json(data);
    }),
  },
});