NestJS இல் routing எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

**Routing** NestJS இல் **decorator-based**: நீங்கள் URL பாதைகள் மற்றும் HTTP முறைகளை decorator களைப் பயன்படுத்தி controller முறைகளுக்கு வரைபடமிடுகிறீர்கள். route prefix `@Controller()` இலிருந்து வருகிறது, குறிப்பிட்ட பாதை + HTTP verb `@Get()` போன்ற method decorator களிலிருந்து — சேர்ந்து முழு route ஐ உருவாக்குகின்றன.

## route கள் எவ்வாறு தொகுக்கப்படுகின்றன

```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 இன் பாதை சேர்க்கப்படுகிறது: `@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 ஐ dynamic (`:param`) ones க்கு முன்னால் declare செய்ய வேண்டும், இல்லையெனில் dynamic route அவற்றைக் கைப்பற்றலாம்.

## Global prefix மற்றும் versioning

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

ஒரு global 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 இல் நன்கு-structured REST APIs ஐ உருவாக்குவதற்கு அவசியம்.

Routing, controllers மற்றும் parameter decorators ஒன்றாக framework இன் request-handling foundation ஐ உருவாக்குகின்றன, இது ஏதேனும் NestJS developer க்கு அத்தியாவசிய, must-know பொருளாக ஆக்குகிறது.