Hibakezelés

1Mi számít hibának?

Nem minden hiba egyforma. A különbségtétel dönti el, mit csinálunk vele:

2A 404-kezelő

Ha egyetlen útvonal sem illeszkedik, a lánc végére ér a kérés. Ott várja a 404-kezelő:

// src/middlewares/nem-talalhato.js
export function nemTalalhato(req, res) {
  res.status(404).json({
    error: {
      message: `Nincs ilyen végpont: ${req.method} ${req.originalUrl}`,
      code: "NINCS_VEGPONT"
    }
  });
}

Az eredmény:

GET /nincs   →   404   {"error":{"message":"Nincs ilyen végpont: GET /nincs","code":"NINCS_VEGPONT"}}

A helye: minden útvonal után, a hibakezelő előtt

Ha nincs 404-kezelőd

Az Express beépítettje válaszol — HTML-lel:

404   text/html   <!DOCTYPE html> … <pre>Cannot GET /nincs</pre>

Egy JSON API-nál ez rossz: a kliens JSON.parse hibára fut, és nem tudja meg, mi történt.

3A központi hibakezelő

Négy paraméter, a lánc legvégén — a 6. fejezetből már ismerős:

// src/middlewares/hibakezelo.js
export function hibakezelo(err, req, res, next) {
  // 1) naplózás — mindig, mielőtt bármi mást tennénk
  console.error(`[HIBA] ${req.method} ${req.originalUrl}`, err);

  // 2) ha a válasz már elment, nincs mit tenni
  if (res.headersSent) {
    return next(err);
  }

  // 3) válasz a kliensnek
  const statusz = err.status ?? 500;

  res.status(statusz).json({
    error: {
      message: statusz < 500 ? err.message : "Váratlan szerverhiba történt.",
      code: statusz < 500 ? (err.code ?? "SZERVERHIBA") : "SZERVERHIBA"
    }
  });
}

Amit a hibakezelő elkap

Mind a négy módon érkező hiba ideér — az eredmények:

A harmadik sor az Express 5 újdonsága — a 4-esben ez a hiba elveszett volna.

4Saját hibaosztály

Ahhoz, hogy a hibakezelő tudja, milyen státuszkód és hibakód jár, a hibának magával kell hoznia ezt az információt:

// src/utils/HttpHiba.js
export class HttpHiba extends Error {
  constructor(status, message, code) {
    super(message);
    this.name = "HttpHiba";
    this.status = status;
    this.code = code;
  }
}

A throw előnye a return res.…-szel szemben

app.get("/api/products/:id", (req, res) => {
  const id = Number(req.params.id);

  if (Number.isNaN(id)) {
    return res.status(400).json({
      error: { message: "…", code: "…" }
    });
  }

  const termek = keres(id);
  if (!termek) {
    return res.status(404).json({
      error: { message: "…", code: "…" }
    });
  }

  res.json(termek);
});

app.get("/api/products/:id", (req, res) => {
  const id = Number(req.params.id);

  if (Number.isNaN(id)) {
    throw new HttpHiba(400,
      "Az azonosító csak szám lehet.", "ERVENYTELEN_ID");
  }

  const termek = keres(id);
  if (!termek) {
    throw new HttpHiba(404,
      "Nincs ilyen termék.", "TERMEK_NEM_TALALHATO");
  }

  res.json(termek);
});

Az eredmény:

GET /sajat   →   404   {"nev":"HttpHiba","uzenet":"Nincs ilyen termék.","kod":"TERMEK_NEM_TALALHATO"}

A webshop hibakódjai

Rögzítsük őket egy helyen, hogy a kliens is dokumentálva kapja:

5Aszinkron hibák — mit kap el az Express 5?

Ez a fejezet legfontosabb — és legtöbb meglepetést okozó — szakasza.

Amit elkap

app.get("/api/products", async (req, res) => {
  const termekek = await adatbazisbolLekerdez();   // ha ez elhasal…
  res.json(termekek);                              // …ide nem jut el
});

Az Express 5 az async függvény által visszaadott Promise elutasítását magától a hibakezelőhöz továbbítja. Kipróbálva: 500-as válasz születik a saját hibakezelőnkből.

Amit NEM kap el

Két eset, és mindkettő csendben okoz bajt. Az eredmények:

a) Vissza nem adott Promise

app.get("/promise", (req, res) => {
  Promise.reject(new Error("elkapatlan promise"));   // ❌ nincs await, nincs return
});

!! unhandledRejection: elkapatlan promise
GET /promise   →   IDŐTÚLLÉPÉS — a kérés lóg

A kérés soha nem kap választ, mert a kezelőfüggvény sem válaszolt, sem next()-et nem hívott. Az Express nem lát semmit: a Promise nem az ő kezében van.

b) Hiba egy időzített visszahívásban

app.get("/timeout", (req, res) => {
  setTimeout(() => {
    throw new Error("callbackben dobott hiba");     // ❌ senki nem kapja el
  }, 10);
  res.json({ elment: true });
});

GET /timeout   →   200   {"elment":true}
!! uncaughtException: callbackben dobott hiba

A válasz elment, a hiba viszont kiszökött a folyamatba. Kezeletlen uncaughtException esetén a Node alapból leállítja a programot.

Akkor kell-e try/catch?

Nem mindenhova. Két esetben igen:

// 1) Ha SAJÁT üzenetet vagy más státuszkódot akarsz
app.get("/api/products/:id", async (req, res) => {
  try {
    const termek = await szolgaltatas.termekAzonositoval(id);
    res.json(termek);
  } catch (hiba) {
    throw new HttpHiba(503, "Az adatbázis nem érhető el.", "ADATBAZIS_HIBA");
  }
});

// 2) Ha takarítani kell (fájl bezárása, tranzakció visszagörgetése)

Ha viszont csak annyit akarsz, hogy a hibából 500 legyen, hagyd el — az Express elintézi.

6A process-szintű hálók

A két „nem elkapott” esetre a Node ad utolsó védővonalat. Ez az index.js-be kerül:

// index.js
import app from "./src/app.js";
import { config } from "./src/config.js";

const szerver = app.listen(config.port, () => {
  console.log(`A szerver fut (${config.kornyezet}): http://localhost:${config.port}`);
});

process.on("unhandledRejection", (hiba) => {
  console.error("[VÉGZETES] Kezeletlen Promise-elutasítás:", hiba);
  szerver.close(() => process.exit(1));
});

process.on("uncaughtException", (hiba) => {
  console.error("[VÉGZETES] Kezeletlen kivétel:", hiba);
  szerver.close(() => process.exit(1));
});

7Fejlesztés vs. éles: mit mutatunk meg?

Az Express beépített hibakezelője már magától így viselkedik. Az eredmények ugyanarra a hibára:

A saját hibakezelőnknek is így kell tennie. A 7. fejezet config.js-e alapján:

import { config } from "../config.js";

export function hibakezelo(err, req, res, next) {
  console.error(`[HIBA] ${req.method} ${req.originalUrl}`, err);

  if (res.headersSent) return next(err);

  const statusz = err.status ?? 500;
  const fejlesztes = config.kornyezet !== "production";

  res.status(statusz).json({
    error: {
      message: statusz < 500 ? err.message : "Váratlan szerverhiba történt.",
      code: statusz < 500 ? (err.code ?? "SZERVERHIBA") : "SZERVERHIBA",
      ...(fejlesztes && statusz >= 500 ? { reszletek: err.message, stack: err.stack } : {})
    }
  });
}

8A teljes kép: hova kerül minden?

webshop-api/
  index.js                     ← app.listen + a process-szintű hálók
  src/
    app.js                     ← a lánc összeállítása
    config.js
    middlewares/
      nem-talalhato.js         ← 404
      hibakezelo.js            ← a központi hibakezelő
    utils/
      HttpHiba.js              ← a saját hibaosztály
    routes/  controllers/  services/

// src/app.js — a teljes lánc
import express from "express";
import path from "node:path";
import termekRouter from "./routes/termek.routes.js";
import { nemTalalhato } from "./middlewares/nem-talalhato.js";
import { hibakezelo } from "./middlewares/hibakezelo.js";

const app = express();

app.use(express.json());                                                // 1) törzs
app.use(express.static(path.join(import.meta.dirname, "..", "public")));  // 2) statikus

app.use("/api/products", termekRouter);                                // 3) útvonalak

app.use(nemTalalhato);                                                  // 4) 404
app.use(hibakezelo);                                                    // 5) hibakezelő

export default app;

Mit lát a kliens? — összefoglaló

Minden válasz ugyanabban a formátumban — ez az egész fejezet célja.

9Gyakori hibák

A hibakezelő soha nem fut le

app.use(hibakezelo);                      // ❌ az útvonalak ELŐTT
app.use("/api/products", termekRouter);

Tünet: a hibaválasz HTML, a saját JSON-formátumod helyett.
Megoldás: a hibakezelő a legvégére, a 404-kezelő után.

Három paraméter négy helyett

app.use((err, req, res) => { … });        // ❌ hiányzik a next

Tünet: ugyanaz — az Express közönséges middleware-nek nézi, és soha nem ad neki hibát.
Megoldás: mind a négy paraméter kiírása, akkor is, ha a next-et nem használod.

A 404-kezelő a hibakezelő UTÁN áll

app.use(hibakezelo);
app.use(nemTalalhato);                    // ❌

Tünet: a nem létező végpontokra a 404 megy ugyan, de a hibák is oda futnak be, mert a hibakezelő már lefutott előtte.
Megoldás: először nemTalalhato, aztán hibakezelo.

A kérés lóg, unhandledRejection a naplóban

app.get("/x", (req, res) => {
  szolgaltatas.valamiAszinkron();         // ❌ nincs await, nincs return
});

Megoldás: async kezelőfüggvény + await, vagy return a Promise elé.

ERR_HTTP_HEADERS_SENT a hibakezelőben

Ha a válasz már elment, mire a hiba keletkezett, a hibakezelő újabb hibát okozna.
Megoldás: a res.headersSent vizsgálata a kezelő elején.

Éles környezetben kiszivárog a veremkiírás

Tünet: a 500-as válaszban ott a fájlnév és a sor száma.
Megoldás: a NODE_ENV=production beállítása és a részletek elrejtése a hibakezelőben.

10Feladatok

a) app.get("/a", () => { throw new Error("x"); });
b) app.get("/b", async () => { throw new Error("x"); });
c) app.get("/c", (q, s) => { Promise.reject(new Error("x")); });
d) app.get("/d", (q, s) => { setTimeout(() => { throw new Error("x"); }, 10); });
e) app.get("/e", (q, s, n) => n(new Error("x")));

export function hibakezelo(err, req, res) {
  res.status(err.status || 500).json({ error: { message: err.message } });
}

11Önellenőrző kvíz

12Összegzés

13Fogalomtár