Seriya: Axios Dars 52

Type-safe API Service — To'liq type-safe API service layer yaratish

To'liq type-safe API Service qatlami: DTO turlari, universal http helper, UserService va React UI komponentlari o'rtasidagi toza arxitektura va qatlamlar ajratilishi.

52-dars

Type-safe API Service — To'liq type-safe API service layer yaratish

Yirik React va TypeScript loyihalarida API arxitekturasini shunday qurish kerakki, u quyidagi uchta muhim mezonlarga 100% javob bersin:

  1. Toza qatlamlar (Separation of Concerns): UI komponentlar HTTP so'rovlar, URL manzillari yoki Axios tafsilotlari nima ekanligini bilmaydi.
  2. Qat'iy Tipizatsiya (Strict Type Safety): So'rovga yuboriladigan ma'lumotlar (DTO), serverdan qaytadigan javoblar (Response) va xatolar qat'iy tiplashtirilgan bo'lishi shart.
  3. Qayta ishlatiluvchanlik (Reusability): Kod takrorlanmaydi, barcha past darajadagi HTTP amallar universal yordamchi (helper) orqali boshqariladi.

Professional loyiha strukturasi

Fayllarning loyihadagi aniq va modulli tartibi:

src/
 ├── api/
 │   ├── client.ts        # Axios instance va interceptor'lar
 │   └── http.ts          # Generic HTTP helper (get, post, patch va h.k.)
 ├── types/
 │   └── user.types.ts    # DTO va Model interfeyslari
 ├── services/
 │   └── userService.ts   # To'liq type-safe API service
 └── components/
     └── UserProfile.tsx  # UI Komponent

1-Qadam: Turlarni e'lon qilish (src/types/user.types.ts)

Barcha ma'lumotlar tuzilmasini oldindan interfeys va type'lar ko'rinishida yozib olamiz:

// src/types/user.types.ts

// 1. Asosiy User modeli (Serverdan keladigan domen obyekti)
export interface User {
  id: number;
  fullName: string;
  email: string;
  role: 'admin' | 'user';
  createdAt: string;
}

// 2. Yangi foydalanuvchi yaratish DTO'si (POST uchun)
export interface CreateUserDto {
  fullName: string;
  email: string;
  password?: string;
  role?: 'admin' | 'user';
}

// 3. Foydalanuvchini yangilash DTO'si (PATCH uchun - Partial)
export type UpdateUserDto = Partial<CreateUserDto>;

// 4. Sahifalangan javob formati (Pagination)
export interface PaginatedUsers {
  data: User[];
  total: number;
  page: number;
  totalPages: number;
}

2-Qadam: Universal HTTP Helper (src/api/http.ts)

Axios instansiyasini o'rab, to'g'ridan-to'g'ri response.data ni qaytaruvchi generik yordamchi:

// src/api/http.ts
import { apiClient } from './client';
import { AxiosRequestConfig } from 'axios';

export const http = {
  get: async <T>(url: string, config?: AxiosRequestConfig): Promise<T> => {
    const res = await apiClient.get<T>(url, config);
    return res.data;
  },
  post: async <T, D = any>(
    url: string,
    data?: D,
    config?: AxiosRequestConfig
  ): Promise<T> => {
    const res = await apiClient.post<T, any, D>(url, data, config);
    return res.data;
  },
  patch: async <T, D = any>(
    url: string,
    data?: D,
    config?: AxiosRequestConfig
  ): Promise<T> => {
    const res = await apiClient.patch<T, any, D>(url, data, config);
    return res.data;
  },
  delete: async <T>(url: string, config?: AxiosRequestConfig): Promise<T> => {
    const res = await apiClient.delete<T>(url, config);
    return res.data;
  },
};

3-Qadam: Type-safe API Service (src/services/userService.ts)

Endi barcha qoidalarni jamlagan holda to'liq tiplashtirilgan servis qatlamini yozamiz. Har bir metodning kirish parametrari va qaytaradigan qiymati (Promise<T>) qat'iy nazorat qilinadi:

// src/services/userService.ts
import { http } from '../api/http';
import { AxiosRequestConfig } from 'axios';
import {
  User,
  CreateUserDto,
  UpdateUserDto,
  PaginatedUsers,
} from '../types/user.types';

export const UserService = {
  // Barcha foydalanuvchilar (sahifalangan)
  getAll: (
    page: number = 1,
    limit: number = 10,
    config?: AxiosRequestConfig
  ): Promise<PaginatedUsers> => {
    return http.get<PaginatedUsers>('/users', {
      ...config,
      params: { page, limit, ...config?.params },
    });
  },

  // ID bo'yicha bitta foydalanuvchini olish
  getById: (id: number, config?: AxiosRequestConfig): Promise<User> => {
    return http.get<User>(`/users/${id}`, config);
  },

  // Yangi foydalanuvchi yaratish (POST)
  create: (data: CreateUserDto, config?: AxiosRequestConfig): Promise<User> => {
    return http.post<User, CreateUserDto>('/users', data, config);
  },

  // Foydalanuvchini qisman yangilash (PATCH)
  update: (
    id: number,
    data: UpdateUserDto,
    config?: AxiosRequestConfig
  ): Promise<User> => {
    return http.patch<User, UpdateUserDto>(`/users/${id}`, data, config);
  },

  // Foydalanuvchini o'chirish (DELETE)
  remove: (id: number, config?: AxiosRequestConfig): Promise<void> => {
    return http.delete<void>(`/users/${id}`, config);
  },
};

4-Qadam: UI Komponentda ishlatilishi (src/components/UserProfile.tsx)

Komponent toza, hech qanday URL manzillari yoki Axios tafsilotlarisiz, faqat UserService bilan ishlaydi:

// src/components/UserProfile.tsx
import React, { useEffect, useState } from 'react';
import { UserService } from '../services/userService';
import { User } from '../types/user.types';

export const UserProfile: React.FC = () => {
  const [user, setUser] = useState<User | null>(null);
  const [loading, setLoading] = useState<boolean>(true);

  useEffect(() => {
    // To'liq type-safe chaqiruv
    UserService.getById(1)
      .then((data) => {
        setUser(data); // data avtomatik ravishda User turiga ega!
      })
      .catch((err) => {
        console.error('Xatolik yuz berdi:', err);
      })
      .finally(() => {
        setLoading(false);
      });
  }, []);

  if (loading) return <p>Yuklanmoqda...</p>;
  if (!user) return <p>Foydalanuvchi topilmadi.</p>;

  return (
    <div>
      <h2>{user.fullName}</h2>
      <p>Email: {user.email}</p>
      <span className="badge">{user.role}</span>
    </div>
  );
};

5. Arxitektura qatlamlari va mas'uliyatlar taqsimoti

Qatlam Fayl namunasi Mas'uliyati Axios bilan bevosita aloqasi
Client / Interceptors src/api/client.ts BaseURL, timeout, tokenlar, interceptorlar Ha (Axios instance yaratiladi)
HTTP Helper src/api/http.ts Generic metodlar, response.data unwrap Ha (Axios chaqiruvlari o'raladi)
Types / DTO src/types/*.types.ts Domen modellari, DTO va Response interfeyslari Yo'q (Sof TypeScript)
Service Layer src/services/*.ts Endpointlar, query parametrlar, biznes-metodlar Yo'q (Faqat http helper bilan ishlaydi)
UI Components src/components/*.tsx Foydalanuvchi interfeysi, state va render Yo'q (Faqat Service chaqiradi)

Nima uchun bu yondashuv mukammal hisoblanadi?

  1. 100% Type Safety: Agar kelajakda backend dasturchilar User modelidan email maydonini olib tashlasa yoki o'zgartirsa, siz uni faqat user.types.ts da o'zgartirasiz va TypeScript ilovaning qaysi joyida xatolik yuzaga kelganini qizil chiziqlar bilan darhol ko'rsatib beradi.
  2. Kodni o'qish osonligi: Komponentlar juda toza va sodda saqlanadi. Biznes-mantiq faqat services papkasida jamlanadi.
  3. Qayta ishlatish va kengaytirish: Yangi obyekt qo'shish kerak bo'lsa, xuddi shu andaza (Types $\rightarrow$ http $\rightarrow$ Service $\rightarrow$ Component) asosida soniyalar ichida yangi servis yozib ketish mumkin.

Xulosa

To'liq Type-safe API Service Layer — bu zamonaviy dasturlashning eng yuksak standartlaridan biridir. Qatlamlarni qat'iy ajratish va TypeScript imkoniyatlaridan to'liq foydalanish dastur kodining xavfsizligini ta'minlaydi, refaktoring qilishni osonlashtiradi va jamoa a'zolari o'rtasida ishonchli ish oqimini yaratadi.