NestJS లో controllers అంటే ఏమిటి?

Question

Accepted Answer

**Controllers** ఆ విధంగా ఇన్‌కమింగ్ **HTTP requests** ను నిర్వహించి responses ని రిటర్న్ చేస్తాయి. అవి మీ application యొక్క routes లను నిర్వచిస్తాయి మరియు entry point గా పనిచేస్తాయి — requests ను స్వీకరించి, డేటాను వెలికి తీసి, services కు డెలిగేట్ చేసి, ఫలితాలను రిటర్న్ చేస్తాయి. అవి routing concerns లను 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 కు బైండ్ చేస్తాయి — స్వచ్ఛమైనది మరియు చదవదగినది, manual route registration అవసరం లేదు.

## Parameter decorators request డేటాను వెలికి తీస్తాయి

```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`) స్వచ్ఛమైన విధంగా ఖచ్చితమైన డేటాను వెలికి తీస్తాయి — `req` యొక్క manual parsing అవసరం లేదు.

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

Best practice: controllers లను **thin** గా ఉంచండి — అవి HTTP concerns (routing, డేటాను వెలికి తీయడం, responses రిటర్న్ చేయడం) నిర్వహించి మరియు సమస్త business logic ను **services** కు డెలిగేట్ చేస్తాయి. ఈ separation కోడ్‌ను testable మరియు organized గా ఉంచుతుంది.

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

Controllers ఒక ఫండామెంటల్ NestJS building block — అన్ని HTTP requests కు entry point మరియు మీ API యొక్క routes నిర్వచించిన చోట.

Decorators (`@Controller`, `@Get`/`@Post`, `@Param`/`@Body`/`@Query`) ఎలా methods లను routes కు మ్యాప్ చేస్తాయి మరియు request డేటాను declaratively వెలికి తీస్తాయి అనేది అర్థం చేసుకోవడం—ఇది అవసరమైన రోజువారీ NestJS జ్ఞానం — ఇది మీరు ఏదైనా endpoint ను ఎలా నిర్మిస్తారో.

సమానంగా ముఖ్యమైనది controllers **thin** గా ఉంచే సూత్రం (HTTP concerns మాత్రమే నిర్వహించడం మరియు business logic ను injected services కు డెలిగేట్ చేయడం), ఇది NestJS యొక్క separation-of-concerns philosophy ను embodiment చేస్తుంది మరియు కోడ్‌ను maintainable మరియు testable గా ఉంచుతుంది.

Controllers, services మరియు modules లతో కలిసి, ప్రతి NestJS application యొక్క core structure ను ఏర్పరుస్తాయి, వాటిని ప్రారంభం నుండి గ్రహించటానికి అవసరమైనవిగా చేస్తుంది.