Hur använder NestJS dekoratörer?

Question

Accepted Answer

NestJS är byggt runt **TypeScript-dekoratörer** — särskilda `@`-prefixade anteckningar som fäster **metadata** till klasser, metoder och parametrar. NestJS läser denna metadata (via reflection) för att deklarativt koppla upp routing, beroendeinjektion, validering och mer. Dekoratörer finns överallt i Nest.

## Klassdekoratörer — definierar klassens roll

```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 deklarerar vad en klass *är* i NestJS-arkitekturen (kontroller, provider, modul) och konfigurerar den.

## Metoddekoratörer — mappar rutter och tillämpar beteende

```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 — extraherar begärandata

```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 extraherar deklarativt exakt den data du behöver ur begäran — ingen manuell `req`-parsing.

## Egenskap/valideringsdekoratörer (på DTO:er)

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

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

## Varför 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.
```

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

## Varför det är viktigt

Dekoratörer är den definierade syntaktiska egenskapen för NestJS — hela ramverket är organiserat runt dem, så att förstå hur de fungerar är väsentligt för att läsa och skriva någon NestJS-kod.

De ger ett **deklarativt**, metadatadrivet tillvagagångssätt: istället för imperativ konfiguration, annoterar du klasser, metoder och parametrar för att deklarera routing (`@Controller`, `@Get`), beroendeinjektion (`@Injectable`), tvärsnittsverkande beteende (`@UseGuards`, `@UseInterceptors`) och validering (`@IsEmail`) direkt där de tillämpas — koncist och läsbart.

Denna metadata-via-reflection-mekanism (samma idé bakom Angular och Java/Spring-anteckningar) är vad som möjliggör NestJS:s rent, strukturerade stil.

Att känna igen kategorierna (klass-, metod-, parameter-, egenskapsdekoratörer), känna till de vanliga och kunna skapa anpassade dekoratörer är grundläggande NestJS-flyt — dekoratörer är hur nästan alla funktioner uttrycks, vilket gör dem till en av de första och viktigaste sakerna att förstå i ramverket.