Guard-ovi određuju je li zahtjev dozvoljeno nastaviti do handler-a rute — oni su NestJS-ov dedicirani mehanizam za autorizaciju (i često provjere autentifikacije). Guard vraća true kako bi dopustio zahtjev ili false/baci iznimku kako bi ga blokirao.
@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 implementira canActivate(), što vraća boolean (ili Promise/Observable od njega). Vraćanje false blokira zahtjev sa 403; također možete baciti specifičnu iznimku (npr. 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)
Guard-ovi se mogu primijeniti na razini metode, kontrolera ili globalno.
@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
}
}
Kombiniranje @Roles() dekoratora (metapodaci) s guard-om koji ga čita (preko Reflector-a) je standardni obrazac za kontrolu pristupa temeljenu na ulogama.
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.
Guard-ovi su NestJS-ov dedicirani, idiomatski mehanizam za autorizaciju — kontrolu kojih zahtjeva je dozvoljeno dostići handler-e na osnovi autentifikacije i dozvola.
Razumijevanje je neophodno jer praktički svaka prava aplikacija trebala čuvati rute (zahtijevati prijavu, provjeravati uloge/dozvole), a guard-ovi su pravi alat za to (daleko čistije od uguravanja auth logike u middleware ili svakog handler-a).
Standardni obrasci — JWT/auth guard koji potvrđuje vjerodajnice i pripisuje korisnika zahtjevu, i guard-ovi temeljeni na ulogama koji kombiniraju @Roles() dekorator s Reflector-čitajućim guard-om za RBAC — su temeljni za osiguranje NestJS API-ja.
Pristup guard-ova bogatom ExecutionContext-u (poznavanju ciljnog handler-a, klase i zahtjeva) je upravo ono što ih čini prikladnima za odluke autorizacije koje middleware ne može čisto napraviti.
Znanje kako napisati, primijeniti (metoda/kontroler/globalno) i kombinirati guard-ove s metapodacima dekoratora je osnovna znanja za izradu sigurnih NestJS aplikacija i česta, arhitektonski važna tema u framework-u.