Mik azok a controllerek a NestJS-ben?

Question

Accepted Answer

**Controllers** kezelik a bejövő **HTTP kéréseket** és válaszokat adnak vissza. Meghatározzák az alkalmazás útvonalait és belépési pontként működnek — fogadják a kéréseket, adatokat nyernek ki, delegálnak a szolgáltatásoknak, és eredményeket adnak vissza. Az útválasztási problémákat az üzleti logikától elkülönítik.

## Miért fontos

```ts
import { Controller, Get, Post, Body, Param } from "@nestjs/common";

@Controller("users")          // the route PREFIX → all routes start with /users
export class UsersController {
  constructor(private usersService: UsersService) {}   // inject a service via DI

@Get()                       // GET /users
  findAll() {
    return this.usersService.findAll();
  }

@Get(":id")                  // GET /users/:id
  findOne(@Param("id") id: string) {        // extract the route param
    return this.usersService.findOne(id);
  }

@Post()                      // POST /users
  create(@Body() dto: CreateUserDto) {       // extract the request body
    return this.usersService.create(dto);
  }
}
```

## Hogyan működik: a dekorátorok metódusokat képeznek leképezni útvonalakra

```text
@Controller("users") → route prefix /users
@Get() / @Post() / @Put() / @Patch() / @Delete() → HTTP method + sub-path
Combined: @Get(":id") inside @Controller("users") → GET /users/:id
```

A dekorátorok deklaratívan kötik össze az osztály metódusait a HTTP útvonalakkal — tiszta és olvasható, nincs manuális útvonal-regisztráció.

## Paraméter dekorátorok a kérelem adatait nyerik ki

```ts
@Get(":id")
example(
  @Param("id") id: string,        // route parameter (/users/:id)
  @Query("sort") sort: string,    // query string (?sort=name)
  @Body() body: CreateUserDto,    // request body
  @Headers("authorization") auth: string,  // a header
  @Req() req: Request,            // the raw request object (rarely needed)
) {}
```

A Nest paraméter dekorátorai (`@Param`, `@Query`, `@Body`, `@Headers`) tisztán kivonatják pontosan az adatokat, amelyekre szüksége van — nincs manuális `req` feldolgozás.

## A controllerek vékonyak legyenek

```ts
// ✅ controller delegates to a service — stays thin
@Post()
create(@Body() dto: CreateUserDto) {
  return this.usersService.create(dto);   // business logic lives in the SERVICE
}
// ❌ don't put database queries / business logic directly in the controller
```

A legjobb gyakorlat: tartsd a controllereket **vékonynak** — kezelik a HTTP-problémákat (útválasztás, adatok kinyerése, válaszok visszaadása) és az összes üzleti logikát delegálják a **szolgáltatásoknak**. Ez az elkülönítés kódot tesztelhetőnek és szervezettnek tartja.

## Miért fontos

A controllerek egy alapvető NestJS építőelem — belépési pont az összes HTTP-kéréshez és ahol az API-ja útvonalai meg vannak határozva.

Annak megértése, hogy a dekorátorok (`@Controller`, `@Get`/`@Post`, `@Param`/`@Body`/`@Query`) hogyan képezik le a metódusokat az útvonalakra és deklaratívan nyerik ki a kérelem adatait, napi NestJS-ismerek — ez az, ahogy bármely végpontot felépítesz.

Egyformán fontos a controllerek **vékonynak** tartásának elve (csak a HTTP-problémákat kezelni és az üzleti logikát az injektált szolgáltatásoknak delegálni), amely megtestesíti a NestJS gondok szétválasztásának filozófiáját és a kódot karbantarthatónak és tesztelhetőnek tartja.

A controllerek, a szolgáltatások és modulok mellett, minden NestJS-alkalmazás alapvető szerkezetét képezik, amely nélkülözhetetlenné teszi őket az elejétől kezdve.