Guards განსაზღვრავს, არის თუ არა მოთხოვნა ნებადართული რომ გაგრძელდეს route handler-ისკენ — ეს არის NestJS-ის ავტორიზაციის (და ხშირად ავთენტიკაციის შემოწმების) დამოუკიდებელი მექანიზმი. 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() დეკორატორის (metadata) და 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-ის ავტორიზაციის დეკიკირებული, იდიომატური მექანიზმი — კონტროლი, თუ რომელი მოთხოვნები დაშვებულია handler-ებამდე მიმართოთ ავთენტიკაციისა და ნებართვების საფუძველზე.
მათი გაგება აუცილებელია, რადგან პრაქტიკულად ყველა რეალურ აპლიკაციას აჭირდება routes-ის დაცვა (აუცილებელია ლოგინი, როლებისა და ნებართვების შემოწმება), და guards არის სწორი ინსტრუმენტი ამ საქმეში (ბევრად უფრო სუფთა, ვიდრე ავთენტიკაციის ლოგიკა middleware-ში ან თითოეულ handler-ში დაწკაპება).
სტანდარტული ნიმუშები — JWT/ავთენტიკაციის guard, რომელიც ამოწმებს ნათელი ინფორმაციას და ამატებს მომხმარებელს მოთხოვნაზე, და როლზე დაფუძნებული guards, რომელიც აერთიანებს @Roles() დეკორატორს Reflector-ის წაკითხვის guard-ის სახით RBAC-ისთვის — არის ფუნდამენტური NestJS API-ების დასაცავად.
Guards-ის წვდომა ღრიმე ExecutionContext-ზე (იცოდა სამიზო handler, კლასი და მოთხოვნა) არის ზუსტად ის, რაც მათ ხდის გამოსადეგ ავტორიზაციის გადაწყვეტილებებისთვის, რომელთა მუშაობა middleware-ს არ შეუძლია სუფთად.
იცოდეთ, თუ როგორ დაწეროთ, გამოიყენოთ (მეთოდი/კონტროლერი/გლობალური) და აერთიანოთ guards metadata დეკორატორებთან, არის ძირითადი ცოდნა უსაფრთხო NestJS აპლიკაციების აგებისთვის და ხშირი, არქიტექტურულად მნიშვნელოვანი თემა ფრეიმვორკში.