Wat zijn controllers in NestJS?

Question

Accepted Answer

**Controllers** verwerken inkomende **HTTP-verzoeken** en retourneren antwoorden. Ze definiëren de routes van uw applicatie en fungeren als ingangspunt — verzoeken ontvangen, gegevens extracten, delegeren aan services en resultaten retourneren. Ze houden routingkwesties gescheiden van bedrijfslogica.

## Een controller definiëren

```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);
  }
}
```

## Hoe het werkt: decorators koppelen methoden aan routes

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

Decorators binden klasmethoden declaratief aan HTTP-routes — schoon en leesbaar, geen handmatige routeregistratie.

## Parameterdecorators extraheren aanvraaggegevens

```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)
) {}
```

Nest's parameterdecorators (`@Param`, `@Query`, `@Body`, `@Headers`) extraheren schoon precies de gegevens die u nodig hebt — geen handmatig parseren van `req`.

## Controllers moeten DUN zijn

```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
```

Beste praktijk: houd controllers **dun** — ze behandelen HTTP-kwesties (routing, gegevensextractie, antwoorden retourneren) en delegeren alle bedrijfslogica aan **services**. Deze scheiding houdt code testbaar en georganiseerd.

## Waarom het belangrijk is

Controllers zijn een fundamenteel NestJS-bouwsteen — het ingangspunt voor alle HTTP-verzoeken en waar de routes van uw API zijn gedefinieerd.

Begrijpen hoe decorators (`@Controller`, `@Get`/`@Post`, `@Param`/`@Body`/`@Query`) methoden aan routes koppelen en aanvraaggegevens declaratief extraheren, is essentiële dagelijkse NestJS-kennis — zo bouwt u elk eindpunt.

Evenals belangrijk is het principe van het houden van controllers **dun** (omgaan met alleen HTTP-kwesties en bedrijfslogica delegeren aan geïnjecteerde services), wat NestJS's scheiding van aandachten weerspiegelt en code onderhoudbaar en testbaar houdt.

Controllers vormen samen met services en modules de kernstructuur van elke NestJS-applicatie, waardoor het essentieel is om ze vanaf het begin te begrijpen.