NestJS లో routing ఎలా పనిచేస్తుంది?

Question

Accepted Answer

**Routing** NestJS లో **decorator-based**: మీరు URL paths మరియు HTTP methods లను decorator ల ఉపయోగించి controller methods కు మ్యాప్ చేస్తారు. route prefix `@Controller()` నుండి వస్తుంది మరియు నిర్దిష్ట path + HTTP verb `@Get()` వంటి method decorator ల నుండి — సమ్మిళితంగా పూర్ణ route ను ఏర్పరుస్తాయి.

## routes ఎలా రూపొందించబడతాయి

```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 prefix + method decorator యొక్క path సమ్మిళితం: `@Controller("users")` లో `@Get(":id")` → `GET /users/:id`. ప్రతి HTTP verb కు దాని స్వంత decorator ఉంది (`@Get`, `@Post`, `@Put`, `@Patch`, `@Delete`).

## Route parameters మరియు 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
) {}
```

## Nested/wildcard routes మరియు sub-paths

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

## Route ordering ముఖ్యమైనది

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

నిర్దిష్ట (static) routes డైనమిక్ (`:param`) ల కంటే ముందుగా ప్రకటించాలి, లేకపోతే డైనమిక్ route వాటిని క్యాప్చర్ చేయవచ్చు.

## Global prefix మరియు versioning

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

עולوमگ prefix (e.g. `/api/v1`) అన్ని routes కు వర్తిస్తుంది — API conventions కు సాధారణమైనది.

## ఎందుకు ఇది ముఖ్యమైనది

Routing ఆధారమైనది — ఇది మీ API యొక్క URL structure ను నిర్వచిస్తుంది మరియు ప్రతి request సరిగ్గా handler కు కసాబడుతుంది.

NestJS లో **decorator-based routing** ను అర్థం చేసుకోవడం (`@Controller` prefix సమ్మిళితంగా `@Get`/`@Post`/etc. method decorator ల తో పూర్ణ routes ను ఏర్పరుచు, మరియు `@Param`/`@Query` data ను సంగ్రహించుకోవడానికి) ఈ అవసరమైన రోజువారీ జ్ఞానం — ఇది ప్రతి endpoint ను ఎలా నిర్మించాలో, మరియు declarative style routing ను manual route registration కు పోల్చినప్పుడు స్వచ్ఛమైన మరియు చదవదగిన విధంగా ఉంచుతుంది.

ప్రాక్టికల్ వివరాలను తెలుసుకోవడం — prefixes మరియు paths సమ్మిళితం, route parameters మరియు query strings నిర్వహణ, nested resource routes, **route ordering** (static before dynamic) యొక్క ప్రాముఖ్యత మరియు API conventions కు global prefixes/versioning — NestJS లో well-structured REST APIs నిర్మాణానికి అవసరమైనది.

Routing, controllers మరియు parameter decorators సమ్మిళితంగా framework యొక్క request-handling foundation ను ఏర్పరుస్తాయి, ఇది ఏదైనా NestJS developer కు ఈ ప్రాథమిక, తప్పనిసరిగా-తెలుసుకోవాల్సిన విషయం చేస్తుంది.