Generic API response
TypeScript'da generic API javob modeli: ApiJavob<T> va ApiXato, sahifalangan javoblar, har qanday T uchun yordamchi funksiyalar, endpoint xaritasi orqali URL'ni type'ga bog'lash va eskirgan generic da'vo xatosi.
60-dars
Generic API response
ApiJavob<T> type'ini yozdik (58-dars). Endi uni real loyiha darajasiga olib chiqamiz: barcha endpoint'lar uchun bitta model, u bilan ishlaydigan umumiy yordamchilar va URL'ga bog'langan javob type'lari. Misollarda quyidagi type'lardan foydalanamiz:
type Mahsulot = { nomi: string; narx: number };
type Foydalanuvchi = { id: number; ism: string };
type Buyurtma = { id: string; summa: number };
declare function render(matn: string): void;
declare function xabarKorsat(xabar: string): void;
Bularsiz har bir so'rov o'z holicha qayta ishlanadi:
// ❌ Muammo: har bir joyda xatoni qo'lda tekshirish, data — any
async function profilniKorsat() {
const res = await fetch("/profil");
const javob = await res.json(); // any
if (javob.success === false) { // 🐛 backend "muvaffaqiyat" deydi, bu yerda "success"
return xabarKorsat(javob.error);
}
render(javob.data.ism); // TS hech narsani tekshirmaydi
}
async function buyurtmalarniKorsat() {
const res = await fetch("/buyurtmalar");
const javob = await res.json();
if (!javob.muvaffaqiyat) { /* yana xuddi shu kod... */ }
}
// ✅ Yechim: bitta generic model + umumiy yordamchilar
type ApiJavob<T> =
| { muvaffaqiyat: true; data: T }
| { muvaffaqiyat: false; xato: ApiXato };
const javob = await sorov("/profil"); // ApiJavob<Foydalanuvchi>
const profil = dataniOl(javob); // Foydalanuvchi
render(profil.ism); // ✅
Quyida sorov va dataniOl'ni bosqichma-bosqich yozamiz.
Qanday ishlaydi?
1. Asosiy model
58-darsdagi union'ni olamiz, xato qismini esa alohida interface qilamiz:
interface ApiXato {
kod: number; // masalan, 404, 422
xabar: string;
}
type ApiJavob<T> =
| { muvaffaqiyat: true; data: T }
| { muvaffaqiyat: false; xato: ApiXato };
E'tibor bering: xato varianti T'ga bog'liq emas. Mahsulot so'rovida ham, foydalanuvchi so'rovida ham xato bir xil ko'rinadi. Bu keyinroq juda qulay bo'ladi.
2. Sahifalangan javoblar
Ro'yxat qaytaradigan endpoint'lar odatda sahifalanadi. Sahifa<T> bilan birlashtiramiz:
interface Sahifa<T> {
elementlar: T[];
jami: number;
joriySahifa: number;
}
type SahifaJavobi<T> = ApiJavob<Sahifa<T>>;
function korsat(javob: SahifaJavobi<Mahsulot>) {
if (javob.muvaffaqiyat) {
javob.data.elementlar[0].narx; // number ✅
javob.data.jami; // number ✅
}
}
Generic type'lar "qatlam"lardek joylashadi: tashqi qatlam — muvaffaqiyat/xato, ichki — sahifalash, eng ichki — ma'lumot.
3. Har qanday T uchun ishlaydigan yordamchilar
Xatoni tekshirish logikasi T'ga bog'liq emas — demak, uni bir marta generic qilib yozish mumkin:
// Xato bo'lsa — throw, aks holda — toza data
function dataniOl<T>(javob: ApiJavob<T>): T {
if (!javob.muvaffaqiyat) {
throw new Error(`${javob.xato.kod}: ${javob.xato.xabar}`);
}
return javob.data;
}
// data'ni o'zgartirish, xatoni o'zgarishsiz uzatish
function ozgartir<T, U>(javob: ApiJavob<T>, f: (data: T) => U): ApiJavob<U> {
if (!javob.muvaffaqiyat) {
return javob; // ✅ xato varianti T'ga bog'liq emas — ApiJavob<U>'ga ham mos
}
return { muvaffaqiyat: true, data: f(javob.data) };
}
declare const mahsulotJavobi: SahifaJavobi<Mahsulot>;
const nomlar = ozgartir(mahsulotJavobi, (s) => s.elementlar.map((m) => m.nomi));
// ApiJavob<string[]>
ozgartir'dagi return javob aynan 1-bo'limdagi qaror tufayli ishlaydi: xato varianti hech qaysi T'ni eslatmaydi, shuning uchun ApiJavob<Sahifa<Mahsulot>>'ning xatosi ApiJavob<string[]>'ning xatosi sifatida ham to'g'ri.
4. Endpoint xaritasi: URL → javob type'i
51-darsdagi yukla<T>(url): Promise<T>'da chaqiruvchi T'ni o'zi "e'lon qiladi". URL va type o'rtasida hech qanday bog'lanish yo'q. Bu bog'lanishni keyof + indexed access (57-dars) bilan yaratamiz:
interface Endpointlar {
"/mahsulotlar": Sahifa<Mahsulot>;
"/profil": Foydalanuvchi;
"/buyurtmalar": Buyurtma[];
}
async function sorov<U extends keyof Endpointlar>(
url: U
): Promise<ApiJavob<Endpointlar[U]>> {
const res = await fetch(url);
return res.json(); // ⚠️ runtime'da hali tekshirilmaydi
}
const p = await sorov("/profil"); // ApiJavob<Foydalanuvchi> ✅
const m = await sorov("/mahsulotlar"); // ApiJavob<Sahifa<Mahsulot>> ✅
sorov("/profill");
// ❌ Argument of type '"/profill"' is not assignable to parameter of type 'keyof Endpointlar'.
| Usul | Type qayerdan? | URL'dagi xato |
|---|---|---|
yukla<Foydalanuvchi>("/profil") |
Chaqiruvchi har safar yozadi | Sezilmaydi |
sorov("/profil") |
Endpointlar xaritasidan |
❌ TS xato beradi |
Eng ko'p uchraydigan xato
Backend javob tuzilmasi o'zgargan, frontend generic'i eskicha qolgan. Avval /mahsulotlar oddiy massiv qaytarardi. Keyin backend sahifalash qo'shdi:
// Frontend'dagi kod (eski):
const javob = await yukla<ApiJavob<Mahsulot[]>>("/mahsulotlar");
if (javob.muvaffaqiyat) {
javob.data.map((m) => m.nomi); // TS indamaydi
// 💥 TypeError: javob.data.map is not a function
}
// Backend endi aslida shuni qaytaradi:
// { muvaffaqiyat: true, data: { elementlar: [...], jami: 120, joriySahifa: 1 } }
Nega bunday bo'ladi? Generic type argument — bu da'vo, tekshiruv emas. <ApiJavob<Mahsulot[]>> deb yozish "server shuni qaytaradi deb ishonaman" degani. TS bu da'voni hech qachon serverga solishtirmaydi, shuning uchun backend o'zgarganda kompilyatsiya xatosiz o'tadi, xato esa faqat foydalanuvchida chiqadi. Agar bir xil endpoint 10 joyda yukla<...> bilan chaqirilgan bo'lsa, 10 ta eski da'vo tarqalgan bo'ladi.
✅ Yechim 1: type'ni bitta joyga yig'ing — endpoint xaritasi. Backend o'zgarsa, bitta qatorni yangilaysiz va TS barcha eski ishlatilgan joylarni ko'rsatadi:
interface Endpointlar {
"/mahsulotlar": Sahifa<Mahsulot>; // Mahsulot[] edi — shu yerda yangiladik
// ...
}
const javob = await sorov("/mahsulotlar");
if (javob.muvaffaqiyat) {
javob.data.map((m) => m.nomi);
// ❌ Property 'map' does not exist on type 'Sahifa<Mahsulot>'.
javob.data.elementlar.map((m) => m.nomi); // ✅
}
✅ Yechim 2: type'larni backend bilan umumiy kontraktdan oling va javobni runtime'da tekshiring (masalan, 46-darsdagi type guard yoki schema kutubxonasi bilan) — shunda da'vo haqiqiy tekshiruvga aylanadi.
Esda tuting: API javobining generic type'i — server haqidagi da'vo; uni bitta joyda saqlang, shunda o'zgarishlarni TS sizga o'zi ko'rsatadi.