NestJS માં controllers શું છે?

Question

Accepted Answer

**Controllers** આવતા **HTTP requests** હેન્ડલ કરે છે અને જવાબો પરત કરે છે. તેઓ તમારી એપ્લિકેશનના routes વ્યાખ્યાયિત કરે છે અને પ્રવેશ બિંદુ તરીકે કાર્ય કરે છે — વિનંતીઓ પ્રાપ્ત કરીને, ડેટા નીકાસ કરીને, સેવાઓને સોંપીને અને પરિણામો પરત કરીને. તેઓ routing concerns ને business logic થી અલગ રાખે છે.

## શા માટે તે મહત્વપૂર્ણ છે

```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 પદ્ધતિઓને 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 અલંકૃત રીતે વર્ગ પદ્ધતિઓને HTTP routes સાથે બાંધે છે — સ્વચ્છ અને વાંચવા યોગ્ય, કોઈ મેનુઅલ route નિબંધન નહીં.

## પરિમાણ decorators વિનંતી ડેટા બહાર કાઢે છે

```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 ના પરિમાણ decorators (`@Param`, `@Query`, `@Body`, `@Headers`) સ્વચ્છતાથી બરાબર જે ડેટાની તમને જરૂર છે તે બહાર કાઢે છે — `req` ના કોઈ મેનુઅલ પાર્સિંગ નહીં.

## Controllers પાતળા હોવા જોઈએ

```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 **પાતળા** રાખો — તેઓ HTTP concerns (routing, ડેટા નીકાસ, પ્રતિક્રિયાઓ પરત કરવા) હેન્ડલ કરે છે અને બધું business logic **services** માં સોંપે છે. આ અલગતા કોડ કસોટીયોગ્ય અને સુવ્યવસ્થિત રાખે છે.

## શા માટે તે મહત્વપૂર્ણ છે

Controllers એક મૂળભૂત NestJS બિલ્ડિંગ બ્લોક છે — તમામ HTTP requests માટે પ્રવેશ બિંદુ અને જ્યાં તમારી API ના routes વ્યાખ્યાયિત થાય છે.

Cocorators કેવી રીતે काम કરે છે તે સમજવું (`@Controller`, `@Get`/`@Post`, `@Param`/`@Body`/`@Query`) પદ્ધતિઓને routes સાથે મ્યાપ કરે છે અને વિનંતી ડેટાને અલંકૃત રીતે બહાર કાઢે છે તે આવશ્યક દૈનિક NestJS જ્ઞાન છે — આ તમે કોઈપણ endpoint બનાવો છો તે રીતે.

સમાન રીતે મહત્વપૂર્ણ controllers **પાતળા** રાખવાનું સિદ્ધાંત છે (હાથ ધરવું માત્ર HTTP concerns અને business logic ને ઇન્જેક્ટ કરેલ services માં સોંપવું), જે NestJS ના separation-of-concerns તત્વશાસ્ત્ર કો મૂર્તિમાન કરે છે અને કોડ જાળવણીયોગ્ય અને કસોટીયોગ્ય રાખે છે.

Controllers, services અને modules સાથે મળીને, દરેક NestJS એપ્લિકેશનનું મૂળ માળખું રચે છે, જે તેમને શરૂઆત થી જ સમજવા આવશ્યક બનાવે છે.