Kif NestJS juża decorators?

Question

Accepted Answer

NestJS hija mibnija madwar **TypeScript decorators** — annotazzjonijiet speċjali b'prefiss `@` li jiffissaw **metadata** għal klassijiet, metodi, u parametri. NestJS taqra dan il-metadata (permezz ta' reflection) biex tgħaqqad routing, dependency injection, validazzjoni, u aktar b'mod deklarattiv. Decorators huma kullimkien f'Nest.

## Decorators tal-klassi — tiddefinixxi r-rwol ta' klassi

```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 tal-klassi jiddikjaraw x'*hija* klassi fl-arkitettura ta' NestJS (controller, provider, module) u jikkunfigurawha.

## Decorators tal-metodu — imappjar routes u applika komportament

```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 tal-parametru — estratt id-data tal-istħarriġ

```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 tal-parametru b'mod deklarattiv iġġibu preċiżament id-data li għandek bżonn mill-istħarriġ — l-ebda parsing manwali ta' `req`.

## Decorators tal-proprjetà/validazzjoni (fuq DTOs)

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

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

## Għalfejn decorators? Metadata deklarattiv

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

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

## Għalfejn dan importanti

Decorators hija l-feature sintattika li tiddefinixxi NestJS — il-framework sħiħ huwa organizzat madwarhom, allura fehim kif jaħdmu huwa essenzjali biex taqra u tikteb kwalunkwe kodiċi NestJS.

Huma jipprovdu approċċ **deklarattiv**, imossi mill-metadata: minflok ta' konfigurazzjoni imperattiva, inti tannotawwa klassijiet, metodi, u parametri biex tiddikjara routing (`@Controller`, `@Get`), dependency injection (`@Injectable`), komportament cross-cutting (`@UseGuards`, `@UseInterceptors`), u validazzjoni (`@IsEmail`) eżattament fejn jiġu applikati — konċiż u leggibli.

Dan il-mekanizmu ta' metadata-via-reflection (l-istess idea wara Angular u annotazzjonijiet Java/Spring) huwa dak li jippermetti l-istil ċlieku u strutturati ta' NestJS.

Irrikonoxxenza tal-kategoriji (decorators tal-klassi, metodu, parametru, proprjetà), għarfien ta' dawk komuni, u l-abbilità li ħollod decorators personalizzati hija flyentezza fundamentali ta' NestJS — decorators hija l-mod li bħala komunement kull feature hija espressa, u jagħmluhom waħda mill-ewwel u aktar importanti affarijiet biex tifhem fil-framework.