Guards bestämmer om en request är tillåten att fortsätta till route-handleren — de är NestJS:s dedikerade mekanism för auktorisering (och ofta autentiseringskontroller). En guard returnerar true för att tillåta requesten eller false/kastar ett undantag för att blockera den.
@Injectable()
export class AuthGuard implements CanActivate {
canActivate(context: ExecutionContext): boolean {
const request = context.switchToHttp().getRequest();
return !!request.headers.authorization; // true = allow, false = block (403)
}
}
En guard implementerar canActivate(), som returnerar ett booleskt värde (eller Promise/Observable av ett). Att returnera false blockerar requesten med en 403; du kan också kasta ett specifikt undantag (t.ex. 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 kan appliceras på metod-, controller- eller global nivå.
@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
}
}
Att kombinera en @Roles()-dekorator (metadata) med en guard som läser den (via Reflector) är standardmönstret för rollbaserad åtkomstkontroll.
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 är den dedikerade, idiomatiska NestJS-mekanismen för auktorisering — att kontrollera vilka requests som får nå handlerar baserat på autentisering och behörigheter.
Att förstå dem är väsentligt eftersom praktiskt taget varje verklig applikation behöver skydda routes (kräva inloggning, kontrollera roller/behörigheter), och guards är det korrekta verktyget för detta (mycket renare än att stoppa in autentiseringslogik i middleware eller varje handler).
Standardmönstren — en JWT/auth-guard som verifierar autentiseringsuppgifter och bifogar användaren till requesten, och rollbaserade guards som kombinerar en @Roles()-dekorator med en Reflector-läsande guard för RBAC — är fundamentala för att säkra NestJS API:er.
Guards åtkomst till den rika ExecutionContext (att veta om målhandlern, klassen och requesten) är exakt vad som gör dem lämpade för auktoriseringsbeslut som middleware inte på ett rent sätt kan fatta.
Att veta hur man skriver, applicerar (metod/controller/global) och kombinerar guards med metadata-dekoratorer är kärnkunskap för att bygga säkra NestJS-applikationer och ett ofta förekommande, arkitektur-viktigt ämne i ramverket.