Guards यह निर्धारित करते हैं कि क्या एक request route handler को proceed करने की अनुमति दी जाएगी — ये NestJS का authorization के लिए समर्पित तंत्र हैं (और अक्सर authentication checks भी)। एक guard true return करता है request को permit करने के लिए या false/throws करता है इसे block करने के लिए।
@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 of one) return करता है। false return करने से request को 403 के साथ block किया जाता है; आप एक specific 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 पर apply किया जा सकता है।
@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 के साथ combine करना जो इसे read करता है (via 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 NestJS के लिए authorization के लिए समर्पित, idiomatic तंत्र हैं — यह नियंत्रित करते हैं कि कौन से requests handlers तक पहुँचने की अनुमति दी जाएगी authentication और permissions के आधार पर।
उन्हें समझना आवश्यक है क्योंकि लगभग हर real application को routes को protect करने की जरूरत होती है (login require करना, roles/permissions check करना), और guards इसके लिए सही tool हैं (middleware या each handler में auth logic को cramming करने से कहीं बेहतर)।
Standard patterns — एक JWT/auth guard जो credentials को verify करता है और user को request से attach करता है, और role-based guards जो @Roles() decorator के साथ Reflector-reading guard को combine करता है RBAC के लिए — NestJS APIs को secure करने के लिए fundamental हैं।
Guards की rich ExecutionContext (target handler, class, और request को जानना) की access बिल्कुल वही है जो उन्हें authorization decisions के लिए suitable बनाता है जो middleware cleanly नहीं कर सकते।
जानना कि कैसे guards को लिखना है, apply करना है (method/controller/global), और metadata decorators के साथ combine करना है यह secure NestJS applications को build करने के लिए core knowledge है और framework में एक frequent, architecturally-important topic है।