NestJS decorators का उपयोग कैसे करता है?

Question

Accepted Answer

NestJS **TypeScript decorators** के इर्द-गिर्द बना है — विशेष `@`-उपसर्ग वाले annotations जो classes, methods और parameters में **metadata** जोड़ते हैं। NestJS इस metadata को (reflection के माध्यम से) पढ़कर routing, dependency injection, validation आदि को declarative ढंग से जोड़ता है। NestJS में decorators हर जगह हैं।

## Class decorators — किसी class की भूमिका परिभाषित करते हैं

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

Class decorators यह घोषित करते हैं कि कोई class NestJS architecture में *क्या है* (controller, provider, module) और उसे configure करते हैं।

## Method decorators — routes map करते हैं और behavior लागू करते हैं

```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() {}
```

## Parameter decorators — request data निकालते हैं

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

Parameter decorators declarative ढंग से request से ठीक वही data खींच लेते हैं जिसकी आपको ज़रूरत होती है — बिना किसी मैनुअल `req` parsing के।

## Property/validation decorators (DTOs पर)

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

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

## Decorators क्यों? Declarative metadata

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

## Custom decorators

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

## यह क्यों महत्वपूर्ण है

Decorators NestJS की परिभाषित करने वाली वाक्यात्मक (syntactic) विशेषता हैं — पूरा framework उन्हीं के इर्द-गिर्द संगठित है, इसलिए वे कैसे काम करते हैं यह समझना किसी भी NestJS code को पढ़ने और लिखने के लिए आवश्यक है।

वे एक **declarative**, metadata-आधारित दृष्टिकोण प्रदान करते हैं: imperative configuration के बजाय, आप classes, methods और parameters को annotate करके routing (`@Controller`, `@Get`), dependency injection (`@Injectable`), क्रॉस-कटिंग behavior (`@UseGuards`, `@UseInterceptors`), और validation (`@IsEmail`) को ठीक वहीं घोषित करते हैं जहाँ वे लागू होते हैं — संक्षिप्त और पठनीय।

यह metadata-via-reflection तंत्र (वही विचार जो Angular और Java/Spring annotations के पीछे है) NestJS की स्वच्छ, संरचित शैली को संभव बनाता है।

श्रेणियों (class, method, parameter, property decorators) को पहचानना, आम decorators को जानना, और custom decorators बना पाना मौलिक NestJS दक्षता है — decorators ही वह तरीका हैं जिससे लगभग हर feature व्यक्त किया जाता है, जिससे वे framework में सबसे पहले और सबसे महत्वपूर्ण समझने योग्य चीज़ों में से एक बन जाते हैं।