Series: Axios Lesson 79

Refresh Token Flow — Refresh token orqali access token yangilash

Axios Response Interceptor orqali Refresh Token oqimini yaratish: 401 Unauthorized handling, isRefreshing lock, failedQueue navbati va parallel so'rovlarni boshqarish.

79-dars

Refresh Token Flow — Refresh token orqali access token yangilash

Tasavvur qiling, foydalanuvchi tizimda ishlab turibdi va oradan 15 daqiqa o'tib uning Access Token muddati tugadi. U sahifada biror amalni bajarganda (masalan, "Saqlash" tugmasini bosganda), backend server tabiiy ravishda 401 Unauthorized xatosini qaytaradi.

Agar sodda va noto'g'ri yondashuv qo'llanilsa, foydalanuvchi darhol majburiy ravishda "Login" sahifasiga uloqtiriladi. Bu juda yomon foydalanuvchi tajribasiga (bad UX) olib keladi.

Professional arxitekturada Refresh Token Flow (Silent Refresh) bu vaziyatni sahna ortida, foydalanuvchiga umuman sezdirmasdan hal qiladi:

  1. So'rov 401 Unauthorized xatosi bilan qaytadi.
  2. Axios Response Interceptor bu xatoni tutib oladi va so'rovni vaqtincha muzlatib qo'yadi.
  3. Serverga yashirincha POST /auth/refresh so'rovi yuboriladi (Refresh Token HttpOnly Cookie orqali xavfsiz uzatiladi).
  4. Server yangi Access Token bergach, xotira (TokenManager) yangilanadi.
  5. Muzlatib turilgan dastlabki so'rov yangi token bilan avtomatik qaytadan yuboriladi (retry) va foydalanuvchi o'z ishini hech qanday uzilishsiz davom ettiradi.

1. Asosiy muammo: Parallel so'rovlar (Concurrent 401s)

Foydalanuvchi sahifani yangilaganda (refresh) yoki yangi sahifaga o'tganda bir vaqtning o'zida bir nechta API so'rovlari parallel ravishda yuboriladi (masalan: /users/me, /notifications va /cart).

Agar Access Token eskirgan bo'lsa, bu 3 ta so'rovning uchalasi ham deyarli bir vaqtda 401 xatosi bilan qaytib keladi.

[!CAUTION] Poyga holati (Race Condition) xavfi: Agar har bir 401 xatosi o'zboshimchalik bilan serverga alohida /auth/refresh so'rovini yuborsa:

  1. Serverga parallel ravishda 3 ta refresh so'rovi boradi.
  2. Agar backendda Refresh Token Rotation (RTR) yoqilgan bo'lsa, birinchi refresh so'rovidan so'ng qolgan ikkitasi eskirgan hisoblanib, server xavfsizlik maqsadida foydalanuvchining barcha sessiyalarini bekor qilib yuborishi mumkin!
  3. Server keraksiz yuklamaga uchraydi.

Yechim: isRefreshing qulfi va failedQueue navbati

Bizga ikkita asosiy boshqaruv mexanizmi kerak:

  1. isRefreshing bayrog'i (Flag): Bir vaqtning o'zida faqat va faqat bitta refresh so'rovi bajarilayotganini kafolatlaydi.
  2. failedQueue (Navbat): Refresh jarayoni ketayotgan paytda 401 olgan boshqa barcha so'rovlar navbatga qo'yiladi. Yangi token kelgach, ularning barchasiga yangi token berilib, bir vaqtning o'zida qayta yuboriladi.
sequenceDiagram
    autonumber
    participant UI as Sahifa / Komponentlar
    participant Interceptor as Axios Interceptor
    participant Queue as failedQueue (Navbat)
    participant Backend as Backend Server

    par Parallel So'rovlar
        UI->>Backend: So'rov A (/profile)
        UI->>Backend: So'rov B (/notifications)
    end
    Backend-->>Interceptor: So'rov A: 401 Unauthorized
    Backend-->>Interceptor: So'rov B: 401 Unauthorized
    
    Note over Interceptor: So'rov A keldi: isRefreshing = true
    Interceptor->>Backend: POST /auth/refresh (Yagona so'rov!)
    
    Note over Interceptor: So'rov B keldi: isRefreshing true bo'lgani uchun
    Interceptor->>Queue: So'rov B navbatga joylandi (Kutilmoqda...)
    
    Backend-->>Interceptor: 200 OK (Yangi Access Token)
    Note over Interceptor: TokenManager yangilandi
    Interceptor->>Queue: Navbatdagi so'rovlarni bo'shatish (processQueue)
    
    par Qayta yuborish (Retry)
        Interceptor->>Backend: So'rov A takrorlash (Yangi Token bilan)
        Queue->>Backend: So'rov B takrorlash (Yangi Token bilan)
    end
    
    Backend-->>UI: So'rov A natijasi (200 OK)
    Backend-->>UI: So'rov B natijasi (200 OK)

2. Amaliyot: Mukammal TypeScript va Axios Refresh Flow Arxitekturasi

Quyida real ishlab chiqarish (production) tizimlarida qo'llaniladigan barcha holatlarni inobatga olgan to'liq implementation keltirilgan:

// src/api/client.ts
import axios, { AxiosError, InternalAxiosRequestConfig } from 'axios';
import { TokenManager } from './tokenManager';

// 1. Axios konfiguratsiyasini maxsus maydonlar bilan kengaytiramiz
declare module 'axios' {
  export interface AxiosRequestConfig {
    skipAuth?: boolean;
    _retry?: boolean;
  }
}

interface CustomRequestConfig extends InternalAxiosRequestConfig {
  skipAuth?: boolean;
  _retry?: boolean;
}

// 2. Asosiy API mijozimiz
export const apiClient = axios.create({
  baseURL: 'https://api.mysite.com/v1',
  timeout: 10000,
  withCredentials: true, // HttpOnly Cookie'lar (Refresh Token) avtomatik yuborilishi uchun shart!
});

// Refresh jarayoni holatini boshqarish
let isRefreshing = false;

interface QueueItem {
  resolve: (token: string) => void;
  reject: (error: unknown) => void;
}

let failedQueue: QueueItem[] = [];

// Navbatdagi barcha so'rovlarni birgalikda hal qilish (resolve yoki reject)
const processQueue = (error: unknown, token: string | null = null): void => {
  failedQueue.forEach((promise) => {
    if (error) {
      promise.reject(error);
    } else if (token) {
      promise.resolve(token);
    }
  });

  failedQueue = [];
};

// 3. REQUEST INTERCEPTOR: Har bir so'rovga mavjud tokenni biriktirish
apiClient.interceptors.request.use(
  (config: CustomRequestConfig) => {
    if (config.skipAuth) {
      return config;
    }

    const token = TokenManager.getToken();
    if (token) {
      config.headers.Authorization = `Bearer ${token}`;
    }

    return config;
  },
  (error) => Promise.reject(error)
);

// 4. RESPONSE INTERCEPTOR: 401 xatolarini ushlash va Silent Refresh
apiClient.interceptors.response.use(
  (response) => response,
  async (error: AxiosError) => {
    const originalRequest = error.config as CustomRequestConfig | undefined;

    // Agar so'rov konfiguratsiyasi mavjud bo'lmasa, xatoni darhol qaytaramiz
    if (!originalRequest) {
      return Promise.reject(error);
    }

    // Xato 401 (Unauthorized) bo'lsa va bu so'rov hali qayta urinilmagan bo'lsa:
    if (error.response?.status === 401 && !originalRequest._retry) {
      
      // Cheksiz halqaning (infinite loop) oldini olish:
      // Agar 401 bergan so'rovning o'zi /auth/refresh bo'lsa, demak Refresh Token ham eskirgan!
      if (originalRequest.url?.includes('/auth/refresh')) {
        TokenManager.clearToken();
        window.location.href = '/login';
        return Promise.reject(error);
      }

      // Agar ayni paytda boshqa bir parallel so'rov tokenni yangilayotgan bo'lsa:
      if (isRefreshing) {
        return new Promise<string>((resolve, reject) => {
          failedQueue.push({ resolve, reject });
        })
          .then((newToken) => {
            originalRequest.headers.Authorization = `Bearer ${newToken}`;
            return apiClient(originalRequest);
          })
          .catch((err) => Promise.reject(err));
      }

      // Birinchi kelgan 401 so'rovi mas'uliyatni o'z zimmasiga oladi
      originalRequest._retry = true;
      isRefreshing = true;

      try {
        // Yangi Access Token olish uchun alohida toza axios so'rovi yuboramiz
        // Muhim: apiClient emas, standart axios ishlatiladi (rekursiv interceptor oldini olish uchun)
        const response = await axios.post<{ accessToken: string }>(
          'https://api.mysite.com/v1/auth/refresh',
          {},
          { withCredentials: true }
        );

        const newAccessToken = response.data.accessToken;

        // Xotiradagi tokenni yangilaymiz
        TokenManager.setToken(newAccessToken);

        // Navbatda kutib turgan barcha parallel so'rovlarga yangi tokenni tarqatamiz
        processQueue(null, newAccessToken);

        // Asl muvaffaqiyatsiz so'rovning sarlavhasini yangilab, qayta yuboramiz
        originalRequest.headers.Authorization = `Bearer ${newAccessToken}`;
        return apiClient(originalRequest);

      } catch (refreshError) {
        // Agar Refresh Token ham eskirgan bo'lsa yoki server uni rad etsa:
        processQueue(refreshError, null);
        TokenManager.clearToken();

        // Foydalanuvchini login sahifasiga xavfsiz yo'naltiramiz
        window.location.href = '/login';

        return Promise.reject(refreshError);
      } finally {
        isRefreshing = false;
      }
    }

    return Promise.reject(error);
  }
);

3. Kodning muhim qismlari va nozik jihatlari

A. Cheksiz rekursiyani oldini olish (_retry flagi)

Agar server yangi token bergandan keyin ham qandaydir sabab bilan yana 401 qaytarsa, ilova cheksiz siklga (infinite loop) tushib qolmasligi uchun originalRequest._retry = true belgisi qo'yiladi. Ikkinchi marta 401 qaytsa, kod uni qayta ushlamaydi.

B. Alohida axios.post chaqiruvi

Refresh so'rovini yuborayotganda apiClient.post() emas, balki toza axios.post() chaqiriladi:

[!NOTE] Agar apiClient.post('/auth/refresh') qilinsa, uning xatosi yana o'sha Response Interceptor'ga tushib, chalkashlik keltirib chiqarishi mumkin. Mustaqil chaqiruv xavfsizroqdir.

C. Navbatdagi so'rovlarni kutish (new Promise)

Parallel kelgan so'rovlar darhol rad etilmaydi yoki qayta yuborilmaydi; ular new Promise((resolve, reject) => failedQueue.push({ resolve, reject })) orqali to'xtatib turiladi. Yangi token olingach, resolve(newToken) chaqirilib, zanjir bo'yicha apiClient(originalRequest) takrorlanadi.


4. Ushbu arxitekturaning afzalliklari

  1. To'liq avtomatizatsiya (Zero UI Interruption): Foydalanuvchi seansining qachon yangilangani sezilmaydi — u ekranda hech qanday qotish yoki qayta yuklanishsiz ishlashda davom etadi.
  2. Concurrency Safety (Parallel xavfsizlik): isRefreshing va failedQueue tandemi tufayli bir vaqtning o'zida o'nlab parallel so'rov kelsa ham, serverga bor-yo'g'i 1 dona refresh so'rovi yuboriladi.
  3. Graceful Logout (Chiroyli chiqish): Refresh Tokenning ham muddati o'tib ketgan bo'lsa (masalan, foydalanuvchi ilovaga 15 kundan keyin kirgan bo'lsa), xotira tozalanib, foydalanuvchi tinchgina /login sahifasiga yo'naltiriladi.

Xulosa

Refresh Token Flow — har qanday jiddiy va professional frontend ilovaning tayanch ustunlaridan biridir. Axios'ning Response Interceptor, Promise Queue va Flags imkoniyatlari yordamida nafaqat xavfsiz autentifikatsiya tizimini, balki foydalanuvchi uchun mutlaqo sezilarsiz va qulay tajribani shakllantirish mumkin.