Series: Axios Lesson 91

File Upload — Fayllarni serverga yuklash

Axios va TypeScript yordamida professional fayl yuklash (File Upload): frontend validatsiya (hajm va MIME type), ko'p faylli yuklash (multiple), onUploadProgress va AbortController orqali bekor qilish.

91-dars

File Upload — Fayllarni serverga yuklash

Oldingi darsimizda biz FormData mexanizmi va uning boundary xususiyatini o'rgandik. Biroq real, yuqori sifatli ishlab chiqarish (production) tizimlarida fayllarni yuklash oddiygina FormData yaratib yuborishdan ancha kengroqdir.

Professional darajadagi fayl yuklash moduli quyidagi 4 ta asosiy ustunga tayanadi:

  1. Frontend Validation (Mijoz tomonidagi tekshiruv): Fayl hajmi va formati serverga yuborilmasdan oldin brauzerdayoq tekshirilishi kerak (ortiqcha tarmoq trafigini tejash uchun).
  2. Multiple Files (Ko'p faylli yuklash): Bir vaqtning o'zida bir nechta faylni biriktirish va to'g'ri massiv sifatida yuborish.
  3. Upload Progress (Yuklanish foizi): Katta hajmli fayllarda foydalanuvchiga real vaqt rejimida foizli ko'rsatkich (progress bar) taqdim etish.
  4. Cancellation (Bekor qilish): Foydalanuvchi xohlagan daqiqada AbortController yordamida yuklashni to'xtata olishi.
flowchart TD
    A["Foydalanuvchi Fayllarni Tanlaydi\n(<input type='file' multiple />)"] --> B{"1. Client-Side Validatsiya\n(Hajmi <= 10MB va Formati ruxsat etilganmi?)"}
    B -->|Yo'q| C["Xatolik xabarini ko'rsatish\n(Serverga so'rov ketmaydi)"]
    B -->|Ha| D["2. FormData Paketi\n(formData.append('files', file))"]
    D --> E["3. Axios POST So'rovi\n(signal: AbortSignal, onUploadProgress)"]
    E --> F["4. Real Vaqt Monitoringi\n(UI Progress Bar yangilanadi)"]
    E -->|Foydalanuvchi 'Bekor qilish'ni bossa| G["AbortController.abort()\n(Tarmoq uziladi)"]
    E -->|Muvaffaqiyatli| H["200 OK: Fayllar saqlandi"]

1. Amaliyot: Professional TypeScript va Axios File Upload Servisi

Keling, barcha ushbu talablarni o'z ichiga olgan, to'liq tiplashtirilgan FileUploadService modulini yozamiz:

// src/services/uploadService.ts
import { apiClient } from '../api/client';
import { AxiosProgressEvent } from 'axios';

export interface UploadOptions {
  onProgress?: (percentage: number) => void;
  signal?: AbortSignal;
}

export interface UploadResult {
  success: boolean;
  urls: string[];
  totalSize: number;
}

export const FileUploadService = {
  /**
   * Bir yoki bir nechta faylni tekshirib, serverga yuklaydi
   */
  uploadMultipleFiles: async (
    files: File[],
    options?: UploadOptions
  ): Promise<UploadResult> => {
    // --- 1. FRONTEND VALIDATSIYA ---
    const MAX_SIZE_MB = 10;
    const allowedTypes = [
      'image/jpeg',
      'image/png',
      'image/webp',
      'application/pdf',
    ];

    for (const file of files) {
      // Fayl hajmini baytlarda tekshiramiz
      if (file.size > MAX_SIZE_MB * 1024 * 1024) {
        throw new Error(
          `"${file.name}" fayl hajmi juda katta. Maksimal ruxsat etilgan hajm: ${MAX_SIZE_MB}MB`
        );
      }

      // Fayl formatini (MIME type) tekshiramiz
      if (!allowedTypes.includes(file.type)) {
        throw new Error(
          `"${file.name}" fayl formati qo'llab-quvvatlanmaydi. Faqat rasm va PDF ruxsat etilgan.`
        );
      }
    }

    // --- 2. FORMDATA TAYYORLASH ---
    const formData = new FormData();

    // Har bir faylni bir xil kalit nomi bilan qo'shamiz (backend massiv sifatida qabul qiladi)
    files.forEach((file) => {
      formData.append('files', file);
    });

    // --- 3. SO'ROVNI YUBORISH ---
    // Eslatma: Content-Type ni qo'lda yozmaymiz, Axios boundary bilan o'zi to'g'rilaydi!
    const response = await apiClient.post<UploadResult>(
      '/upload/multiple',
      formData,
      {
        // AbortController signalini ulaymiz (yuklashni to'xtatish uchun)
        signal: options?.signal,

        // Yuklanish foizini hisoblash
        onUploadProgress: (progressEvent: AxiosProgressEvent) => {
          if (progressEvent.total && options?.onProgress) {
            const percent = Math.round(
              (progressEvent.loaded * 100) / progressEvent.total
            );
            options.onProgress(percent);
          }
        },
      }
    );

    return response.data;
  },
};

2. React Komponentida Ishlatish Namunasi (AbortController bilan)

Quyida foydalanuvchi fayllarni tanlaganda yuklash jarayonini boshlaydigan, real vaqtda progress ko'rsatadigan va istalgan vaqtda yuklashni bekor qiluvchi to'liq komponent keltirilgan:

// src/components/FileUploadComponent.tsx
import React, { useState, useRef } from 'react';
import axios from 'axios';
import { FileUploadService } from '../services/uploadService';

export const FileUploadComponent: React.FC = () => {
  const [progress, setProgress] = useState<number>(0);
  const [uploading, setUploading] = useState<boolean>(false);
  const [uploadedUrls, setUploadedUrls] = useState<string[]>([]);
  const [errorMessage, setErrorMessage] = useState<string | null>(null);

  // So'rovni bekor qilish uchun AbortController'ni ref'da saqlaymiz
  const abortControllerRef = useRef<AbortController | null>(null);

  const handleFileChange = async (e: React.ChangeEvent<HTMLInputElement>) => {
    const selectedFiles = e.target.files;
    if (!selectedFiles || selectedFiles.length === 0) return;

    const filesArray = Array.from(selectedFiles);

    // Yangi AbortController yaratamiz
    abortControllerRef.current = new AbortController();
    setUploading(true);
    setProgress(0);
    setErrorMessage(null);

    try {
      const result = await FileUploadService.uploadMultipleFiles(filesArray, {
        signal: abortControllerRef.current.signal,
        onProgress: (percent) => {
          setProgress(percent);
        },
      });

      setUploadedUrls(result.urls);
      alert('Fayllar muvaffaqiyatli yuklandi!');
    } catch (error: unknown) {
      // Axios'da bekor qilinganligini type-safe tekshirish
      if (axios.isCancel(error)) {
        console.log('Fayl yuklash foydalanuvchi tomonidan bekor qilindi.');
        setErrorMessage('Fayl yuklash to\'xtatildi.');
      } else if (error instanceof Error) {
        console.error('Xatolik:', error.message);
        setErrorMessage(error.message);
      }
    } finally {
      setUploading(false);
      abortControllerRef.current = null;
    }
  };

  const handleCancelUpload = () => {
    if (abortControllerRef.current) {
      // So'rovni darhol to'xtatamiz!
      abortControllerRef.current.abort();
    }
  };

  return (
    <div style={{ maxWidth: '450px', padding: '20px', border: '1px solid #ddd', borderRadius: '8px' }}>
      <h3>Fayllarni yuklash</h3>
      
      <input
        type="file"
        multiple
        onChange={handleFileChange}
        disabled={uploading}
        accept="image/png,image/jpeg,image/webp,application/pdf"
      />

      {uploading && (
        <div style={{ marginTop: '16px' }}>
          <p>Yuklanmoqda: <strong>{progress}%</strong></p>
          <progress value={progress} max="100" style={{ width: '100%', height: '10px' }} />
          <button
            onClick={handleCancelUpload}
            style={{
              marginTop: '10px',
              backgroundColor: '#dc3545',
              color: '#fff',
              border: 'none',
              padding: '6px 12px',
              borderRadius: '4px',
              cursor: 'pointer',
            }}
          >
            Yuklashni bekor qilish
          </button>
        </div>
      )}

      {errorMessage && (
        <p style={{ color: '#dc3545', marginTop: '12px' }}>{errorMessage}</p>
      )}

      {uploadedUrls.length > 0 && (
        <div style={{ marginTop: '16px' }}>
          <h4>Yuklangan fayllar:</h4>
          <ul>
            {uploadedUrls.map((url, idx) => (
              <li key={idx}>
                <a href={url} target="_blank" rel="noopener noreferrer">
                  Fayl {idx + 1}
                </a>
              </li>
            ))}
          </ul>
        </div>
      )}
    </div>
  );
};

3. Muhim Arxitekturaviy Qoidalar ⚠️

A. Client-Side Validatsiyaning ahamiyati

Serverga 100MB li yaroqsiz faylni yuborib, keyin serverdan 400 Bad Request kutish tarmoqni behuda band qiladi. Foydalanuvchi hajmi oshib ketgan faylni tanlagan zahoti brauzerda xato chiqarish foydalanuvchi tajribasini (UX) tez va yoqimli qiladi.

[!WARNING] Server-Side Validatsiyani hech qachon unutmang: Brauzerdagi tekshiruv faqat qulaylik va tezlik uchundir. Xakerlar brauzer validatsiyasini osongina chetlab o'tib so'rov jo'natishi mumkin. Backend server doimo fayl hajmi, kengaytmasi va haqiqiy binar tuzilishini (Magic Bytes) mustaqil tekshirishi shart.

B. onUploadProgress va total tekshiruvi

Ba'zi holatlarda server javobida yoki brauzerda progressEvent.total qiymati undefined bo'lib qolishi mumkin (masalan, fayl hajmi aniq bo'lmaganda). Shu sababli Math.round((progressEvent.loaded * 100) / progressEvent.total) hisoblashdan oldin doimo if (progressEvent.total) deb tekshirish tavsiya etiladi.

C. AbortController orqali xavfsiz to'xtatish

Katta hajmli fayllarni yuklashda foydalanuvchiga jarayonni bekor qilish imkoniyatini berish shart. Aks holda foydalanuvchi sahifani yopishga yoki internetni uzishga majbur bo'ladi.


4. Oddiy Fayl Yuklash vs Professional Servis Taqqoslovi

Mezon Oddiy Fayl Yuklash Professional FileUploadService
Fayl hajmi va formati Tekshirilmaydi (Server rad etadi) Brauzerdayoq tekshirilib, tezkor xato beriladi
Progress monitoringi Yo'q (foydalanuvchi qotib qoldi deb o'ylaydi) Foizli real vaqt ko'rsatkichi (onUploadProgress)
Yuklashni bekor qilish Mumkin emas AbortController orqali bir tugma bilan to'xtatiladi
Ko'p fayllar (Multiple) Qo'lda boshqarish qiyin Massiv orqali bir vaqtning o'zida yuboriladi
Xatolar tahlili Noma'lum xato axios.isCancel() orqali bekor qilish va boshqa xatolar ajratiladi

Xulosa

Fayllarni serverga yuklash — frontend va tarmoq o'rtasidagi eng og'ir operatsiyalardan biridir. Oldindan validatsiya qilish, onUploadProgress orqali foydalanuvchiga ma'lumot berish va AbortController orqali to'xtatish imkoniyatini taqdim etish orqali siz ilovangizda yuqori sifatli va ishonchli fayl almashinuv tizimini qurasiz.