Guards ਇਹ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਨ ਕਿ ਕੀ ਕੋਈ ਬੇਨਤੀ (request) ਰੂਟ ਹ੍ਭੰਡਲਰ ਤੱਕ ਅੱਗੇ ਵਧਣ ਦੀ ਆਗਿਆ ਹੈ — ਇਹ NestJS ਦਾ ਅਧਿਕਾਰ ਪ੍ਰਬੰਧਨ (authorization) ਲਈ ਸਮਰਪਿਤ ਵਿਧੀ ਹੈ (ਅਤੇ ਅਕਸਰ ਪ੍ਰਮਾਣੀਕਰਨ ਜਾਂਚਾਂ ਵੀ)। 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 ਨੂੰ ਵਿਧੀ, ਕੰਟਰੋਲਰ, ਜਾਂ ਗਲੋਬਲ ਪੱਧਰ ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
@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() ਡੈਕੋਰੇਟਰ (ਮੈਟਾਡੇਟਾ) ਨੂੰ ਇੱਕ 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 ਅਧਿਕਾਰ ਪ੍ਰਬੰਧਨ ਲਈ ਸਮਰਪਿਤ, ਪ੍ਰਵਾਹੀ NestJS ਵਿਧੀ ਹਨ — ਪ੍ਰਮਾਣੀਕਰਨ ਅਤੇ ਅਨੁਮਤੀਆਂ ਦੇ ਆਧਾਰ ਤੇ ਇਹ ਨਿਯੰਤ੍ਰਿਤ ਕਰਨਾ ਕਿ ਕਿਹੜੀਆਂ ਬੇਨਤੀਆਂ ਹ੍ਭੰਡਲਰਾਂ ਤੱਕ ਪਹੁੰਚਣ ਦੀ ਆਗਿਆ ਹੈ।
imਉਹਨਾਂ ਨੂੰ ਸਮਝਣਾ ਲਾਜ਼ਮੀ ਹੈ ਕਿਉਂਕਿ ਲਗਭਗ ਹਰ ਅਸਲ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਰੂਟਾਂ ਨੂੰ ਸੁਰੱਖਿਤ ਕਰਨਾ ਪੈਂਦਾ ਹੈ (ਲਾਗਇਨ ਦੀ ਲੋੜ, ਭੂਮਿਕਾਵਾਂ/ਅਨੁਮਤੀਆਂ ਦੀ ਜਾਂਚ ਕਰਨਾ), ਅਤੇ guards ਇਸ ਲਈ ਸਹੀ ਟੂਲ ਹਨ (middleware ਜਾਂ ਹਰ ਹ੍ਭੰਡਲਰ ਵਿੱਚ auth ਲਾਜ਼ਿਕ ਭਰਨ ਨਾਲੋਂ ਕਿਤੇ ਸਾਫ਼)।
ਮਾਨਕ ਪੈਟਰਨ — ਇੱਕ JWT/auth guard ਜੋ ਕਮਜ਼ੋਰੀਆਂ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਬੇਨਤੀ ਨਾਲ ਜੋੜਦਾ ਹੈ, ਅਤੇ ਭੂਮਿਕਾ-ਆਧਾਰਿਤ guards ਇੱਕ @Roles() ਡੈਕੋਰੇਟਰ ਨੂੰ Reflector-ਰੀਡਿੰਗ guard ਨਾਲ RBAC ਲਈ ਮਿਲਾਦੇ ਹੋਏ — NestJS APIs ਨੂੰ ਸੁਰੱਖਿਤ ਕਰਨ ਲਈ ਅਗਰਿਪ ਹਨ।
Guards ਦੀ ਅਮੀਰ ExecutionContext ਤੱਕ ਪਹੁੰਚ (ਪ੍ਰਮੁੱਖ ਹ੍ਭੰਡਲਰ, ਕਲਾਸ, ਅਤੇ ਬੇਨਤੀ ਨੂੰ ਜਾਣਦੇ ਹੋਏ) ਬਿਲਕੁਲ ਉਹ ਕਾਰਨ ਹੈ ਜੋ ਉਹਨਾਂ ਨੂੰ ਅਧਿਕਾਰ ਪ੍ਰਬੰਧਨ ਦੇ ਫੈਸਲਿਆਂ ਲਈ ਢੁਕਵਾਂ ਬਣਾਉਂਦਾ ਹੈ ਜੋ middleware ਸਾਫ਼-ਸੁਥਰਾ ਨਹੀਂ ਕਰ ਸਕਦਾ।
Gaurds ਨੂੰ ਲਿਖਣਾ, ਲਾਗੂ ਕਰਨਾ (ਵਿਧੀ/ਕੰਟਰੋਲਰ/ਗਲੋਬਲ), ਅਤੇ ਮੈਟਾਡੇਟਾ ਡੈਕੋਰੇਟਰਾਂ ਨਾਲ ਮਿਲਾਉਣਾ ਸੁਰੱਖਿਤ NestJS ਐਪਲੀਕੇਸ਼ਨਾਂ ਬਣਾਉਣ ਲਈ ਮੂਲ ਜਾਣਕਾਰੀ ਹੈ ਅਤੇ ਬਹੁ-ਵਾਰ, ਤਾਰੀਖ਼-ਮਹੱਤਵਪੂਰਨ ਫਰੇਮਵਰਕ ਵਿਸ਼ਾ ਹੈ।