Come funziona il routing in NestJS?

Question

Accepted Answer

**Routing** in NestJS è **basato su decoratori**: mappi percorsi URL e metodi HTTP a metodi controller usando decoratori. Il prefisso della rotta proviene da `@Controller()` e il percorso specifico + verbo HTTP dai decoratori di metodo come `@Get()` — combinati per formare la rotta completa.

## Come vengono composte le rotte

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

Il prefisso del controller + il percorso del decoratore di metodo si combinano: `@Get(":id")` dentro `@Controller("users")` → `GET /users/:id`. Ogni verbo HTTP ha il suo decoratore (`@Get`, `@Post`, `@Put`, `@Patch`, `@Delete`).

## Parametri di rotta e query string

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

## Rotte annidate/wildcard e sotto-percorsi

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

## L'ordine delle rotte è importante

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

Le rotte specifiche (statiche) dovrebbero essere dichiarate prima di quelle dinamiche (`:param`), altrimenti la rotta dinamica potrebbe catturarle.

## Prefisso globale e versionamento

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

Un prefisso globale (ad es. `/api/v1`) si applica a tutte le rotte — comune per le convenzioni API.

## Perché è importante

Il routing è fondamentale — definisce la struttura URL della tua API ed è come ogni richiesta raggiunge il gestore corretto.

Comprendere il **routing basato su decoratori** di NestJS (il prefisso `@Controller` combinato con decoratori di metodo `@Get`/`@Post`/ecc. per formare rotte complete, e `@Param`/`@Query` per estrarre dati) è conoscenza essenziale quotidiana — è come costruisci ogni endpoint, e lo stile dichiarativo mantiene il routing pulito e leggibile rispetto alla registrazione manuale delle rotte.

Conoscere i dettagli pratici — composizione di prefissi e percorsi, gestione dei parametri di rotta e query string, rotte di risorse annidate, l'importanza dell'**ordine delle rotte** (statico prima del dinamico), e prefissi globali/versionamento per le convenzioni API — è necessario per costruire API REST ben strutturate in NestJS.

Il routing, i controller e i decoratori di parametri insieme formano la base della gestione delle richieste del framework, rendendo questo materiale fondamentale e imprescindibile per qualsiasi sviluppatore NestJS.