Guards ఒక రిక్వెస్ట్ను **రూట్ హ్యాండ్లర్కు సరిపోతుందో కాదో నిర్ణయించాయి — అవి authorizationకు NestJS యొక్క ప్రత్యేక మెకానిజం (మరియు తరచుగా authentication చెక్లను కూడా). ఒక guard రిక్వెస్ట్ను అనుమతించడానికి trueని లేదా అది నిరోధించడానికి false/throws ను రిటర్న్ చేస్తుంది.
()
{
(: ): {
request = context.().();
!!request..;
}
}
ఒక guard canActivate()ను ఇంప్లిమెంట్ చేస్తుంది, ఇది ఒక boolean (లేదా Promise/Observable) ను రిటర్న్ చేస్తుంది. falseని రిటర్న్ చేయడం 403తో రిక్వెస్ట్ను నిరోధిస్తుంది; మీరు ఒక నిర్దిష్ట exception (ఉదా UnauthorizedException) ను కూడా throw చేయవచ్చు.
@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() డెకోరేటర్ (metadata) తో ఒక 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 అనేది authorization కోసం ప్రత్యేక, idiomaticపైన NestJS మెకానిజం — authentication మరియు permissions ఆధారంగా హ్యాండ్లర్లకు రిక్వెస్ట్లను అనుమతించవలసిందానిని నియంత్రించడం.
వాటిని అర్థం చేసుకోవడం అవసరం ఎందుకంటే దాదాపు ప్రతిটి నిజమైన అ్యాప్లికేషన్ రూట్లను రక్షించాల్సిన అవసరం ఉంది (లాగిన్ అవసరం, roles/permissions చెక్ చేయండి), మరియు guards ఇందుకు సరైన సాధనం (auth లాజిక్ను middleware లో లేదా ప్రతిটి handler లో నింపడం కంటే చాలా క్లీనర్).
ప్రామాణిక నమూనాలు — JWT/auth guard ఇది credentials ని ధృవీకరిస్తుంది మరియు రిక్వెస్ట్కు user ని attach చేస్తుంది, మరియు role-based guards ఒక @Roles() డెకోరేటర్ను కలపడం RBAC కోసం Reflector-reading guard తో — NestJS APIs ని సురక్షితం చేయడానికి ప్రాథమికమైనవి.
Guards యొక్క సমృద్ధ ExecutionContext (లక్ష్య handler, class, మరియు request ను తెలుసుకోవడం) కు access ఖచ్చితంగా అవి authorization నిర్ణయాలకు సరిపోసినవి చేస్తుంది ఇవి middleware స్వచ్ఛంగా చేయలేవు.
Guards ని ఎలా రాయాలి, అన్వయించాలి (method/controller/global), మరియు మెటాడేటా డెకోరేటర్ల తో కలపాలి తెలుసుకోవడం సురక్షిత NestJS అ్యాప్లికేషన్ల నిర్మాణానికి కోర్ జ్ఞానం మరియు ఫ్రేమ్వర్క్లో ఎక్కువ సార్లు, architecturally-important విషయం.