interface User {
id: string;
email: string;
passwordHash: string;
role: 'admin' | 'user';
bio?: string;
createdAt: Date;
}
// 1. Nu expunem hash-ul către client
export type PublicUser = Omit<User, 'passwordHash'>;
// 2. La înregistrare cerem doar datele inițiale
export type RegisterDTO = Pick<User, 'email'> & { password: string };
// 3. La PATCH totul e opțional, dar nu permitem schimbarea id-ului sau datei
export type UpdateProfileDTO = Partial<Pick<User, 'email' | 'bio'>>;
// 4. Extragem tipul returnat de un handler fără să rescriem interfața
async function getUserStats(userId: string) {
return { activeSessions: 3, lastLogin: new Date() };
}
type UserStats = ReturnType<typeof getUserStats>;Dacă te prinzi că definești User, apoi CreateUserInput, apoi UpdateUserInput scriind de mână aceleași 15 câmpuri, pierzi timp aiurea. Am făcut greșeala asta acum vreo 6 ani la o aplicație cu vreo 40 de tabele în Postgres și am ajuns rapid la sute de tipuri redundante. TypeScript vine din cutie cu câteva unelte simple care rezolvă problema asta elegant.
Partial și Required la update-uri reale
Cea mai comună nevoie pe backend sau frontend apare la endpoint-urile de tip PATCH. Utilizatorul vrea să-și schimbe doar avatarul sau doar numele, nu tot formularul.
Partial<T> ia toate proprietățile lui T și le transformă în opționale (le adaugă ?).
Trade-off-ul e simplu: Partial e o armă cu două tăișuri dacă îl trântești direct pe toată entitatea. Dacă faci Partial<User>, permiți teoretic ca payload-ul să conțină și id: undefined sau să permită modificarea unor câmpuri de sistem. Soluția sănătoasă e să filtrezi întâi proprietățile modificabile și abia apoi să aplici Partial.
Required<T> face exact opusul. Îl folosesc des la sisteme de configurare: am o interfață cu setări opționale pe care le trimite utilizatorul, iar după ce aplic fallback-urile mele interne, forțez obiectul final să fie Required<Config>. Așa mă asigur că logica internă nu dă de undefined.
Pick vs Omit: dilema securității
Ambele servesc la reducerea unei structuri mari la un subset mai mic, dar filozofia lor e diferită:
Pick<T, Keys>ia doar ce-i spui explicit.Omit<T, Keys>ia tot, mai puțin ce excluzi.
Am pățit la un sistem fintech o chestie neplăcută: foloseam Omit<Account, 'secretKey'> pentru a returna datele de cont în API. Un coleg a adăugat un câmp nou în bază, riskScoreInternal, care nu trebuia să ajungă niciodată la client. Pentru că aveam Omit, câmpul nou a fost automat inclus în răspuns timp de două săptămâni până s-a prins cineva la un audit.
De atunci, regula mea e strictă: pentru date trimise către exterior folosesc aproape mereu Pick. E mai mult de tastat la refactoring, dar e garantat tip-safe împotriva scăpărilor de date.
ReturnType când te lupți cu biblioteci terțe
Câteodată folosești un ORM sau o librărie de validare (gen Zod, Prisma sau un factory intern) care generează dinamic obiecte complexe, dar autorul n-a exportat un type explicit pentru rezultatul final.
În loc să inspectezi manual ce returnează funcția și să faci reverse-engineering la un interface, trântești type MyData = ReturnType<typeof myFunction>. Dacă funcția e asincronă, o combini cu Awaited: type Result = Awaited<ReturnType<typeof fetchItems>>.
Am economisit zeci de ore pe proiecte mari scăpând de tipuri scrise la ghici care se desincronizau la fiecare update de librărie.
Unde devine nasol
Evită să cazi în capcana meta-programării exagerate. Când văd în code review chestii de genul Partial<Omit<Pick<User, 'a' | 'b' | 'c'>, 'c'>> & Required<Pick<Other, 'x'>>, mă ia durerea de cap. E ilizibil, iar erorile din compilator devin un zid de text pe care juniorii din echipă nu vor ști să-l decodeze.
Dacă o transformare necesită mai mult de două utility types compuse, mai bine declari o interfață curată de la zero.
Voi ce folosiți ca default când filtrați datele pentru API: abordarea conservatoare cu Pick sau mergeți pe Omit?