NestJS hutumiaje decorators?

Question

Accepted Answer

NestJS imejengwa kuzunguka **TypeScript decorators** — annotations maalum zenye kiambishi `@` ambazo huambatanisha **metadata** na classes, methods, na parameters. NestJS husoma metadata hii (kupitia reflection) kuunganisha routing, dependency injection, validation, na zaidi kwa njia ya kutangaza. Decorators zipo kila mahali ndani ya Nest.

## Class decorators — hufafanua jukumu la class

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

Class decorators hutangaza class *ni nini* katika usanifu wa NestJS (controller, provider, module) na huiweka mipangilio.

## Method decorators — huunganisha routes na kutumia tabia

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

## Parameter decorators — hutoa data ya request

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

Parameter decorators hutoa hasa data unayohitaji kutoka kwa request kwa njia ya kutangaza — bila kuchanganua `req` kwa mkono.

## Property/validation decorators (kwenye DTOs)

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

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

## Kwa nini decorators? Metadata ya kutangaza

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

## Custom decorators

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

## Kwa nini ni muhimu

Decorators ni kipengele cha kisintaksia kinachoifafanua NestJS — framework nzima imepangwa kuzizunguka, hivyo kuelewa jinsi zinavyofanya kazi ni muhimu kwa kusoma na kuandika code yoyote ya NestJS.

Hutoa mbinu ya **kutangaza**, inayoendeshwa na metadata: badala ya mipangilio ya kimaagizo (imperative), unaongeza annotations kwenye classes, methods, na parameters kutangaza routing (`@Controller`, `@Get`), dependency injection (`@Injectable`), tabia za kupita pande mbalimbali (`@UseGuards`, `@UseInterceptors`), na validation (`@IsEmail`) hapo hapo zinapotumika — kwa ufupi na urahisi wa kusoma.

Utaratibu huu wa metadata-kupitia-reflection (wazo lile lile lililo nyuma ya Angular na annotations za Java/Spring) ndio unaowezesha mtindo safi na uliopangwa wa NestJS.

Kutambua makundi (class, method, parameter, property decorators), kujua zile zinazojulikana, na kuweza kuunda custom decorators ni ufasaha wa msingi wa NestJS — decorators ndiyo jinsi karibu kila feature inavyoonyeshwa, jambo linalozifanya kuwa mojawapo ya vitu vya kwanza na muhimu zaidi kuelewa katika framework hii.