type SystemResource = 'user' | 'invoice' | 'project';
type SystemAction = 'read' | 'create' | 'update' | 'delete' | 'export';
// Matrice de acțiuni valide per resursă
type ResourcePermissions = {
user: 'read' | 'create' | 'update' | 'delete';
invoice: 'read' | 'export';
project: SystemAction;
};
// Template literal type restricționat
export type PermissionString<R extends SystemResource = SystemResource> =
R extends unknown ? `api:${R}:${ResourcePermissions[R]}` : never;
function canAccess<R extends SystemResource>(permission: PermissionString<R>): boolean {
// Verificare runtime rapidă
return true;
}
// Valide:
canAccess('api:user:create');
canAccess('api:invoice:export');
// TypeScript Error: Type '"api:invoice:delete"' is not assignable...
// canAccess('api:invoice:delete');Dacă ai scris vreodată un verificator de permisiuni gen user.hasPermission('users:delete') și ai pierdut două ore căutând un bug pentru că backend-ul se aștepta la user:delete la singular, textul ăsta e pentru tine. Template literal types rezolvă exact problema asta. Transformă banalele string-uri în contracte rigide verificate la compilare, fără niciun overhead în bundle-ul de runtime.
Problema cu string-urile oarbe
La un proiect cu vreo 40 de microservicii și 12 roluri diferite, țineam permisiunile ca string[]. Evident că la al treilea release cineva a împins în producție billing:invoice:read în loc de billing:invoices:read. În teste a trecut nestingherit fiindcă mock-urile erau scrise la fel de neglijent, dar în producție utilizatorii din finance s-au trezit cu 403 pe linie. A durat 45 de minute să ne dăm seama de ce un simplu dashboard nu se mai deschidea.
Soluția clasică pe vremuri era un enum gigantic sau un obiect imens const PERMISSIONS = { ... } as const. Merge, dar devine un coșmar de întreținut dacă sistemul tău e granular și ierarhic.
Produsul cartezian pe care ți-l dă TypeScript
Frumusețea la template literals e că poți combina mai multe union types pentru a genera automat toate permisiunile valide. Când definești un string template tip api:${Resource}:${Action}, TypeScript face în spate un produs cartezian între toate valorile posibile.
Ce faci însă dacă nu toate resursele suportă toate acțiunile? De pildă, un raport financiar poate fi descărcat (export) sau vizualizat (read), dar nu creat manual (create). Dacă combini naiv două uniuni, permiți stări invalide. Secretul e să folosești o hartă de mapare (un lookup table tip type) și un template generic care extrage acțiunile permise pentru resursa respectivă.
Trade-off-ul: atenție la memoria compilatorului
Să fim sinceri, tehnica asta e o sabie cu două tăișuri.
Merge impecabil când ai 10-15 resurse și câteva acțiuni standard. Primești autocomplete instant în VS Code, refactoring-ul merge dintr-un singur rename și ai garanția că nimeni nu greșește o literă.
Dar dacă arunci într-un template literal vreo 4 union-uri mari — de exemplu 40 de resurse × 8 acțiuni × 5 domenii × 3 tipuri de acces —, obții instant 4.800 de variante de string-uri în union. Am văzut un proiect unde un coleg a făcut asta pentru un router intern și ne-a crescut timpul de build în CI cu 35%, iar Language Server-ul din VS Code crăpa la fiecare 10 minute cu out of memory. TypeScript e puternic, dar nu e o bază de date relațională.
Regula mea de bază: dacă rezultatul depășește câteva sute de combinații, renunță la produsul cartezian complet și împarte permisiunile pe module sau folosește un parser de tip Zod la granița aplicației.
Voi cum țineți permisiunile în sync între backend și frontend: union types exportate dintr-un pachet comun sau scheme generate din OpenAPI?