Series: Axios Lesson 49

Request Body Typing — POST, PUT va PATCH body'larini tipizatsiya qilish

Axios orqali POST, PUT va PATCH so'rovlarida body qismini tiplashtirish: DTO yaratish, Partial<T> orqali PATCH yondashuvi, ApiWrapper va generiklar integratsiyasi.

49-dars

Request Body Typing — POST, PUT va PATCH body'larini tipizatsiya qilish

Serverga ma'lumot yuborayotganimizda (POST, PUT, PATCH so'rovlari), so'rov tanasi (request body) ma'lum bir qat'iy strukturaga ega bo'lishi shart. Agar TypeScript'da bu body tiplashtirilmasa, noto'g'ri turdagi ma'lumot yuborish yoki mavjud bo'lmagan maydonni ko'rsatib qo'yish xavfi yuzaga keladi.

Axios'ning post, put va patch metodlari ikkita asosiy generikni qabul qiladi:

apiClient.post<ResponseDataType, RequestDataType>(url, data, config);
  • 1-generik (ResponseDataType): Serverdan javob sifatida keladigan ma'lumot turi (response.data).
  • 2-generik (RequestDataType): Serverga yuboriladigan payload (body) ma'lumot turi.

1. Amaliy misol: POST so'rovini tiplashtirish

Yangi foydalanuvchi yaratish jarayonini ko'rib chiqamiz. Buning uchun ikkita alohida DTO (Data Transfer Object) e'lon qilinadi: biri yuboriladigan ma'lumot uchun (CreateUserDto), ikkinchisi esa serverdan qaytadigan javob uchun (User).

import { apiClient } from './client';

// 1. Serverga yuboriladigan ma'lumot turi (Request Body DTO)
export interface CreateUserDto {
  fullName: string;
  email: string;
  age: number;
}

// 2. Serverdan qaytadigan javob turi (Response Data DTO)
export interface User {
  id: number;
  fullName: string;
  email: string;
  age: number;
  createdAt: string;
}

// 3. Servis funksiyasi
export const createUser = async (userData: CreateUserDto): Promise<User> => {
  // POST<ResponseDataType, RequestDataType>
  const response = await apiClient.post<User, CreateUserDto>('/users', userData);
  
  return response.data;
};

[!NOTE] Agar siz userData obyektiga CreateUserDto ichida mavjud bo'lmagan maydon qo'shmoqchi bo'lsangiz yoki maydon turini xato yozsangiz (masalan, age: "yigirma"), TypeScript darhol kompilyatsiya bosqichida xatolik ko'rsatib ogohlantiradi.


2. PUT va PATCH so'rovlarini tiplashtirish

PUT va PATCH so'rovlari mavjud ma'lumotni yangilash uchun ishlatiladi. Ularning tub farqi quyidagicha:

  • PUT — resursni to'liq almashtiradi (odatda barcha maydonlar majburiy bo'ladi).
  • PATCH — qisman o'zgartiradi (faqat o'zgargan maydonlar yuboriladi, shuning uchun maydonlar ixtiyoriy — optional bo'ladi).

TypeScript'dagi yordamchi turlar (Partial<T>, Omit<T>) bu yerda juda qo'l keladi:

import { apiClient } from './client';
import { CreateUserDto, User } from './userTypes';

// Barcha maydonlarni majburiy qilib yangilash (PUT uchun)
export type UpdateUserFullDto = CreateUserDto;

// Barcha maydonlarni ixtiyoriy qilib yangilash (PATCH uchun — Partial yordamida)
export type UpdateUserPartialDto = Partial<CreateUserDto>;

export const UserService = {
  // PUT so'rovi (to'liq almashtirish)
  updateComplete: async (id: number, data: UpdateUserFullDto): Promise<User> => {
    const res = await apiClient.put<User, UpdateUserFullDto>(`/users/${id}`, data);
    return res.data;
  },

  // PATCH so'rovi (qisman yangilash)
  updatePartial: async (id: number, data: UpdateUserPartialDto): Promise<User> => {
    const res = await apiClient.patch<User, UpdateUserPartialDto>(`/users/${id}`, data);
    return res.data;
  },
};

Komponentda PATCH so'rovini ishlatish juda qulay bo'ladi, chunki siz faqat o'zgartirmoqchi bo'lgan bitta maydonni uzatsangiz ham TypeScript ruxsat beradi:

// Faqat email'ni yangilash — qolgan maydonlar talab qilinmaydi!
await UserService.updatePartial(1, { email: '[email protected]' });

3. API Wrapper yoki Service Qatlamida tiplashtirish

Agar loyihada to'g'ridan-to'g'ri response.data ni qaytaruvchi ApiWrapper ishlatilayotgan bo'lsa, generiklar quyidagicha soddalashtiriladi:

import { apiClient } from './client';
import { AxiosRequestConfig } from 'axios';

export const ApiWrapper = {
  post: <TResponse, TBody = any>(
    url: string,
    data?: TBody,
    config?: AxiosRequestConfig
  ): Promise<TResponse> => {
    return apiClient.post(url, data, config);
  },

  put: <TResponse, TBody = any>(
    url: string,
    data?: TBody,
    config?: AxiosRequestConfig
  ): Promise<TResponse> => {
    return apiClient.put(url, data, config);
  },

  patch: <TResponse, TBody = any>(
    url: string,
    data?: TBody,
    config?: AxiosRequestConfig
  ): Promise<TResponse> => {
    return apiClient.patch(url, data, config);
  },
};

4. POST, PUT va PATCH taqqoslovi

HTTP Method Maqsadi Body Maydonlari Tavsiya etilgan DTO Turi
POST Yangi resurs yaratish Majburiy maydonlar talab etiladi interface CreateResourceDto
PUT Resursni to'liq almashtirish Barcha maydonlar majburiy CreateResourceDto yoki UpdateResourceDto
PATCH Resursni qisman yangilash Maydonlar ixtiyoriy (?) Partial<CreateResourceDto>

5. Nima uchun Request Body'ni tiplashtirish muhim?

  1. Xatoliklarning oldini olish: Backend kutilmagan formatdagi ma'lumotni qabul qilib, serverda 400 Bad Request yoki 500 Server Error bo'lishining oldi olinadi.
  2. Autocomplete qulayligi: Forma ma'lumotlarini (form state) yuborayotganda IDE qaysi maydonlar borligini avtomatik ko'rsatib turadi.
  3. Refactoring xavfsizligi: Agar backend'da biror maydon nomi o'zgarsa, uni DTO interfeysida o'zgartirish kifoya — butun loyiha bo'ylab qayerda noto'g'ri ishlatilgani darhol qizil bilan belgilanadi.

Xulosa

Axios metodlarida request body'ni tiplashtirish frontend va backend o'rtasidagi ma'lumotlar almashinuvini kafolatli va xavfsiz qiladi. POST, PUT va PATCH so'rovlari uchun alohida DTO va Partial<T> turlaridan foydalanish dastur arxitekturasini mustahkam va kengaytirishga oson holatga keltiradi.