Guards ஒரு request route handler-க்கு தொடர அனுமதிக்கப்படுகிறதா என்பதை தீர்மானிக்கின்றன — அவை authorization-க்கான NestJS-இன் dedicated mechanism (மற்றும் பெரும்பாலும் authentication checks). ஒரு guard request-ஐ அனுமதிக்க true-ஐ திருப்பி அனுப்புகிறது அல்லது அதை block செய்ய false/throws செய்கிறது.
@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()-ஐ implement செய்கிறது, இது ஒரு boolean-ஐ (அல்லது அதன் Promise/Observable) திருப்பி அனுப்புகிறது. false-ஐ திருப்பி அனுப்புவது request-ஐ 403-உடன் block செய்கிறது; நீங்கள் ஒரு குறிப்பிட்ட exception-ஐயும் throw செய்யலாம் (எ.கா. 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 level-இல் பயன்படுத்தலாம்.
@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 மூலம்) இணைப்பது role-based access control-க்கான standard pattern.
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-க்கான dedicated, idiomatic NestJS mechanism — authentication மற்றும் permissions-ஐ அடிப்படையாகக் கொண்டு எந்த requests handlers-ஐ அடைய அனுமதிக்கப்படுகின்றன என்பதை கட்டுப்படுத்துதல்.
அவற்றை புரிந்துகொள்வது அத்தியாவசியம், ஏனெனில் கிட்டத்தட்ட ஒவ்வொரு உண்மையான applicationக்கும் routes-ஐ பாதுகாக்க வேண்டும் (login தேவை, roles/permissions சரிபார்த்தல்), மற்றும் guards இதற்கு சரியான கருவி (auth logic-ஐ middleware-இல் அல்லது ஒவ்வொரு handler-இல் திணிப்பதை விட மிகவும் சுத்தமானது).
Standard patterns — credentials-ஐ verify செய்து user-ஐ request-உடன் இணைக்கும் ஒரு JWT/auth guard, மற்றும் role-based guards RBAC-க்காக ஒரு @Roles() decorator-ஐ Reflector-படிக்கும் guard-உடன் இணைப்பது — NestJS APIs-ஐ பாதுகாக்க அடிப்படை.
Guards-இன் rich ExecutionContext-க்கான அணுகல் (target handler, class, மற்றும் request-ஐ அறிதல்) தான் middleware சுத்தமாக செய்ய முடியாத authorization முடிவுகளுக்கு அவற்றை பொருத்தமாக்குகிறது.
Guards-ஐ எவ்வாறு எழுதுவது, பயன்படுத்துவது (method/controller/global), மற்றும் metadata decorators-உடன் இணைப்பது எவ்வாறு என்பதை அறிவது பாதுகாப்பான NestJS applications-ஐ உருவாக்க முக்கிய அறிவு மற்றும் framework-இல் அடிக்கடி வரும், architecturally முக்கியமான தலைப்பு.