Hogyan használ dekorátorokat a NestJS?

Question

Accepted Answer

A NestJS a **TypeScript dekorátorokra** épül — speciális `@` előtaggal ellátott annotációkra, amelyek **metaadatokat** csatolnak osztályokhoz, metódusokhoz és paraméterekhez. A NestJS ezt a metaadatot (reflexión keresztül) olvassa be az útválasztás, függőségi injekció, validáció és egyéb deklaratív funkciók bekötéséhez. A dekorátorok mindenhol megtalálhatók a Nest-ben.

## Osztály dekorátorok — az osztály szerepének meghatározása

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

Az osztály dekorátorok deklarálják, hogy az osztály *mit reprezentál* a NestJS architektúrában (vezérlő, szolgáltató, modul) és konfigurálják azt.

## Metódus dekorátorok — útvonalak leképezése és viselkedés alkalmazása

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

## Paraméter dekorátorok — kérésadatok kinyerése

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

A paraméter dekorátorok deklaratívan nyernek ki pontosan azt az adatot a kérésből, amelyre szükségünk van — manuális `req` feldolgozás nélkül.

## Tulajdonság/validáció dekorátorok (DTO-kon)

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

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

## Miért dekorátorok? Deklaratív metaadatok

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

## Egyéni dekorátorok

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

## Miért fontos

A dekorátorok a NestJS meghatározó szintaktikai jellemzője — az egész keretrendszer körülöttük szerveződik, ezért elengedhetetlen azok működésének megértése a NestJS kód olvasásához és írásához.

Egy **deklaratív**, metaadatvezetésű megközelítést nyújtanak: az imperatív konfiguráció helyett osztályokat, metódusokat és paramétereket annotálsz az útválasztás deklarálásához (`@Controller`, `@Get`), függőségi injekció (`@Injectable`), keresztvágó viselkedés (`@UseGuards`, `@UseInterceptors`) és validáció (`@IsEmail`) céljából közvetlenül ott, ahol alkalmazandóak — tömör és olvasható.

Ez a metaadatok-reflexión alapuló mechanizmus (ugyanaz az elv, amely az Angular és a Java/Spring annotációk mögött áll) az, ami a NestJS tiszta, strukturált stílusát lehetővé teszi.

A kategóriák felismerése (osztály, metódus, paraméter, tulajdonság dekorátorok), a gyakori dekorátorok ismerete és az egyéni dekorátorok létrehozásának képessége alapvető NestJS tudás — a dekorátorok szinte minden funkció kifejezésének módja, ezért ezek az egyik legfontosabb dolog a keretrendszer megértéséhez.