NestJS decorators कसे वापरतो?

Question

Accepted Answer

NestJS **TypeScript decorators** च्या सुर्दीवर बांधलेला आहे — विशेष `@`-प्रीफिक्स असलेली टिप्पण्या जी **metadata** क्लास, पद्धती आणि पॅरामीटर्सला संलग्न करतात. NestJS हा metadata (reflection द्वारे) वाचून routing, dependency injection, validation आणि आणखी काही घोषणात्मकपणे वायर करतो. Decorators Nest मध्ये सर्वत्र आहेत.

## क्लास decorators — क्लासची भूमिका परिभाषित करा

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

क्लास decorators घोषणा करतात की क्लास NestJS आर्किटेक्चर मध्ये *काय आहे* (नियंत्रक, प्रदाता, मॉड्यूल) आणि त्याला कॉन्फिगर करतात.

## पद्धती decorators — मार्ग मैप करा आणि वर्तन लागू करा

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

## पॅरामीटर decorators — विनंती डेटा काढा

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

पॅरामीटर decorators घोषणात्मकपणे विनंतीमधून तुम्हाला लागणारा डेटा काढतात — `req` ची कोणतीही मॅन्युअल पार्सिंग नाही.

## प्रॉपर्टी/validation decorators (DTOs वर)

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

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

## Decorators कशासाठी? घोषणात्मक 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.
```

## कस्टम 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 चा परिभाषित करणारा सिंटॅक्टिक वैशिष्ट्य आहे — संपूर्ण framework त्यांच्या सुर्दी आयोजित केली आहे, त्यामुळे ते कसे कार्य करतात हे समजणे NestJS कोड वाचण्यासाठी आणि लिहिण्यासाठी आवश्यक आहे.

ते **घोषणात्मक**, metadata-चालित दृष्टिकोन प्रदान करतात: अनिवार्य कॉन्फिगरेशनऐवजी, तुम्ही क्लास, पद्धती आणि पॅरामीटर्स टिप्पणी करा routing (`@Controller`, `@Get`), dependency injection (`@Injectable`), cross-cutting वर्तन (`@UseGuards`, `@UseInterceptors`) आणि validation (`@IsEmail`) घोषणा करण्यासाठी तर ते लागू होतात — संक्षिप्त आणि वाचनीय.

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

श्रेणी (क्लास, पद्धती, पॅरामीटर, प्रॉपर्टी decorators) ओळखणे, सामान्य लोकांला जाणणे आणि कस्टम decorators तयार करू शकणे हे मूलभूत NestJS प्रवाहिता आहे — decorators हा तरीका आहे की जवळजवळ प्रत्येक वैशिष्ट्य व्यक्त केली जाते, जे त्यांना framework मध्ये शिकण्यासाठी प्रथम आणि सर्वात महत्वाच्या गोष्टींपैकी एक बनवते.