Guards हे निश्चित करते की विनंती route handler पर्यंत पोहोचण्याला परवानगी आहे की नाही — हे NestJS चे authorization साठी समर्पित यंत्रणा आहे (आणि अक्सर authentication तपासणी). एक guard विनंती परवानगी देण्यासाठी true परत करते किंवा तिला अवरोधित करण्यासाठी false/अपवाद फेकते.
@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 परत केल्यास विनंती 403 सह अवरोधित होते; आप विशिष्ट अपवाद (उदा. 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 (metadata) हे guard सह (जो Reflector द्वारे वाचते) एकत्रित करणे हे भूमिका-आधारित प्रवेश नियंत्रणसाठी मानक नमुना आहे.
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 हे authorization साठी NestJS चे समर्पित, idiiomatic यंत्रणा आहे — कोन विनंती handlers पर्यंत पोहोचण्याला authentication आणि permissions च्या आधारावर परवानगी आहे हे नियंत्रित करणे.
हे समजणे आवश्यक आहे कारण व्यावहारिकपणे प्रत्येक वास्तविक अनुप्रयोगाला routes संरक्षित करण्याची आवश्यकता आहे (login आवश्यक करा, roles/permissions तपासा), आणि guards हे योग्य साधन आहे (middleware मध्ये किंवा प्रत्येक handler मध्ये auth logic ठेवण्यापेक्षा बरेच स्वच्छ).
मानक नमुने — एक JWT/auth guard जो credentials सत्यापित करते आणि विनंतीला user जोडते, आणि भूमिका-आधारित guards जे @Roles() decorator हे Reflector-वाचणारे guard सह RBAC साठी एकत्रित करते — हे NestJS APIs संरक्षित करण्यासाठी मौलिक आहेत.
Guards चा समृद्ध ExecutionContext मध्ये प्रवेश (target handler, class, आणि request जाणून) हे अचूकपणे त्यांना authorization निर्णय साठी योग्य करते जे middleware स्वच्छपणे करू शकत नाही.
Guards कसे लिहायचे, लागू करायचे (method/controller/global), आणि metadata decorators सह एकत्रित करायचे हे ज्ञान सुरक्षित NestJS applications बांधण्यासाठी मूलभूत आहे आणि फ्रेमवर्क मध्ये वारंवार, वास्तुशिल्प-महत्वाचा विषय आहे.