Jak NestJS používá dekorátory?

Question

Accepted Answer

NestJS je postaven kolem **TypeScript dekorátorů** — speciálních poznámek s předponou `@`, které připojují **metadata** ke třídám, metodám a parametrům. NestJS čte tato metadata (prostřednictvím reflexe) a deklarativně propojuje routing, vkládání závislostí, validaci a další. Dekorátory jsou všude v Nest.

## Dekorátory tříd — definují roli třídy

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

Dekorátory tříd deklarují, co je třída *v* architektuře NestJS (kontrolér, poskytovatel, modul) a nakonfigurují ji.

## Dekorátory metod — mapují trasy a aplikují chování

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

## Dekorátory parametrů — extrahují data požadavku

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

Dekorátory parametrů deklarativně vytahují přesně ta data, která potřebujete z požadavku — bez ručního parsování `req`.

## Dekorátory vlastností/validace (na DTO)

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

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

## Proč dekorátory? Deklarativní metadata

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

## Vlastní dekorátory

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

## Proč to má значение

Dekorátory jsou definující syntaktickou vlastností NestJS — celý framework je kolem nich organizován, takže pochopení toho, jak fungují, je nezbytné pro čtení a psaní jakéhokoli kódu NestJS.

Nabízejí **deklarativní** přístup řízený metadaty: místo imperativní konfigurace si jako anotace berete třídy, metody a parametry, abyste deklarovali routing (`@Controller`, `@Get`), vkládání závislostí (`@Injectable`), chování přetínající se (`@UseGuards`, `@UseInterceptors`) a validaci (`@IsEmail`) přesně tam, kde se používají — stručné a čitelné.

Tato metadata-přes-reflexi mechanismus (stejná myšlenka za anotacemi Angular a Java/Spring) je to, co umožňuje čistý a strukturovaný styl NestJS.

Rozeznání kategorií (dekorátory tříd, metod, parametrů, vlastností), znalost běžných a schopnost vytvářet vlastní dekorátory je základní plynulostí NestJS — dekorátory jsou způsob, jakým se vyjadřuje prakticky každá funkce, což je činí jednou z prvních a nejdůležitějších věcí k pochopení v rámci.