Wie funktioniert das Routing in NestJS?

Question

Accepted Answer

**Routing** in NestJS ist **dekorator-basiert**: Sie ordnen URL-Pfade und HTTP-Methoden mithilfe von Dekoratoren Controller-Methoden zu. Das Routing-Präfix kommt von `@Controller()` und der spezifische Pfad + HTTP-Verb von Methoden-Dekoratoren wie `@Get()` — kombiniert um die vollständige Route zu bilden.

## Wie Routen zusammengesetzt werden

```ts
@Controller("users")          // PREFIX: all routes start with /users
export class UsersController {
  @Get()                       // GET /users
  findAll() {}

@Get("active")               // GET /users/active
  findActive() {}

@Get(":id")                  // GET /users/:id (dynamic parameter)
  findOne(@Param("id") id: string) {}

@Post()                      // POST /users
  create(@Body() dto: CreateUserDto) {}

@Put(":id")                  // PUT /users/:id
  update(@Param("id") id: string, @Body() dto: UpdateUserDto) {}

@Delete(":id")               // DELETE /users/:id
  remove(@Param("id") id: string) {}
}
```

Controller-Präfix + Methoden-Dekorator-Pfad kombinieren sich: `@Get(":id")` innerhalb von `@Controller("users")` → `GET /users/:id`. Jedes HTTP-Verb hat seinen eigenen Dekorator (`@Get`, `@Post`, `@Put`, `@Patch`, `@Delete`).

## Route-Parameter und Query-Strings

```ts
@Get(":id")
example(
  @Param("id") id: string,        // path param: /users/123 → id = "123"
  @Query("sort") sort: string,    // query: /users?sort=name → sort = "name"
  @Query() allQuery: any,         // the whole query object
) {}
```

## Verschachtelte/Wildcard-Routen und Unterpfade

```ts
@Controller("users")
export class UsersController {
  @Get(":id/posts")              // GET /users/:id/posts (nested resource)
  getUserPosts(@Param("id") id: string) {}

@Get("search/*")               // wildcard matching
  search() {}
}
```

## Die Route-Reihenfolge ist wichtig

```ts
@Get("active")    // ✅ specific route FIRST
findActive() {}
@Get(":id")        // dynamic route AFTER — else "active" would match :id
findOne() {}
```

Spezifische (statische) Routen sollten vor dynamischen (`:param`) deklariert werden, sonst können sie von der dynamischen Route erfasst werden.

## Globales Präfix und Versionierung

```ts
app.setGlobalPrefix("api/v1");   // all routes become /api/v1/...
// NestJS also supports API versioning (URI, header, media-type based)
```

Ein globales Präfix (z. B. `/api/v1`) gilt für alle Routen — üblich für API-Konventionen.

## Warum es wichtig ist

Routing ist grundlegend — es definiert die URL-Struktur Ihrer API und ist die Art und Weise, wie jede Anfrage den richtigen Handler erreicht.

Das Verständnis von **dekorator-basiertem Routing in NestJS** (das `@Controller`-Präfix kombiniert mit Methoden-Dekoratoren wie `@Get`/`@Post`/etc. um vollständige Routen zu bilden und `@Param`/`@Query` zum Extrahieren von Daten) ist unverzichtbares Alltagswissen — es ist der Weg, wie Sie jeden Endpunkt erstellen, und der deklarative Stil hält das Routing sauber und lesbar im Vergleich zur manuellen Route-Registrierung.

Die praktischen Details kennen — das Kombinieren von Präfixen und Pfaden, das Verarbeiten von Route-Parametern und Query-Strings, verschachtelte Ressourcen-Routen, die Wichtigkeit der **Route-Reihenfolge** (statisch vor dynamisch) und globale Präfixe/Versionierung für API-Konventionen — ist notwendig, um gut strukturierte REST APIs in NestJS zu erstellen.

Routing, Controller und Parameter-Dekoratoren bilden zusammen die Grundlage der Request-Verarbeitung des Frameworks, was dies zu Kernmaterial macht, das jeder NestJS-Entwickler kennen muss.