NestJS decorators ਨੂੰ ਕਿਵੇਂ ਵਰਤਦਾ ਹੈ?

Question

Accepted Answer

NestJS **TypeScript decorators** ਦੇ ਆਸ-ਪਾਸ ਬਣਿਆ ਹੋਇਆ ਹੈ — ਵਿਸ਼ੇਸ਼ `@`-ਪਿਛਲੇ ਪਾਸੇ ਵਾਲੇ ਐਨੋਟੇਸ਼ਨ ਜੋ classes, methods, ਅਤੇ parameters ਵਿੱਚ **metadata** ਲੱਗਾਉਂਦੇ ਹਨ। NestJS ਇਸ metadata ਨੂੰ (reflection ਰਾਹੀਂ) ਪੜ੍ਹਦਾ ਹੈ ਤਾਂ ਜੋ routing, dependency injection, validation, ਅਤੇ ਹੋਰ ਚੀਜ਼ਾਂ ਨੂੰ declaratively ਤਰੀਕੇ ਨਾਲ ਤਿਆਰ ਕਰ ਸਕੇ। Decorators Nest ਵਿੱਚ ਸਰਵੱਤਰ ਹਨ।

## Class decorators — ਇੱਕ 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 ਘੋਸ਼ਣਾ ਕਰਦੇ ਹਨ ਕਿ ਇੱਕ class NestJS ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ *ਕੀ ਹੈ* (controller, provider, module) ਅਤੇ ਇਸਨੂੰ ਸੰਰਚਿਤ ਕਰਦੇ ਹਨ।

## Method decorators — routes ਨੂੰ map ਕਰੋ ਅਤੇ ਵਿਵਹਾਰ ਲਾਗੂ ਕਰੋ

```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 — request data ਨੂੰ ਬਾਹਰ ਕੱਢੋ

```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 declaratively ਬਿਲਕੁਲ ਉਹ ਡੇਟਾ ਨਿਕਾਲਦੇ ਹਨ ਜਿਸਦੀ ਤੁਹਾਨੂੰ request ਤੋਂ ਲੋੜ ਹੈ — ਕੋਈ ਵੀ ਹੱਥੀ `req` parsing ਨਹੀਂ।

## Property/validation decorators (DTOs 'ਤੇ)

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

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

## Decorators ਕਿਉਂ? Declarative 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.
```

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

## ਇਹ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ ਕਿਉਂ

Decorators NestJS ਦੀ ਪਰਿਭਾਸ਼ਿਤ syntactic ਵਿਸ਼ੇਸ਼ਤਾ ਹਨ — ਪੂਰੀ ਫਰੇਮਵਰਕ ਉਹਨਾਂ ਦੇ ਦੁਆਲੇ ਸੰਗਠਿਤ ਹੈ, ਇਸ ਲਈ ਇਹ ਸਮਝਣਾ ਕਿ ਉਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ ਕਿਸੇ ਵੀ NestJS ਕੋਡ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਉਹ ਇੱਕ **declarative**, metadata-ਸੰਚਾਲਿਤ ਪਹੁੰਚ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ: imperative ਸੰਰਚਨਾ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ classes, methods, ਅਤੇ parameters ਨੂੰ annotate ਕਰਦੇ ਹੋ ਤਾਂ ਜੋ routing (`@Controller`, `@Get`), dependency injection (`@Injectable`), cross-cutting ਵਿਵਹਾਰ (`@UseGuards`, `@UseInterceptors`), ਅਤੇ validation (`@IsEmail`) ਨੂੰ ਘੋਸ਼ਣਾ ਕਰ ਸਕੋ ਬਿਲਕੁਲ ਜਿੱਥੇ ਉਹ ਲਾਗੂ ਹੁੰਦੇ ਹਨ — ਸੰਖੇਪ ਅਤੇ ਪੜ੍ਹਨ ਯੋਗ।

ਇਹ metadata-via-reflection ਵਿਧੀ (Angular ਅਤੇ Java/Spring annotations ਦੇ ਪਿੱਛੇ ਵੀ ਇਹੀ ਵਿਚਾਰ) ਇਹੈ ਜੋ NestJS ਦੀ ਸਾਫ਼, ਢਾਂਚਾਬੱਧ ਸ਼ੈਲੀ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ।

ਸ਼੍ਰੇਣੀਆਂ (class, method, parameter, property decorators) ਨੂੰ ਪਛਾਣਨਾ, ਆਮ ਤੌਰ 'ਤੇ ਵਰਤੀਆਂ ਜਾਣਨਾ, ਅਤੇ custom decorators ਬਣਾਉਣ ਲਈ ਸਮਰੱਥ ਹੋਣਾ ਬੁਨਿਆਦੀ NestJS ਤਰਲਤਾ ਹੈ — decorators ਲਗਭਗ ਹਰ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਗਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਉਹਨਾਂ ਨੂੰ ਫਰੇਮਵਰਕ ਵਿੱਚ ਸਮਝਣ ਲਈ ਪਹਿਲੀਆਂ ਅਤੇ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਚੀਜ਼ਾਂ ਵਿੱਚੋਂ ਇੱਕ ਬਣਾਉਂਦਾ ਹੈ।