Cum folosește NestJS decoratorii?

Question

Accepted Answer

NestJS este construit în jurul **decoratorilor TypeScript** — adnotări speciale cu prefixul `@` care atașează **metadate** claselor, metodelor și parametrilor. NestJS citește aceste metadate (prin reflexie) pentru a conecta în mod declarativ rutele, injectarea dependențelor, validarea și multe altele. Decoratorii sunt peste tot în Nest.

## Decoratori de clasă — definiți rolul unei clase

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

Decoratorii de clasă declară ce *este* o clasă în arhitectura NestJS (controller, provider, modul) și o configurează.

## Decoratori de metodă — mapați rutele și aplicați comportament

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

## Decoratori de parametru — extrageți datele cererii

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

Decoratorii de parametru extrag în mod declarativ exact datele de care aveți nevoie din cerere — fără analiza manuală a `req`.

## Decoratori de proprietate/validare (pe DTO-uri)

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

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

## De ce decoratori? Metadate declarative

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

## Decoratori personalizați

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

## De ce este important

Decoratorii sunt caracteristica sintactică definitorie a NestJS — întregul framework este organizat în jurul lor, deci înțelegerea modului în care funcționează este esențială pentru a citi și a scrie orice cod NestJS.

Ei oferă o abordare **declarativă** și condusă de metadate: în loc de configurare imperativă, adnotați clase, metode și parametri pentru a declara rutare (`@Controller`, `@Get`), injectare de dependență (`@Injectable`), comportament transversal (`@UseGuards`, `@UseInterceptors`) și validare (`@IsEmail`) exact acolo unde se aplică — concis și ușor de citit.

Acest mecanism de metadate prin reflexie (aceeași idee din spatele adnotărilor Angular și Java/Spring) este ceea ce permite stilul curat și structurat al NestJS.

Reconoașterea categoriilor (decoratori de clasă, metodă, parametru, proprietate), cunoașterea celor obișnuiți și capacitatea de a crea decoratori personalizați este cunoaștere fundamentală a NestJS — decoratorii sunt modul în care aproape toate funcțiile sunt exprimate, făcând-o una dintre primele și cele mai importante lucruri de înțeles în framework.