Cinneann guards an bhfuil gealadh ceadaithe a dhul ar aghaidh go dtí an handler iarbhír an bhóthar — is iad an méanism dírithe de NestJS do údarú (agus go minic sheiceanna fíordheimhnithe). Filleann guard true chun an iarratas a cheadú nó false/thaifeadadh chun é a bhacadh.
@Injectable()
export class AuthGuard implements CanActivate {
canActivate(context: ExecutionContext): boolean {
const request = context.switchToHttp().getRequest();
return !!request.headers.authorization; // true = allow, false = block (403)
}
}
Cuireann guard canActivate() i bhfeidhm, a fhilleann boolean (nó Promise/Observable de sin). Má fhilleann tú false bíonn an iarratas bactha le 403; is féidir leat eisceacht shonrach a thaifeadadh freisin (m.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)
Is féidir guards a chur i bhfeidhm ar an leibhéal modh, rialóir, nó domhanda.
@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
}
}
Is é an patrún caighdeánach a bhaineann le @Roles() (sondata) agus le guard a léann é (trí Reflector) an rialú rochtain bunaithe ar ról.
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.
Is iad guards an méanasm dírithe agus idiomatach de NestJS do údarú — a rialú cé na hiarbhíreanna a bhfuil cead acu dul go dtí na handlers bunaithe ar fhíordheimhnithe agus ceadanna.
Tá sé riachtanach iad a thuiscint toisc go dteastaíonn cosaint a dhéanamh ar bhóthar i gach fíor-thairbhe (logáil isteach a bheith ag teastáil, róil/ceadanna a sheiceáil), agus is iad guards an uirlis cheart ar an ábhar seo (i bhfad níos geal ná an loighic údarúcháin a chur isteach sa middleware nó i ngach handler).
Is iad na patrúin chaighdeánacha — guard JWT/údarúcháin a bhailíonn creidiúintí agus a cheanglíonn an úsáideoir ar an iarratas, agus guards bunaithe ar róil ag cumadh @Roles() le guard ag léamh trí Reflector do RBAC — lárnach i ndaingne na n-API NestJS.
Is ann do rochtain guards ar an saibhir ExecutionContext (ar eolas an tairgid handler, rang agus iarratas) go beacht cad atá oiriúnach dóibh ar chinntí údarúcháin nach féidir leis an middleware a dhéanamh go soiléir.
A bheith ar an eolas conas guards a scríobh, a chur i bhfeidhm (modh/rialóir/domhanda), agus a chomhcheangal le gréasáin-dhréachtóirí sondata is feasacht bhunúsach chun feidhmchláir NestJS a dhéanamh slán agus ábhar minic, thábhachtach go leictreachais sa bhframework.