REST API CRUD-dal

1A szerződés

Mielőtt egy sort is írnánk, rögzítjük, mit ígér az API. Ez a „szerződés”, amiről az 1. blokk 2. fejezetében volt szó.

Végponttérkép

A termék alakja

{ "id": 1, "nev": "Billentyűzet", "ar": 12990, "keszlet": 8, "categoryId": 3 }

A listavégpont query paraméterei

A válaszformátum

Lista — az adat mellé a lapozáshoz szükséges információ is kell:

{ "elemek": [ … ], "osszesTalalat": 3, "oldal": 1, "meret": 20 }

Hiba — mindig ugyanaz a szerkezet (5. és 8. fejezet):

{ "error": { "message": "Nincs ilyen termék.", "code": "TERMEK_NEM_TALALHATO" } }

2A projekt felállítása

mkdir webshop-api
cd webshop-api
npm init -y
npm install express

Egészítsd ki a package.json fájlt:

{
  "type": "module",
  "scripts": {
    "dev": "node --watch --env-file=.env index.js",
    "start": "node index.js"
  }
}

A mappaszerkezet a 7. fejezetből:

webshop-api/
  index.js
  src/
    app.js
    routes/termek.routes.js
    controllers/termek.controller.js
    services/termek.service.js
    middlewares/
      ervenyes-azonosito.js
      nem-talalhato.js
      hibakezelo.js
    utils/
      HttpHiba.js
      validalas.js
  keresek.http

3Az adatréteg

A service a memóriában tárolt tömböt kezeli. Nincs benne req, res, se státuszkód — ez a 7. fejezet szabálya.

// src/services/termek.service.js
let termekek = [
  { id: 1, nev: "Billentyűzet", ar: 12990, keszlet: 8,  categoryId: 3 },
  { id: 2, nev: "Egér",         ar: 4990,  keszlet: 25, categoryId: 3 },
  { id: 3, nev: "Monitor",      ar: 89990, keszlet: 0,  categoryId: 1 }
];
let kovetkezoId = 4;

export function osszes({ categoryId, q, oldal = 1, meret = 20 } = {}) {
  let talalatok = termekek;

  if (categoryId !== undefined) {
    talalatok = talalatok.filter(t => t.categoryId === categoryId);
  }
  if (q) {
    const kis = q.toLowerCase();
    talalatok = talalatok.filter(t => t.nev.toLowerCase().includes(kis));
  }

  const osszesTalalat = talalatok.length;      // a SZŰRT találatok száma — lapozás ELŐTT
  const kezdet = (oldal - 1) * meret;

  return { elemek: talalatok.slice(kezdet, kezdet + meret), osszesTalalat };
}

export function azonositoval(id) {
  return termekek.find(t => t.id === id) ?? null;
}

export function letrehoz(adat) {
  const termek = {
    id: kovetkezoId++,
    nev: adat.nev,
    ar: adat.ar,
    keszlet: adat.keszlet ?? 0,
    categoryId: adat.categoryId ?? null
  };
  termekek.push(termek);
  return termek;
}

export function felulir(id, adat) {
  const index = termekek.findIndex(t => t.id === id);
  if (index === -1) return null;

  termekek[index] = {                          // TELJES csere — a hiányzó mezők alapértékre állnak
    id,
    nev: adat.nev,
    ar: adat.ar,
    keszlet: adat.keszlet ?? 0,
    categoryId: adat.categoryId ?? null
  };
  return termekek[index];
}

export function modosit(id, valtozasok) {
  const termek = azonositoval(id);
  if (!termek) return null;

  Object.assign(termek, valtozasok);           // csak a megadott mezőket írja felül
  return termek;
}

export function torol(id) {
  const index = termekek.findIndex(t => t.id === id);
  if (index === -1) return false;

  termekek.splice(index, 1);
  return true;
}

4A validáció

A bejövő adatot egy helyen ellenőrizzük, és HttpHiba-t dobunk (8. fejezet):

// src/utils/validalas.js
import { HttpHiba } from "./HttpHiba.js";

export function termekAdatok(torzs, { reszleges = false } = {}) {
  if (typeof torzs !== "object" || torzs === null || Array.isArray(torzs)) {
    throw new HttpHiba(400, "A kérés törzse hiányzik vagy nem objektum.", "HIANYZO_TORZS");
  }

  const eredmeny = {};

  // nev — kötelező, kivéve részleges módosításnál
  if (torzs.nev !== undefined) {
    if (typeof torzs.nev !== "string" || torzs.nev.trim() === "") {
      throw new HttpHiba(400, "A név nem lehet üres.", "ERVENYTELEN_NEV");
    }
    eredmeny.nev = torzs.nev.trim();
  } else if (!reszleges) {
    throw new HttpHiba(400, "A név megadása kötelező.", "HIANYZO_MEZO");
  }

  // ar — kötelező, kivéve részleges módosításnál
  if (torzs.ar !== undefined) {
    if (typeof torzs.ar !== "number" || !Number.isFinite(torzs.ar) || torzs.ar < 0) {
      throw new HttpHiba(400, "Az ár csak nem negatív szám lehet.", "ERVENYTELEN_AR");
    }
    eredmeny.ar = torzs.ar;
  } else if (!reszleges) {
    throw new HttpHiba(400, "Az ár megadása kötelező.", "HIANYZO_MEZO");
  }

  // keszlet — mindig elhagyható
  if (torzs.keszlet !== undefined) {
    if (!Number.isInteger(torzs.keszlet) || torzs.keszlet < 0) {
      throw new HttpHiba(400, "A készlet csak nem negatív egész szám lehet.", "ERVENYTELEN_KESZLET");
    }
    eredmeny.keszlet = torzs.keszlet;
  }

  // categoryId — mindig elhagyható
  if (torzs.categoryId !== undefined) {
    if (!Number.isInteger(torzs.categoryId) || torzs.categoryId < 1) {
      throw new HttpHiba(400, "A kategória azonosítója csak pozitív egész szám lehet.", "ERVENYTELEN_KATEGORIA");
    }
    eredmeny.categoryId = torzs.categoryId;
  }

  if (reszleges && Object.keys(eredmeny).length === 0) {
    throw new HttpHiba(400, "Legalább egy módosítandó mezőt meg kell adni.", "NINCS_MODOSITAS");
  }

  return eredmeny;
}

Amit ez a függvény megold

5Az azonosító-ellenőrző middleware

A négy /:id végpont mindegyikének ugyanaz az első dolga. A 6. fejezetből tudjuk, hogy ez middleware-be való:

// src/middlewares/ervenyes-azonosito.js
import { HttpHiba } from "../utils/HttpHiba.js";

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

  if (!Number.isInteger(id) || id < 1) {
    return next(new HttpHiba(400, "Az azonosító csak pozitív egész szám lehet.", "ERVENYTELEN_ID"));
  }

  req.termekId = id;          // a már átalakított érték a vezérlőnek
  next();
}

Az eredmények:

GET /api/products/alma   →   400   {"error":{"message":"Az azonosító csak pozitív egész szám lehet.", …}}
GET /api/products/-3     →   400   ugyanaz
GET /api/products/1      →   200   a termék

A Number.isInteger egyszerre zárja ki a NaN, a tizedes tört és a -3 esetét — a Number("alma") ugyanis NaN, a Number.isInteger(NaN) pedig hamis.

6A vezérlő: hat függvény

// src/controllers/termek.controller.js
import * as szolgaltatas from "../services/termek.service.js";
import { termekAdatok } from "../utils/validalas.js";
import { HttpHiba } from "../utils/HttpHiba.js";

export function listaz(req, res) {
  const oldal = Number(req.query.page) || 1;
  const meret = Number(req.query.limit) || 20;
  const categoryId = req.query.categoryId ? Number(req.query.categoryId) : undefined;

  const { elemek, osszesTalalat } = szolgaltatas.osszes({ categoryId, q: req.query.q, oldal, meret });

  res.set("X-Total-Count", String(osszesTalalat));
  res.json({ elemek, osszesTalalat, oldal, meret });
}

export function egy(req, res) {
  const termek = szolgaltatas.azonositoval(req.termekId);
  if (!termek) throw new HttpHiba(404, "Nincs ilyen termék.", "TERMEK_NEM_TALALHATO");
  res.json(termek);
}

export function letrehoz(req, res) {
  const adat = termekAdatok(req.body);
  const termek = szolgaltatas.letrehoz(adat);
  res.location(`/api/products/${termek.id}`).status(201).json(termek);
}

export function felulir(req, res) {
  const adat = termekAdatok(req.body);                          // minden mező kötelező
  const termek = szolgaltatas.felulir(req.termekId, adat);
  if (!termek) throw new HttpHiba(404, "Nincs ilyen termék.", "TERMEK_NEM_TALALHATO");
  res.json(termek);
}

export function modosit(req, res) {
  const valtozasok = termekAdatok(req.body, { reszleges: true });   // csak amit küldtek
  const termek = szolgaltatas.modosit(req.termekId, valtozasok);
  if (!termek) throw new HttpHiba(404, "Nincs ilyen termék.", "TERMEK_NEM_TALALHATO");
  res.json(termek);
}

export function torol(req, res) {
  const sikerult = szolgaltatas.torol(req.termekId);
  if (!sikerult) throw new HttpHiba(404, "Nincs ilyen termék.", "TERMEK_NEM_TALALHATO");
  res.sendStatus(204);
}

Figyeld meg, milyen rövidek. Ez azért lehetséges, mert:

7PUT vs. PATCH

Ez a fejezet legfontosabb REST-fogalma, és a leggyakoribb félreértés.

8A router és az app.js

// src/routes/termek.routes.js
import express from "express";
import * as vezerlo from "../controllers/termek.controller.js";
import { ervenyesAzonosito } from "../middlewares/ervenyes-azonosito.js";

const router = express.Router();

router.get("/", vezerlo.listaz);
router.post("/", vezerlo.letrehoz);

router.get("/:id",    ervenyesAzonosito, vezerlo.egy);
router.put("/:id",    ervenyesAzonosito, vezerlo.felulir);
router.patch("/:id",  ervenyesAzonosito, vezerlo.modosit);
router.delete("/:id", ervenyesAzonosito, vezerlo.torol);

export default router;

.all()-lal:      OPTIONS /api/products/1   →   404
metódusonként:   OPTIONS /api/products/1   →   200, Allow: DELETE, GET, HEAD, PATCH, PUT

cors() nélkül:   OPTIONS /api/products/1   →   200, Allow: DELETE, GET, HEAD, PATCH, PUT
cors()-szal:     OPTIONS /api/products/1   →   204, Allow fejléc nélkül

// src/app.js
import express from "express";
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({ limit: "100kb" }));      // 1) törzs-feldolgozás
app.use("/api/products", termekRouter);         // 2) útvonalak
app.use(nemTalalhato);                          // 3) 404
app.use(hibakezelo);                            // 4) hibakezelő — legvégül

export default app;

A hibakezelő a törzs-feldolgozó hibáit is a saját formátumunkra fordítja (5. és 8. fejezet):

// src/middlewares/hibakezelo.js — az eleje
export function hibakezelo(err, req, res, next) {
  if (err.type === "entity.parse.failed") {
    return res.status(400).json({
      error: { message: "A kérés törzse nem érvényes JSON.", code: "ERVENYTELEN_JSON" }
    });
  }
  if (err.type === "entity.too.large") {
    return res.status(413).json({
      error: { message: "A kérés törzse túl nagy.", code: "TUL_NAGY_TORZS" }
    });
  }
  // …a 8. fejezet szerinti általános rész…
}

9Kipróbálás

A keresek.http fájl (REST Client, 1. blokk 5. fejezet):

@alap = http://localhost:3000

### Összes termék
GET {{alap}}/api/products

### Szűrés kategóriára
GET {{alap}}/api/products?categoryId=3

### Új termék
POST {{alap}}/api/products
Content-Type: application/json

{ "nev": "Webkamera", "ar": 19990, "categoryId": 2 }

### Részleges módosítás
PATCH {{alap}}/api/products/1
Content-Type: application/json

{ "ar": 22990 }

### Törlés
DELETE {{alap}}/api/products/2

Válassz egy kérést a gombokkal.

—

—

Eredmények — sikeres esetek

Eredmények — hibás esetek

10Amit így sem tudunk

Ez a lista nem hiányérzet, hanem a következő blokkok tartalomjegyzéke:

11Gyakori hibák

Az id-t a kliens küldi

const termek = { ...req.body };            // ❌ a kliens id-je is bekerül

Tünet: a kliens felülírhat egy létező terméket, vagy ütköző azonosítót hoz létre.
Megoldás: a validáló függvény csak az ismert mezőket adja vissza, az id-t a service adja.

A PATCH letörli a mezőket

export function modosit(req, res) {
  const adat = termekAdatok(req.body);      // ❌ hiányzik a { reszleges: true }
}

Tünet: a PATCH ugyanúgy megköveteli a nev és ar mezőt, mint a PUT.
Megoldás: a reszleges kapcsoló átadása.

A lapozás rossz számot ad vissza

const elemek = talalatok.slice(kezdet, kezdet + meret);
const osszesTalalat = elemek.length;        // ❌ az OLDAL mérete, nem az összes találat

Tünet: a kliens azt hiszi, csak egy oldalnyi találat van.
Megoldás: az osszesTalalat értékét a lapozás előtt, a szűrt listából vedd.

DELETE után is 200-at küldesz törzzsel

Tünet: a kliens megpróbálja értelmezni a választ, pedig nincs mit.
Megoldás: res.sendStatus(204).

OPTIONS kérésre 404

Ok: router.route("/:id").all(…) használata.
Megoldás: a middleware-t metódusonként add meg.

Ha 404 helyett 204-et kapsz Allow fejléc nélkül, az nem ez a hiba: akkor a cors() middleware válaszolt az előkérésre. Az a helyes viselkedés.

A szűrés nem talál semmit

talalatok.filter(t => t.categoryId === req.query.categoryId);   // ❌ "3" === 3 hamis

Megoldás: Number(req.query.categoryId) — a 4. fejezet buktatója.

12Feladatok

export function listaz(req, res) {
  const oldal = Number(req.query.page) || 1;
  const meret = Number(req.query.limit) || 20;
  const kezdet = (oldal - 1) * meret;
  const elemek = termekek.slice(kezdet, kezdet + meret);
  res.json({ elemek, osszesTalalat: elemek.length });
}

13Önellenőrző kvíz

14Összegzés

15Fogalomtár