NestJS-இல் controllers என்றால் என்ன?

Question

Accepted Answer

**Controllers** உள்வரும் **HTTP requests**-ஐ கையாண்டு responses-ஐ திருப்பி அனுப்புகின்றன. அவை உங்கள் applicationஇன் routes-ஐ வரையறுத்து, entry point ஆக செயல்படுகின்றன — requests-ஐ பெற்று, data-ஐ எடுத்து, services-க்கு delegate செய்து, முடிவுகளை திருப்பி அனுப்புகின்றன. அவை routing தொடர்பான விஷயங்களை business logic-இலிருந்து தனியாக வைத்திருக்கின்றன.

## ஒரு controller-ஐ வரையறுத்தல்

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

## இது எவ்வாறு செயல்படுகிறது: decorators methods-ஐ 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 class methods-ஐ HTTP routes-உடன் declarative முறையில் இணைக்கின்றன — சுத்தமாகவும் படிக்கக்கூடியதாகவும், manual route registration தேவையில்லை.

## Parameter decorators request data-ஐ எடுக்கின்றன

```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-இன் parameter decorators (`@Param`, `@Query`, `@Body`, `@Headers`) உங்களுக்கு தேவையான data-ஐ மட்டும் சுத்தமாக எடுக்கின்றன — `req`-ஐ manual ஆக parse செய்ய வேண்டியதில்லை.

## Controllers THIN ஆக இருக்க வேண்டும்

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

சிறந்த நடைமுறை: controllers-ஐ **thin** ஆக வைத்திருங்கள் — அவை HTTP தொடர்பான விஷயங்களை (routing, data எடுத்தல், responses திருப்பி அனுப்புதல்) கையாண்டு, அனைத்து business logic-ஐயும் **services**-க்கு delegate செய்கின்றன. இந்த பிரிப்பு code-ஐ testable ஆகவும் ஒழுங்காகவும் வைத்திருக்கிறது.

## இது ஏன் முக்கியம்

Controllers என்பது அடிப்படையான NestJS கட்டமைப்பு கூறு — அனைத்து HTTP requests-க்கான entry point மற்றும் உங்கள் API-இன் routes வரையறுக்கப்படும் இடம்.

Decorators (`@Controller`, `@Get`/`@Post`, `@Param`/`@Body`/`@Query`) எவ்வாறு methods-ஐ routes-உடன் இணைத்து request data-ஐ declarative முறையில் எடுக்கின்றன என்பதை புரிந்துகொள்வது அத்தியாவசியமான தினசரி NestJS அறிவு — இதுதான் நீங்கள் எந்த endpoint-ஐயும் கட்டமைக்கும் விதம்.

Controllers-ஐ **thin** ஆக வைத்திருக்கும் கொள்கையும் (HTTP தொடர்பான விஷயங்களை மட்டும் கையாண்டு, business logic-ஐ inject செய்யப்பட்ட services-க்கு delegate செய்தல்) சமமாக முக்கியமானது, இது NestJS-இன் separation-of-concerns தத்துவத்தை உள்ளடக்கி, code-ஐ maintainable ஆகவும் testable ஆகவும் வைத்திருக்கிறது.

Controllers, services மற்றும் modules-உடன் சேர்ந்து, ஒவ்வொரு NestJS application-இன் முக்கிய கட்டமைப்பை உருவாக்குகின்றன, அதனால் அவற்றை ஆரம்பத்திலிருந்தே புரிந்துகொள்வது அத்தியாவசியம்.