Guards यह निर्धारित करते हैं कि क्या एक request रूट हैंडलर तक आगे बढ़ने की अनुमति है — ये NestJS का प्राधिकरण के लिए समर्पित तंत्र हैं (और अक्सर प्रमाणीकरण जांच)। एक guard request को अनुमति देने के लिए true या इसे अवरुद्ध करने के लिए false/exception फेंकता है।
@Injectable()
export class AuthGuard implements CanActivate {
canActivate(context: ExecutionContext): boolean {
const request = context.switchToHttp().getRequest();
return !!request.headers.authorization; // true = allow, false = block (403)
}
}
एक guard canActivate() को लागू करता है, जो एक boolean (या उसका Promise/Observable) लौटाता है। false लौटाने से request 403 के साथ अवरुद्ध हो जाती है; आप विशिष्ट exception भी फेंक सकते हैं (उदा. UnauthorizedException)।
@UseGuards(AuthGuard) // on a single route
@Get("profile")
getProfile() {}
@UseGuards(AuthGuard) // on a whole controller (all routes)
@Controller("admin")
export class AdminController {}
app.useGlobalGuards(new AuthGuard()); // globally (all routes)
Guards को method, controller, या global स्तर पर लागू किया जा सकता है।
@Injectable()
export class JwtAuthGuard implements CanActivate {
constructor(private jwtService: JwtService) {}
async canActivate(context: ExecutionContext): Promise<boolean> {
const request = context.switchToHttp().getRequest();
const token = request.headers.authorization?.split(" ")[1];
if (!token) throw new UnauthorizedException();
try {
request.user = await this.jwtService.verifyAsync(token); // attach the user
return true;
} catch {
throw new UnauthorizedException("Invalid token");
}
}
}
// a @Roles decorator stores required roles as metadata
@Roles("admin")
@Get("users")
listUsers() {}
// the RolesGuard reads the metadata and checks the user's roles
@Injectable()
export class RolesGuard implements CanActivate {
constructor(private reflector: Reflector) {}
canActivate(ctx: ExecutionContext): boolean {
const roles = this.reflector.get<string[]>("roles", ctx.getHandler());
const { user } = ctx.switchToHttp().getRequest();
return roles.some(role => user.roles?.includes(role)); // allow if the user has a required role
}
}
@Roles() decorator (मेटाडेटा) को एक guard के साथ जोड़ना जो इसे पढ़ता है (via Reflector) role-based access control के लिए मानक पैटर्न है।
The ExecutionContext gives guards rich info (the handler, class, request) — more
than plain middleware — which is why guards (not middleware) are the right place
for authorization decisions.
Guards प्राधिकरण के लिए NestJS का समर्पित, idiomatic तंत्र हैं — यह नियंत्रित करना कि कौन से requests प्रमाणीकरण और अनुमतियों के आधार पर handlers तक पहुंचने की अनुमति है।
इन्हें समझना आवश्यक है क्योंकि लगभग हर वास्तविक अनुप्रयोग को routes की सुरक्षा करनी पड़ती है (लॉगिन की आवश्यकता, roles/permissions की जांच करें), और guards इसके लिए सही उपकरण हैं (middleware या प्रत्येक handler में auth logic को ठूंसने की तुलना में बहुत स्वच्छ)।
मानक पैटर्न — एक JWT/auth guard जो credentials को सत्यापित करता है और request को user से जोड़ता है, और role-based guards @Roles() decorator को Reflector-reading guard के साथ RBAC के लिए जोड़ना — NestJS APIs को सुरक्षित करने के लिए मौलिक हैं।
Guards की समृद्ध ExecutionContext तक पहुंच (लक्ष्य handler, class, और request को जानना) ठीक यही है जो उन्हें प्राधिकरण निर्णयों के लिए उपयुक्त बनाता है जो middleware स्वच्छ रूप से नहीं कर सकते।
Guards को कैसे लिखें, लागू करें (method/controller/global), और मेटाडेटा decorators के साथ मिलाएं यह सुरक्षित NestJS applications बनाने का मुख्य ज्ञान है और framework में एक बार-बार आने वाला, architecturally-महत्वपूर्ण विषय है।