Guardat përcaktojnë nëse një kërkesë lejohet të vazhdojë në rutën e trajtuesit — ato janë mekanizmi i dedikuar i NestJS për autorizimin (dhe shpesh kontrollat e autentifikimit). Një guard kthen true për të lejuar kërkesën ose false/hedh për ta bllokuar atë.
@Injectable()
export class AuthGuard implements CanActivate {
canActivate(context: ExecutionContext): boolean {
const request = context.switchToHttp().getRequest();
return !!request.headers.authorization; // true = allow, false = block (403)
}
}
Një guard implementon canActivate(), e cila kthen një boolean (ose Promise/Observable të tij). Kthimi i false bllokon kërkesën me një 403; mund të hedhni edhe një përjashtim specifik (p.sh. 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)
Guardat mund të zbatohen në nivelin e metodës, kontrollerit ose 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
}
}
Kombinimi i një dekoratori @Roles() (metadata) me një guard që e lexon atë (përmes Reflector) është modeli standard për kontrollin e aksesit të bazuar në rol.
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.
Guardat janë mekanizmi i dedikuar, idiomatik i NestJS për autorizimin — kontrollin se cilat kërkesa lejohen të arrijnë trajtuesit bazuar në autentifikimin dhe përmisat.
Kuptimi i tyre është thelbësor sepse praktikisht çdo aplikacion i vërtetë duhet të mbrojë rutët (kërkojnë hyrje, kontrollojnë rolet/përmisat), dhe guardat janë mjeti i saktë për këtë (shumë më i pastër sesa t'i fusin logjikën e autentifikimit në middleware ose secilin trajtues).
Modeliet standard — një guard JWT/autentifikimi që verifikon kredencialet dhe bashkëngjit përdoruesin në kërkesë, dhe guardat e bazuar në rol që kombinojnë një dekorator @Roles() me një guard që lexon Reflector për RBAC — janë themelore për sigurimin e API-ve NestJS.
Qasja e guardave në ExecutionContext të pasur (duke ditur trajtuesin e synuar, klasën dhe kërkesën) është saktësisht ajo që i bën ata të përshtatshëm për vendime autorizimi që middleware nuk mund t'i bëjë pastër.
Dija se si të shkruani, zbatoni (metoda/kontrolleri/global) dhe kombinoni guardat me dekoratorët e metadata është njohje qendrore për ndërtimin e aplikacioneve të sigurta NestJS dhe një temë e shpeshtë, me rëndësi arkitekturore në kornizën.