Miten NestJS käyttää dekoraattoreita?

Question

Accepted Answer

NestJS on rakennettu **TypeScript-dekoraattoreiden** ympärille — erityisiä `@`-etuliitteellä varustettuja merkintöjä, jotka liittävät **metadataa** luokkiin, metodeihin ja parametreihin. NestJS lukee tämän metadatan (reflection-mekanismin kautta) yhdistääkseen reitityksen, riippuvuuksien injektoinnin, validoinnin ja paljon muuta deklaratiivisesti. Dekoraattorit ovat kaikkialla Nestissa.

## Luokkadekoraattorit — määrittelevät luokan roolin

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

Luokkadekoraattorit ilmoittavat mitä luokka *on* NestJS-arkkitehtuurissa (kontrollleri, palveluntarjoaja, moduuli) ja määrittävät sen.

## Metodidekoraattorit — kartoittavat reitit ja soveltavat käyttäytymistä

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

## Parametridekoraattorit — poistavat pyyntötietoja

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

Parametridekoraattorit poistavat deklaratiivisesti tarkalleen ne tiedot, jotka tarvitset pyynnöstä — ilman manuaalista `req`-jäsentämistä.

## Ominaisuus-/validointidekoraattorit (DTO:issa)

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

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

## Miksi dekoraattorit? Deklaratiivinen 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.
```

## Mukautetut dekoraattorit

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

## Miksi sillä on merkitystä

Dekoraattorit ovat NestJS:n määrittävä syntaktinen ominaisuus — koko kehys on järjestetty niiden ympärille, joten niiden toimintaperiaatteen ymmärtäminen on välttämätöntä minkä tahansa NestJS-koodin lukemiselle ja kirjoittamiselle.

Ne tarjoavat **deklaratiivisen**, metadatapohjaisen lähestymistavan: imperatiivisen konfiguraation sijaan merkitset luokkia, metodeja ja parametreja deklaroidaksesi reitityksen (`@Controller`, `@Get`), riippuvuuksien injektoinnin (`@Injectable`), poikkileikkaavan käyttäytymisen (`@UseGuards`, `@UseInterceptors`) ja validoinnin (`@IsEmail`) juuri siellä, missä niitä käytetään — ytimekkäästi ja helposti luettavasti.

Tämä metadatan-reflection-mekanismi (sama ajatus Angular- ja Java/Spring-merkintöjen takana) on se, joka mahdollistaa NestJS:n puhtaan, strukturoidun tyylin.

Kategorioiden tunnistaminen (luokka-, metodi-, parametri-, ominaisuusdekoraattorit), yleisten tunteminen ja mukautettujen dekoraattoreiden luomiskyky on perustavanlaatuinen NestJS-sujuvuus — dekoraattorit ovat tapa, jolla lähes jokainen ominaisuus ilmaistaan, mikä tekee niistä yhden ensimmäisistä ja tärkeimmistä asioista, jotka tulee ymmärtää kehyksessä.