Conas a úsáideann NestJS deoraithe?

Question

Accepted Answer

Tá NestJS tógtha timpeall ar **deoraithe TypeScript** — anótáisí speisialta atá réamhfhillte le `@` a ghabhann **meiteashonraí** le ranganna, modhanna, agus paraiméadair. Léann NestJS an meiteashonraí seo (trí léirsinn) chun ionracadh, instealladh an spleáchais, bailíochtú, agus níos mó a dhréachtú go deimhin. Tá deoraithe ann i ngach áit i Nest.

## Deoraithe ranganna — sainiú ról an ranga

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

Déanann deoraithe ranganna a dhearbhú cad is *ann* don rang san ailtireacht NestJS (rialtóir, soláthraí, modúl) agus a leagadh amach.

## Deoraithe modhanna — mapáil rothair agus iompar a chur i bhfeidhm

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

## Deoraithe paraiméadair — sonraí an iarratas a bhaint amach

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

Baineann deoraithe paraiméadair go deimhin na sonraí atá díreach uait amach as an iarratas — gan fhilleadh ar `req` a bhaint as láimh.

## Deoraithe maoine/bailíochtaithe (ar DTOanna)

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

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

## Cén fáth deoraithe? Meiteashonraí deimhin

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

## Deoraithe saincheaptha

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

## Cén fáth a bheidh tábhacht air

Is iad deoraithe an gné chomhréire sainaitheanta de NestJS — tá an crframework iomlán eagraithe timpeall orthu, mar sin tá tuiscint ar conas a oibríonn siad riachtanach chun aon chód NestJS a léamh agus a scríobh.

Tuigean siad cur chuige **deimhnitheach**, dírithe ar meiteashonraí: in ionad cumraíochta imréadach, anótaíonn tú ranganna, modhanna, agus paraiméadair chun ionracadh a dhearbhú (`@Controller`, `@Get`), instealladh an spleáchais (`@Injectable`), iompar trasghearrthach (`@UseGuards`, `@UseInterceptors`), agus bailíochtú (`@IsEmail`) díreach san áit ar fheidhmíonn siad — gonta agus inléite.

Is é an meicníocht meiteashonraí-trí-léirsinn seo (an smaoineamh céanna taobh thiar de anótáisí Angular agus Java/Spring) a dhéanann a bheith ábalta dó stíl gheal, struchtúrtha NestJS a thug faoi choinne a thógáil.

Is bunúsach é na catagóirí a aithint (deoraithe ranga, modhanna, paraiméadair, maoine), na cinn choitianta a bheith ar eolas agat, agus a bheith ábalta deoraithe saincheaptha a chruthú ar dhifríochta bhríomhar NestJS — is iad deoraithe an chaoi ar dhéantar beagnach gach gné a chur in iúl, rud a fhágann gur iad na rudaí is tosaigh agus is tábhachtaí a thuiscint sa chrframework.