Middleware

1Mi a middleware?

Az eddigi fejezetekben már használtunk middleware-t, csak nem neveztük néven:

• app.use(express.json()) — beolvassa a kérés törzsét (5. fejezet);
• a 4. fejezetben az app.delete("/api/products/:id", bejelentkezveKell, kezelo) első függvénye;
• és a 8. fejezetben jövő 404-kezelő is az lesz.

A middleware egy függvény, amely a kérés és a válasz között fut le. Három paramétert kap:

function naplozo(req, res, next) {
  console.log(`${req.method} ${req.originalUrl}`);
  next();                                  // ← továbbadjuk a következőnek
}

app.use(naplozo);

A next a lényeg. Enélkül a middleware nem különbözne egy sima kezelőfüggvénytől.

Kezelőfüggvény vagy middleware?

Igazából ugyanaz. Az egyetlen különbség a szándék:

Ezért írhattuk a 4. fejezetben, hogy az útvonalnak több függvénye is lehet: az első néhány middleware-ként viselkedik, az utolsó válaszol.

2A lánc

Az Express minden kérésnél sorban végigmegy a regisztrált függvényeken, felülről lefelé:

const app = express();

app.use(morgan("dev"));            // 1. naplóz, majd next()
app.use(express.json());           // 2. beolvassa a törzset, majd next()
app.use(hitelesites);              // 3. ellenőriz, majd next() vagy hibát ad

app.get("/api/products", kezelo);  // 4. VÁLASZOL — itt megáll a lánc

app.use(nemTalalhato);             // 5. csak akkor fut le, ha semmi nem válaszolt
app.use(hibakezelo);               // 6. csak hiba esetén fut le

A nyomvonal (egy naplózó middleware jegyezte fel a lépéseket):

GET /api/x   →   ["1 globális", "2 csak /api alatt", "3 útvonal-middleware", "4 kezelő"]
GET /nincs   →   ["1 globális", "404-kezelő"]

Figyeld meg a második sort: a /nincs kérésnél a globális middleware lefutott, csak nem talált végpontot, ezért a lánc végén álló 404-kezelőhöz jutott.

3Háromféle befejezés

Minden middleware pontosan egyféleképpen fejeződhet be. Ha egyiket sem teszi meg, a kérés örökre lóg.

1. next() — továbbadás

app.use((req, res, next) => {
  req.kertIdo = new Date();      // hozzáteszünk valamit a kéréshez
  next();                        // és megyünk tovább
});

2. Válasz — a lánc megáll

app.use((req, res, next) => {
  if (!req.get("Authorization")) {
    return res.status(401).json({ error: { message: "Bejelentkezés szükséges." } });
  }
  next();
});

Figyeld meg a return-t: enélkül a next() is lefutna a válasz után. Ugyanaz a szabály, mint az 5. fejezetben — egy kérésre egy válasz.

3. next(hiba) — ugrás a hibakezelőhöz

app.use((req, res, next) => {
  const id = Number(req.query.id);
  if (Number.isNaN(id)) {
    return next(new Error("Az azonosító nem szám."));
  }
  next();
});

Az eredmény: a next(new Error("kézzel dobott hiba")) hívás után a lánc átugorja az összes közbeeső middleware-t és útvonalat, és egyenesen a négyparaméteres hibakezelőhöz megy — onnan 500-as válasz születik.

Ha egyik sem történik meg

app.get("/lefagy", (req, res, next) => {
  console.log("ide eljutok");
  // nincs next(), nincs válasz
});

Kipróbálva: a kérés időtúllépésig lóg, és nincs hibaüzenet. A böngésző pörög, a terminál néma. Ez a middleware-ek leggyakoribb, legnehezebben megtalálható hibája.

4Hol fusson? Négyféle hatókör

// 1) GLOBÁLIS — minden kérésre
app.use(naplozo);

// 2) ELŐTAGHOZ KÖTÖTT — csak a /api alatt
app.use("/api", hitelesites);

// 3) ÚTVONAL-SZINTŰ — csak ezen az egy végponton
app.delete("/api/products/:id", adminKell, torloKezelo);

// 4) ROUTEREN BELÜLI — a router minden útvonalára
const router = express.Router();
router.use(termekLetezik);

Az előtag „lekopik” a req.url-ről

Ha előtaghoz kötött middleware-t vagy routert használsz, a middleware nem látja az előtagot:

app.use("/elotag", (req, res) => {
  res.json({ url: req.url, baseUrl: req.baseUrl, originalUrl: req.originalUrl });
});

Az eredmény a GET /elotag/melyebb/utvonal kérésre:

{ "url": "/melyebb/utvonal", "baseUrl": "/elotag", "originalUrl": "/elotag/melyebb/utvonal" }

Ez ugyanaz a viselkedés, amit a 4. fejezetben a routereknél láttunk — és pontosan ezért működik a router relatív útvonalakkal.

5Beépített middleware-ek

Az Express hármat hoz magával. Külön csomag egyikhez sem kell.

express.static()

app.use(express.static("public"));

Ettől a public/proba.txt fájl a GET /proba.txt címen érhető el (kipróbálva). Vedd észre: a mappa neve nem része az URL-nek.

Ha mégis kell előtag:

app.use("/statikus", express.static("public"));   // → GET /statikus/proba.txt

Beállítási lehetőségek

6Saját middleware írása

a) Naplózó

export function naplozo(req, res, next) {
  const kezdet = Date.now();

  res.on("finish", () => {                       // amikor a válasz elment
    const ido = Date.now() - kezdet;
    console.log(`${req.method} ${req.originalUrl} ${res.statusCode} — ${ido} ms`);
  });

  next();
}

A next() azonnal lefut, nem várja meg a finish eseményt. A naplósor később, a válasz után íródik ki.

b) A req kiegészítése

app.use((req, res, next) => {
  req.kertIdo = new Date().toISOString();
  next();
});

app.get("/api/idopont", (req, res) => {
  res.json({ mikor: req.kertIdo });          // működik
});

Ez a minta lesz a hitelesítés alapja a 4. blokkban: a token ellenőrzése után a middleware req.felhasznalo = { id: 5, szerep: "admin" } alakban teszi be a bejelentkezett felhasználót.

c) res.locals — adat a válaszhoz

app.use((req, res, next) => {
  res.locals.valaszIdo = new Date().toISOString();
  next();
});

A res.locals egy objektum, amely egyetlen kérés-válasz párhoz tartozik. Példa:

{ "kertIdo": "2026-08-29T12:00:00.000Z", "locals": { "felhasznalo": "teszt" } }

d) Ellenőrző middleware

export function ervenyesAzonosito(req, res, next) {
  const id = Number(req.params.id);

  if (!Number.isInteger(id) || id < 1) {
    return res.status(400).json({
      error: { message: "Az azonosító csak pozitív egész szám lehet.", code: "ERVENYTELEN_ID" }
    });
  }

  req.termekId = id;        // átadjuk a már átalakított értéket
  next();
}

router.get("/:id", ervenyesAzonosito, (req, res) => {
  const termek = termekek.find(t => t.id === req.termekId);   // már szám!
  // …
});

Ezzel a 4. fejezet buktatóját egyszer és mindenkorra megoldottuk: a kezelőfüggvényben már számot kapunk, és a hibás azonosító ide sem jut el.

7Hasznos külső middleware-ek

Mindhárom ingyenes, MIT-licencű npm-csomag, teljes funkcionalitással.

npm install morgan cors helmet

Ellenőrzött verziók: morgan 1.12.0, cors 2.8.6, helmet 8.3.0.

morgan — naplózás

import morgan from "morgan";

app.use(morgan("dev"));

Formátumok

cors — kérések másik forrásból

import cors from "cors";

app.use(cors());

Ez hozzáadja az Access-Control-Allow-Origin: * fejlécet, vagyis bármelyik weboldal hívhatja az API-dat.

Éles rendszerben ne hagyd "*"-on:

app.use(cors({ origin: "https://webshop.example.com" }));

helmet — biztonsági fejlécek

import helmet from "helmet";

app.use(helmet());

Egyetlen sorral tizenegy biztonsági fejlécet állít be. A lista (helmet 8.3.0):

A helyes sorrend

const app = express();

app.use(helmet());                  // 1. biztonsági fejlécek — mindenre
app.use(cors());                    // 2. CORS-fejlécek
app.use(morgan("dev"));             // 3. naplózás
app.use(express.json());            // 4. törzs-feldolgozás

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

app.use(nemTalalhato);              // 6. 404
app.use(hibakezelo);                // 7. hibakezelő — MINDIG a legvégén

8A hibakezelő middleware

Az Express egyetlen dolog alapján ismeri fel: négy paramétere van, és az első a hiba.

app.use((err, req, res, next) => {          // ← NÉGY paraméter!
  console.error(err);
  res.status(err.status || 500).json({
    error: { message: err.message, code: "SZERVERHIBA" }
  });
});

A helye: a lánc legvégén

Ez a fejezet második nagy buktatója. Kipróbálva mindkét sorrend:

app.use((err, q, s, n) => …);   // ❌
app.get("/hiba", () => { throw … });

500  <!DOCTYPE html> … <pre>Error: bumm  at …</pre>

app.get("/hiba", () => { throw … });
app.use((err, q, s, n) => …);   // ✅

500  {"hol":"helyes hibakezelo","uzenet":"bumm"}

Miért? Mert a hibakezelő is a láncban van. Ha az útvonalak előtt regisztrálod, a hiba később keletkezik, mint ahol ő áll — és a lánc nem megy visszafelé.

9Gyakori hibák

A kérés lóg, nincs hibaüzenet

app.use((req, res, next) => {
  console.log("naplózás");
  // ❌ elmaradt a next()
});

Tünet: minden kérés időtúllépésre fut, a terminál néma.
Megoldás: minden ágon next() vagy válaszküldés.

req.body az undefined — pedig ott az express.json()

app.post("/korai", kezelo);        // ❌ ez ELŐBB van
app.use(express.json());
app.post("/kesoi", kezelo);        // ✅ ez már látja a törzset

Az eredmény:

POST /korai  →  {"tipus":"undefined"}
POST /kesoi  →  {"body":{"a":1},"tipus":"object"}

Megoldás: az express.json() a fájl elejére, minden útvonal elé.

A hibakezelő HTML-t küld

Tünet: a hibaválasz HTML, nem a saját JSON-formátumod.
Ok: a hibakezelő az útvonalak előtt áll, vagy csak három paramétere van.
Megoldás: négy paraméter, és a lánc legvégére.

next() a válasz után

app.get("/utana", (req, res, next) => {
  res.json({ elso: true });
  next();                          // ❌
});

Kipróbálva: a kliens megkapja az első választ (200), de a lánc továbbmegy a 404-kezelőhöz, ami újra válaszolni próbál — a terminálban ERR_HTTP_HEADERS_SENT jelenik meg. A szerver fut tovább, tehát semmi nem hívja fel rá a figyelmedet.
Megoldás: return res.json(…).

Rossz helyen álló app.use("/api", …)

app.use("/api", hitelesites);
app.get("/api/products", kezelo);       // ✅ ide kell a hitelesítés
app.get("/allapot", kezelo);            // ✅ ide nem — jó, hogy kimarad

Ha az előtagot lehagyod, a /allapot végpont is bejelentkezést követelne — beleértve azt az állapot-ellenőrző végpontot, aminek épp bejelentkezés nélkül kell működnie.

next(valami) hibának minősül

next(termek);        // ❌ ebből hiba lesz, nem adatátadás!

Megoldás: adatot a req objektumon adj tovább (req.termek = termek; next();).

10Feladatok

app.use(naplozo);
app.use("/api", hitelesites);
app.get("/allapot", allapotKezelo);
app.get("/api/products", termekKezelo);
app.use(nemTalalhato);

const app = express();
app.post("/api/products", (req, res) => res.json(req.body));
app.use(express.json());
app.listen(3000);

app.use((req, res, next) => {
  if (req.get("Authorization")) {
    next();
  }
});

11Önellenőrző kvíz

12Összegzés

13Fogalomtár