NestJS Guards : Create Guard In NestJS In Hindi

If tutorials available on this website are helpful for you, please whitelist this website in your ad blocker😭 or Donate to help us ❤️ pay for the web hosting to keep the website running.

NestJS Guards एक powerful mechanism है जो आपको requests को control करने कि facility देते हैं। Guards primarily authorization के लिए use किये जाते हैं, जिसमे यह check किया जाता है कि request fulfill hone से पहले user authenticated है या नहीं।

यह middleware कि तरह request-response cycle में intervene करते हैं, लेकिन middleware के comparison में ज़्यादा specific और context-driven होते हैं।

What is Guard In NestJS

NestJS में Guards वो classes होती हैं जो CanActivate interface को implement करती हैं। Guards request को fulfill करने से पहले एक decision लेती हैं कि request allow कि जाये या नहीं।

यह decision mostly authorization के context में होता है, लेकिन आप guards का use custom logic के लिए भी कर सकते हैं, जैसे roles checking या permissions को verify करना।

Simpler terms में

• Guards decide करते हैं कि request allow कि जाएगी या नहीं।

• Mostly यह authorization या permissions check करने के लिए use होते हैं।

Need of Guards In NestJS

Guards का main role authorization और request filtering होता है। यह कुछ common use cases हैं जहाँ आप guards का use कर सकते हैं।

• Authorization : यह ensure करता है कि user request execute करने के लिए authorized है या नहीं।

• Role-based Access Control (RBAC) : Guard के through आप check कर सकते हैं कि user के पास correct role है या नहीं (e.g., admin, user).

• Permissions : यह verify करने के लिए use होता है कि user के पास specific resource के लिए required permissions हैं या नहीं।

• Custom Logic : Guards को custom scenarios के लिए भी use किया जा सकता है, जैसे IP whitelisting या certain request headers को check करना।

●●●

NestJS Guard Example

NestJS में guards को बनाने के लिए CanActivate interface को implement करना पड़ता है। इस interface में एक method canActivate() होता है, जो true (allow) या false (deny) return करता है।

Step 1 : Basic Guard

File : src/guards/auth.guard.ts

Copy
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Observable } from 'rxjs';

@Injectable()
export class AuthGuard implements CanActivate {
  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    const request = context.switchToHttp().getRequest();
    const user = request.user;

    // Simple check: Agar user present hai toh request allow karo
    return user ? true : false;
  }
}

Example में -

• canActivate() method : यह method request को process hone से पहले authorize करता है , अगर यह true return करता है तो request allow होती है, और अगर false return करता है तो reject हो जाती है।

• request.user : हमने यह check किया है कि user authenticated है या नहीं।

●●●

NestJS Create Custom Guard

चलिए एक custom guard बनाते हैं जो role-based authorization handle करेगा। इस guard में हम यह check करेंगे कि user के पास admin role है या नहीं।

Step 2 : Create RolesGuard

File : src/guards/roles.guard.ts

Copy
import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
import { Reflector } from '@nestjs/core';

@Injectable()
export class RolesGuard implements CanActivate {
  constructor(private reflector: Reflector) {}

  canActivate(context: ExecutionContext): boolean {
    const requiredRoles = this.reflector.get<string[]>('roles', context.getHandler());
    
    if (!requiredRoles) {
      return true;  // Agar role defined nahi hai, toh sabko allow kar do
    }

    const request = context.switchToHttp().getRequest();
    const user = request.user;

    // Check if user roles match required roles
    return requiredRoles.some(role => user.roles?.includes(role));
  }
}

Example में -

• Reflector : NestJS का Reflector use करते hue हम metadata (जैसे roles) को extract करते हैं।

• requiredRoles : यह roles extract करता है जो controller या route पर defined हैं।

• user.roles : User के roles को request object से access करके check किया गया है कि required roles present हैं या नहीं।

●●●

NestJS Apply Guards on Controller& Route

आप guards को Controller या specific route level पर apply कर सकते हैं , इसके लिए @UseGuards() decorator का use होता है।

Step 3 : Apply Guard on Route

File : src/user/user.controller.ts

Copy
import { Controller, Get, UseGuards } from '@nestjs/common';
import { AuthGuard } from '../guards/auth.guard';
import { RolesGuard } from '../guards/roles.guard';

@Controller('users')
export class UserController {
  @Get('profile')
  @UseGuards(AuthGuard)  // AuthGuard ko specific route pe apply kiya gaya hai
  getProfile() {
    return 'This is a protected route';
  }

  @Get('admin')
  @UseGuards(AuthGuard, RolesGuard)  // Multiple guards apply kiye gaye hain
  getAdminData() {
    return 'This is admin-only data';
  }
}

In above example -

• AuthGuard : getProfile() route को protect कर रहा है।

• RolesGuard : getAdminData() route को protect कर रहा है, जो सिर्फ admin role के users के लिए accessible है।

●●●

NestJS Register Global Guards

अगर आपको guard को globally हर route पर apply करना है, तो आप उससे main.ts file में register कर सकते हैं।

Step 4 : Register Global Guard

File : src/main.ts

Copy
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { AuthGuard } from './guards/auth.guard';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);

  // Global Guard registration
  app.useGlobalGuards(new AuthGuard());

  await app.listen(3000);
}
bootstrap();

यहां Global Guards हर incoming request पर apply होते हैं, और हर route के लिए same check perform करते हैं।

●●●

NestJS Guard Structure

अब हम एक complete example देखते हैं जिसमे guards को folder structure के साथ implement किया गया है।

Copy
src/
│
├── guards/
│   ├── auth.guard.ts        # Guard for basic authentication
│   ├── roles.guard.ts       # Guard for role-based authorization
│
├── user/
│   ├── user.controller.ts   # User controller with guards applied
│   ├── user.module.ts       # User module
│
├── app.module.ts            # Root module
├── main.ts                  # Global guards registration

●●●

NestJS Guards Best Practices

• Specific Guards for Specific Roles : हर role के लिए अलग guard बनाएं, ताकि आपका guard simple और maintainable रहे, जैसे AdminGuard, UserGuard, etc.

• Use Metadata for Role Checking : Role-based guards बनाते वक्त Reflector का use करें और controller/route पर role metadata set करें, ताकि logic reusable हो।

• Avoid Heavy Logic in Guards : Guard का main काम request को allow या deny करना है. Complex logic को services में shift करें।

• Apply Global Guards Cautiously : Global guards को wisely use करें , हर route के लिए अलग guard कि need हो सकती है।

• Error Handling : Guard में कोई validation या authorization fail hone पर, ForbiddenException या UnauthorizedException throw करें, ताकि proper HTTP error codes return हूँ।

Conclusion

NestJS Guards आपको request-level authorization और validation करने कि flexibility देते हैं। यह authorization, role-checking, और custom request validation को handle करते हैं।

Guards को सही तरीके से implement करके आप अपने application को ज़्यादा secure और maintainable बना सकते हैं।