NestJS ले decorators कसरी प्रयोग गर्छ?

Question

Accepted Answer

NestJS **TypeScript decorators** को वरपर निर्मित छ — विशेष `@`-उपसर्ग भएका annotations जो classes, methods, र parameters मा **metadata** संलग्न गर्छन्। NestJS ले यो metadata (reflection मार्फत) पढेर routing, dependency injection, validation, र अरु कुरा घोषणात्मक रूपमा जोडिन्छ। Decorators Nest मा सर्वत्र छन्।

## 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 आर्किटेक्चरमा *के हो* (controller, provider, module) र यसलाई कन्फिगर गर्छन्।

## Method decorators — routes म्याप गर्नुहोस् र व्यवहार लागू गर्नुहोस्

```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 घोषणात्मक रूपमा request बाट तपाईंलाई चाहिएको डेटा निकाल्छन् — कुनै म्यानुअल `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 कोड पढ्न र लेख्न आवश्यक छ।

तिनले **घोषणात्मक**, metadata-संचालित दृष्टिकोण प्रदान गर्छन्: imperative कन्फिगरेशनको सट्टा, तपाई classes, methods, र parameters मा annotation गरेर routing (`@Controller`, `@Get`), dependency injection (`@Injectable`), cross-cutting behavior (`@UseGuards`, `@UseInterceptors`), र validation (`@IsEmail`) घोषणा गर्नुहुन्छ जहाँ तिनले लागू हुन्छन् — संक्षिप्त र पठनीय।

यो metadata-via-reflection तन्त्र (Angular र Java/Spring annotations को पछाडिको विचार) NestJS को स्वच्छ, संरचित शैली सक्षम गर्छ।

श्रेणीहरू (class, method, parameter, property decorators) चिनिने, सामान्य सामग्रीहरू जान्ने, र custom decorators बनाउन सक्ने कुरा मौलिक NestJS धारणा हो — decorators लगभग सबै विशेषता व्यक्त गरिन्छन्, तिनलाई framework मा सर्वप्रथम र सबैभन्दा महत्त्वपूर्ण कुरा बनाइरहेछ।