NestJS ડેકોરેટર્સનો ઉપયોગ કેવી રીતે કરે છે?

Question

Accepted Answer

NestJS **TypeScript ડેકોરેટર્સ** ની આસપાસ બનેલું છે — વિશેષ `@`-પ્રીફિક્સ અર્થવ્યવસ્થા જે ક્લાસ, મેથડ અને પેરામીટર્સને **મેટાડેટા** જોડે છે। NestJS આ મેટાડેટા (રિફ્લેક્શન દ્વારા) વાંચે છે અને તેને રૂટિંગ, ડિપેન્ડન્સી ઇંજેક્શન, વેલિડેશન અને વધુ બધું ડિક્લેરેટિવલી વાયર અપ કરવા માટે વાપરે છે। ડેકોરેટર્સ 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`) બરાબર જ્યાં તેઓ લાગુ થાય છે — સંક્ષિપ્ત અને વાંચવામાં સરળ.

યો મેટાડેટા-વિયા-રિફ્લેક્શન મેકેનિઝમ (Angular અને Java/Spring એનોટેશનની પાછળ તે જ વિચાર) તે છે જે NestJS ની સ્વચ્છ, સંરચિત શૈલી સક્ષમ કરે છે.

વર્ગો ઓળખવા (ક્લાસ, મેથડ, પેરામીટર, પ્રોપર્ટી ડેકોરેટર્સ), સામાન્ય લોકોને જાણવા, અને કસ્ટમ ડેકોરેટર્સ બનાવવા માટે સક્ષમ હોવું એ મૂળભૂત NestJS પ્રવાહિતા છે — ડેકોરેટર્સ છે કેવી રીતે લગભગ દરેક વિશેષતા વ્યક્ત કરવામાં આવે છે, તેમને ફ્રેમવર્કમાં સમજવાની પહેલી અને સૌથી મહત્વપૂર્ણ વસ્તુઓ બનાવે છે.