Hvordan bruker NestJS dekoratører?

Question

Accepted Answer

NestJS er bygget rundt **TypeScript-dekoratører** — spesielle `@`-prefikserte merknader som legger til **metadata** til klasser, metoder og parametere. NestJS leser denne metadataen (via refleksjon) for å konfigurere ruting, avhengighetsinjeksjon, validering og mer deklarativt. Dekoratører er overalt i Nest.

## Klassdekoratører — definer rollen til en klasse

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

Klassdekoratører deklarerer hva en klasse *er* i NestJS-arkitekturen (kontroller, leverandør, modul) og konfigurerer den.

## Metoddekoratører — kartlegg ruter og bruk oppførsel

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

## Parameterdekoratører — trekk ut forespørselsdata

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

Parameterdekoratører deklarerer nøyaktig hvilke data du trenger ut av forespørselen — ingen manuell `req`-parsing.

## Egenskaps-/valideringsdekoratører (på DTOer)

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

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

## Hvorfor dekoratører? Deklarativ 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.
```

## Egendefinerte dekoratører

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

## Hvorfor det spiller en rolle

Dekoratører er den definerende syntaktiske funksjonen til NestJS — hele rammeverket er organisert rundt dem, så det er viktig å forstå hvordan de fungerer for å lese og skrive NestJS-kode.

De gir en **deklarativ**, metadata-drevet tilnærming: i stedet for imperativ konfigurering merker du klasser, metoder og parametere for å deklarere ruting (`@Controller`, `@Get`), avhengighetsinjeksjon (`@Injectable`), kryssfunksjonell oppførsel (`@UseGuards`, `@UseInterceptors`) og validering (`@IsEmail`) akkurat der de gjelder — konsist og lesbar.

Denne metadata-via-refleksjon-mekanismen (samme idé bak Angular og Java/Spring-merknader) er det som gjør NestJS's rene, strukturerte stil mulig.

Å gjenkjenne kategoriene (klasse-, metode-, parameter-, egenskapsdekoratører), kjenne de vanlige og kunne lage egendefinerte dekoratører er grunnleggende NestJS-flyt — dekoratører er hvordan nesten alle funksjoner uttrykkes, noe som gjør dem til en av de første og viktigste tingene å forstå i rammeverket.