type Scope = 'api' | 'internal';
type Resource = 'users' | 'invoices' | 'teams';
type Action = 'read' | 'write' | 'delete' | '*';
// Produs cartezian generat automat de TS:
export type Permission = `${Scope}:${Resource}:${Action}`;
// Extragerea resursei dintr-un string de permisiune:
export type ExtractResource<T extends string> =
T extends `${string}:${infer R}:${string}` ? R : never;
function checkAccess(perm: Permission): boolean {
return perm.endsWith(':*') || perm.startsWith('api:');
}
// Autocomplete perfect, eroare la typo:
checkAccess('api:invoices:read'); // OK
// @ts-expect-error - typo detectat la compile-time
checkAccess('api:invoices:udpate');Am avut acum vreo doi ani un incident stupid în producție: cineva a scris billing:invoice:udpate în loc de update într-un middleware de auth. Linter-ul a tăcut, testele n-au prins typo-ul fiindcă mock-uiau string-ul brut, iar utilizatorii cu rol de contabil s-au trezit cu erori de 403 timp de vreo 4 ore. Atunci am tăiat în carne vie și am decis că niciun string de permisiune nu mai intră în codebase fără să fie validat de sistemul de tipuri.
Template literal types au apărut prin TypeScript 4.1, dar multă lume le ignoră sau le folosește doar pentru chestii triviale gen kebab-case to camelCase. Puterea lor reală se vede când modelezi domenii stricte, cum ar fi un sistem RBAC sau ABAC pe care îl împarți între backend și frontend.
Cum construim matricea de permisiuni
Ideea de bază e simplă: TypeScript distribuie automat uniunile peste șabloanele de string. Dacă ai o listă de resurse și o listă de acțiuni posibile, compilatorul face produsul cartezian în locul tău fără să scrii zeci de linii repetitive.
Când combini mai multe uniuni, obții instant toate variantele valide. Vrei să adaugi și un wildcard pentru administratori? Nicio problemă, îl adaugi în uniunea de bază sau îl compui separat. Ce e mișto e că funcția ta de verificare a accesului — să-i zicem hasPermission(user, permission) — primește autocomplete complet în IDE. N-ai cum să greșești numele resursei fără să urle compilatorul cu roșu.
Extragerea bucăților cu infer
Magia nu se oprește la generarea de string-uri. Uneori ai deja o permisiune salvată ca string în baza de date sau primită dintr-un token JWT și vrei să extragi resursa sau acțiunea pentru audit logs sau logică de routing.
Folosind pattern matching cu infer, poți desface string-ul în componentele lui la nivel de tip. Compilatorul știe exact ce tip are fiecare segment. Dacă permisiunea se potrivește cu structura api:${string}:${string}, extragi tipul resursei și îl convertești direct într-un tip util în restul aplicației, fără regex-uri scrise de mână la fiecare pas.
Trade-off-ul: capcana exploziei combinatorii
Sună perfect, dar există o problemă gravă dacă sari calul: performanța compilatorului. La un monorepo cu vreo 40 de resurse, 8 acțiuni standard și 4 medii de execuție sau tenant scopes, am ajuns rapid la peste 1.200 de variante de tipuri dintr-o singură linie.
Ce am pățit? TSServer a început să consume 1.8 GB de RAM în VS Code, iar autocomplete-ul avea un lag vizibil de două secunde la fiecare apăsare de tastă. TypeScript are o limită internă de recursivitate și complexitate a uniunilor; dacă generezi zeci de mii de combinații, o să vezi eroarea clasică Type instantiation is excessively deep and possibly infinite.
Regula mea de bun simț: ține template literals pentru combinații finite, bine delimitate (sub 300-400 de variante). Dacă ajungi la mii de permisiuni ultra-dinamice cu regex-uri complexe, e mai sănătos să folosești branded types și validare la runtime cu Zod sau ArkType.
Voi cum țineți în frâu autorizarea pe frontend și backend — tipuri stricte generate sau vă bazați doar pe teste de integrare?