Si e përdor NestJS dekoratorët?

Question

Accepted Answer

NestJS është ndërtuar rreth **dekoratorëve të TypeScript** — anotacione të veçanta me parashtesën `@` që bashkëngjiten **metapëlqimit** në klasa, metoda dhe parametra. NestJS lexon këtë metapëlqim (përmes refleksionit) për të lidhur rutimin, injektimin e varësisë, validimin dhe më shumë në mënyrë deklarative. Dekoratorët janë kudo në Nest.

## Dekoratorë klase — përcakto rolin e një klase

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

Dekoratorët e klasës deklarojnë se çfarë *është* një klasë në arkitekturën e NestJS (kontrollues, furnizues, modul) dhe e konfiguroni atë.

## Dekoratorë metode — hartëzo rrutat dhe zbato sjelljen

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

## Dekoratorë parametri — nxjerr të dhënat e kërkesës

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

Dekoratorët e parametrave nxjerrin në mënyrë deklarative saktësisht të dhënat që ju nevojiten nga kërkesa — pa analizimin manual të `req`.

## Dekoratorë pronësie/validimi (në DTO-të)

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

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

## Pse dekoratorë? Metapëlqim deklarativ

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

## Dekoratorë të personalizuar

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

## Pse ka rëndësi

Dekoratorët janë veçoria sintaksore përcaktuese e NestJS — i gjithë korniza është organizuar rreth tyre, kështu që të kuptuarit se si funksionojnë ato është thelbësor për leximin dhe shkrimin e çdo kodi NestJS.

Ata ofrojnë një qasje **deklarative**, të drejtuar nga metapëlqimi: në vend të konfigurimit imperativ, ju shënoni klasa, metoda dhe parametra për të deklaruar rutimin (`@Controller`, `@Get`), injektimin e varësisë (`@Injectable`), sjelljen ndërkryqore (`@UseGuards`, `@UseInterceptors`) dhe validimin (`@IsEmail`) pikërisht ku aplikohen — konciz dhe i lexueshëm.

Ky mekanizëm i metapëlqimit-përmes-refleksionit (e njëjta ide prapa anotacioneve të Angular dhe Java/Spring) është ajo që mundëson stilin e pastër dhe të strukturuar të NestJS.

Të njohur kategoritë (dekoratorë klase, metode, parametri, pronësie), njohja e atyre të zakonshme dhe aftësia për të krijuar dekoratorë të personalizuar është kurthje themelore e NestJS — dekoratorët janë mënyra se si shprehet pothuajse çdo veçori, duke i bërë ato një nga gjërat e para dhe më të rëndësishme për të kuptuar në kornizë.