NestJS డెకోరేటర్‌లను ఎలా ఉపయోగిస్తుంది?

Question

Accepted Answer

NestJS **TypeScript డెకోరేటర్‌ల** చుట్టూ నిర్మితమైనది — ప్రత్యేక `@`-ఉపసర্గ చేసిన వ్యాఖ్యలు, కుల్లాలు, పద్ధతులు మరియు పారామితులకు **మెటాడేటా** జోడిస్తాయి. NestJS ఈ మెటాడేటాను (reflection ద్వారా) చదువుకుని రూటింగ్, డిపెండెన్సీ ఇంజెక్షన్, ధృవీకరణ మరియు ఇతర విషయాలను డిక్లరేటివ్‌గా సంధానం చేస్తుంది. డెకోరేటర్‌లు Nestలో సర్వత్రా ఉన్నాయి.

## క్లాస్ డెకోరేటర్‌లు — క్లాస్‌ యొక్క పాత్రను నిర్వచించండి

```ts
@Controller("users")     // this class is a CONTROLLER, prefix /users
export class UsersController {}

@Injectable()            // this class is a PROVIDER (injectable)
export class UsersService {}

@Module({ ... })         // this class is a MODULE
export class UsersModule {}
```

క్లాస్ డెకోరేటర్‌లు NestJS ఆర్కిటెక్చర్‌లో క్లాస్ *ఎలా ఉంటుందో* ప్రకటించుకుంటాయి (కంట్రోలర్, ప్రోవైడర్, మాడ్యూల్) మరియు దానిని కాన్ఫిగర్ చేస్తాయి.

## పద్ధతి డెకోరేటర్‌లు — మార్గాలను మ్యాప్ చేయండి మరియు ప్రవర్తనను వర్తించండి

```ts
@Get()                   // GET request handler
@Post()                  // POST handler
@Get(":id")              // GET /users/:id
@HttpCode(204)           // set the response status code
@UseGuards(AuthGuard)    // apply a guard to this route
@UseInterceptors(LoggingInterceptor)
findAll() {}
```

## పారామితి డెకోరేటర్‌లు — అభ్యర్థన డేటాను సంగ్రహించండి

```ts
findOne(
  @Param("id") id: string,       // route parameter
  @Query("sort") sort: string,   // query string
  @Body() dto: CreateUserDto,    // request body
  @Headers("auth") auth: string, // header
) {}
```

పారామితి డెకోరేటర్‌లు డిక్లరేటివ్‌గా మీకు అవసరమైన ఖచ్చితమైన డేటాను అభ్యర్థన నుండి తీసుకుంటాయి — ఎటువంటి మానవ `req` విశ్లేషణ లేదు.

## ఆస్తి/ధృవీకరణ డెకోరేటర్‌లు (DTOలపై)

```ts
export class CreateUserDto {
  @IsEmail()                     // validation rules (class-validator)
  email: string;

@IsString()
  @MinLength(8)
  password: string;
}
```

## ఎందుకు డెకోరేటర్‌లు? డిక్లరేటివ్ మెటాడేటా

```text
Decorators attach METADATA that NestJS reads at runtime (via reflection) to:
  ✓ Register routes (@Get, @Controller)
  ✓ Wire dependency injection (@Injectable, @Inject)
  ✓ Apply guards/interceptors/pipes (@UseGuards, etc.)
  ✓ Validate input (@IsEmail, @IsString)
→ Behavior is declared WHERE it applies, concisely and readably.
```

## కస్టమ్ డెకోరేటర్‌లు

```ts
// you can create your own — e.g. extract the current user from the request
export const CurrentUser = createParamDecorator((data, ctx) =>
  ctx.switchToHttp().getRequest().user
);
// usage: findProfile(@CurrentUser() user: User) {}
```

## దీనికి ఎందుకు సంబంధం ఉంది

డెకోరేటర్‌లు NestJS యొక్క నిర్వచించే సింటాక్టిక్ ఫీచర్ — స온్నిహిత సంస్థ సంపూర్ణంగా వాటి చుట్టూ ఆయోజించబడింది, కాబట్టి వాటి ఎలా పనిచేస్తాయో అర్థం చేసుకోవడం ఏదైనా NestJS కోడ్‌ను చదువుకోవడానికి మరియు రాయడానికి ముఖ్యమైనది.

వాటి **డిక్లరేటివ్**, మెటాడేటా-నడిచిన విధానాన్ని అందిస్తాయి: బలవంతపు కాన్ఫిగరేషన్ కంటే, మీరు కుల్లాలు, పద్ధతులు మరియు పారామితులను రూటింగ్ (`@Controller`, `@Get`), డిపెండెన్సీ ఇంజెక్షన్ (`@Injectable`), క్రాస్‌-కటింగ్ ప్రవర్తన (`@UseGuards`, `@UseInterceptors`) మరియు ధృవీకరణ (`@IsEmail`) ఎక్కడ వర్తిస్తాయో తక్షణమే ప్రకటించండి — సంక్ష్ప్త మరియు చదవదగినది.

ఈ మెటాడేటా-ద్వారా-reflection విధానం (Angular మరియు Java/Spring శాసనల వెనుక ఇదే ఆలోచన) NestJS యొక్క శుభ్ర, నిర్మితమైన శైలిని సક్షమ చేస్తుంది.

వర్గీకరణలను గుర్తించుకోవడం (క్లాస్, పద్ధతి, పారామితి, ఆస్తి డెకోరేటర్‌లు), సాధారణ వాటిని తెలుసుకోవడం మరియు కస్టమ్ డెకోరేటర్‌లను సృష్టించగలగడం ప్రాథమిక NestJS సాఫల్యం — డెకోరేటర్‌లు దాదాపుగా ప్రతి ఫీచర్ ఎలా వ్యక్తీకరించబడుతుందో, సంస్థలో అవి సౌమ్యతరాలు మరియు చాలా ముఖ్యమైన అంశాలు.