type AsyncState<T> =
| { status: 'idle' }
| { status: 'loading' }
| { status: 'success'; data: T }
| { status: 'error'; error: Error };
function renderUI(state: AsyncState<string[]>) {
switch (state.status) {
case 'idle':
return 'Apasă butonul pentru încărcare';
case 'loading':
return 'Se încarcă...';
case 'error':
return `Eroare: ${state.error.message}`;
case 'success':
return `Avem ${state.data.length} elemente`;
default: {
const _exhaustiveCheck: never = state;
return _exhaustiveCheck;
}
}
}Până prin 2018 scriam stările de fetch exact cum nu trebuie: isLoading: boolean, data: T | null și error: string | null. Rezultatul inevitabil a fost că interfața ajungea des în stări aberante, cum ar fi spinner peste eroare sau date randate în timp ce request-ul rula din nou.
Discriminated unions (sau tagged unions) au rezolvat problema asta definitiv pentru mine. Ideea e banală: folosești o singură proprietate comună (de obicei status sau type) pe post de discriminator literal, iar compilatorul deduce automat restul proprietăților.
Fără stări imposibile la API calls
Când ai proprietăți opționale separate pe un obiect, TypeScript n-are cum să știe că error nu poate coexista cu data. Îi permiți matematic 8 combinații posibile din trei booleene, deși în realitate doar 3 sau 4 au sens în produs.
La o platformă de e-commerce cu vreo 12k comenzi pe lună la care am lucrat, aveam permanent tichete pe checkout. Ba că apărea butonul de plată blocat, ba că rămânea formularul dezactivat după o eroare de card. Am refăcut starea formularului cu o uniune discriminată bazată pe status: 'idle', 'submitting', 'success' și 'failed'. În momentul în care am făcut asta, TypeScript ne-a forțat să tratăm fiecare ramură în componente. Am tăiat din start vreo 6 bug-uri de sincronizare care ne mâncau timpul la fiecare release.
Reducere și State Machines fără biblioteci grele
Nu ai mereu nevoie de XState ca să ai comportament predictibil. Dacă ai un reducer clasic în React sau un store simplu, discriminated unions fac minuni împreună cu exhaustive type checking.
Dacă adaugi o stare nouă în uniune — să zicem status: 'requires_2fa' — compilatorul crapă instant la build în toate fișierele unde nu ai pus un case specific în switch. Asta obții folosind tipul never pe ramura default.
Pentru mine, ăsta e testul suprem de refactoring: adaugi un feature nou în tipul de date, salvezi, iar TypeScript îți desenează pe ecran lista exactă de fișiere unde trebuie să adaugi logică.
Unde devine enervant (trade-off sincer)
Pattern-ul ăsta nu vine pe gratis și are două bătăi de cap evidente:
- Serializarea din backend: Dacă API-ul tău livrează JSON-uri plate cu o căruță de câmpuri nullabile (stilul clasic Spring Boot sau Laravel nesortat), ești forțat să scrii o funcție de mapare manuală la intrarea în client ca să transformi răspunsul într-o uniune discriminată. Dacă uiți un caz, runtime-ul crapă.
- Boilerplate la stări compuse: Dacă un ecran are date parțiale care trebuie păstrate pe ecran în timp ce reîncarci în background (cum ar fi un refetch silențios), împărțirea pe stări strict mutual exclusive devine rigidă. Ajungi să dublezi câmpul
datași pe starealoading, ceea ce diluează puțin eleganța inițială a pattern-ului.
Chiar și cu compromisul ăsta, pentru orice flux critic — de la plăți, auth, până la upload de fișiere mari — nu mă mai întorc la obiecte cu flag-uri opționale împrăștiate.
Voi cum gestionați stările de fetch în proiectele mari? Mergeți pe tipare de genul ăsta scrise de mână sau lăsați TanStack Query să se ocupe de tot?