Seriya: TanStack Router Dars 64

Router context + API client — API client'ni route context orqali uzatish

TanStack Router'da Dependency Injection: API client'ni route context orqali uzatish, mocking va testlash qulayligi, SSR xavfsizligi va React Router bilan taqqos.

64-dars

Router context + API client — API client'ni route context orqali uzatish

Katta va professional loyihalarda har bir marshrut fayli ichida global API obyektini to‘g‘ridan-to‘g‘ri import qilish (import { apiClient } from '@/api/client') arxitekturaviy jihatdan tavsiya etilmaydi (Anti-pattern).

Chunki:

  1. Test yozish qiyinlashadi: Unit testlarda haqiqiy serverga so‘rov ketmasligi uchun murakkab module-mocking qilishga to‘g‘ri keladi.
  2. SSR va Ko‘p foydalanuvchilik (Multi-tenancy) muammolari: Serverda har bir foydalanuvchining o‘z sessiyasi, tokoni va cookielari bo‘ladi. Global singleton obyekt esa xotirada aralashib, xavfsizlik zaifligini keltirib chiqarishi mumkin.

TanStack Router bu muammoni Dependency Injection (Qaramliklarni inyeksiya qilish) usuli orqali hal qiladi: apiClient router kontekstiga bir marta kiritiladi va barcha loaderlarga xavfsiz yetkaziladi.


1. Hayotiy o‘xshatish: Restoran xodimlari va Markaziy planshet

Tasavvur qiling, siz yirik restoran tarmog‘ini boshqaryapsiz:

  • Eski usul (Global import): Har bir ofitsiant o‘z cho‘ntagida shaxsiy pos-terminal olib yuradi. Agar bank tizimi o‘zgarsa, 100 ta ofitsiantning terminalini birma-bir qayta sozlash kerak. Yangi ishga kirgan amaliyotchiga esa haqiqiy pul yechadigan terminal berib qo‘yish xavfli!
  • Dependency Injection (Router Context): Restoranning markaziy boshqaruvi (Root Route Context) har bir ofitsiantga yagona standartlashtirilgan xizmat planshetini (apiClient) taqdim etadi. Bank shartlari o‘zgarsa — faqat bitta markaziy sozlama yangilanadi. Sinov vaqtida esa amaliyotchilarga haqiqiy pul bilan ishlamaydigan o‘quv terminali (Mock API) beriladi.

2. Qadam-baqadam to‘liq implementatsiya

Keling, API Client yaratishdan tortib, uni route loader'larida qabul qilishgacha bo‘lgan to‘liq jarayonni ko‘rib chiqamiz:

1-qadam: API Client shartnomasini (Interface) tuzish

// src/api/client.ts
export interface Post {
  id: string
  title: string
  content: string
}

export interface ApiClient {
  getPosts: () => Promise<Post[]>
  getPostById: (id: string) => Promise<Post>
  createPost: (data: { title: string; content: string }) => Promise<Post>
}

// Haqiqiy tarmoq bilan ishlovchi client
export const apiClient: ApiClient = {
  getPosts: async () => {
    const res = await fetch('https://api.example.com/posts')
    if (!res.ok) throw new Error('Maqolalarni yuklab bo‘lmadi')
    return res.json()
  },

  getPostById: async (id: string) => {
    const res = await fetch(`https://api.example.com/posts/${id}`)
    if (!res.ok) throw new Error('Maqola topilmadi')
    return res.json()
  },

  createPost: async (data) => {
    const res = await fetch('https://api.example.com/posts', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(data),
    })
    return res.json()
  },
}

2-qadam: Root Route kontekstini sozlash

src/routes/__root.tsx faylida router konteksti ichiga apiClient turini kiritamiz:

// src/routes/__root.tsx
import { createRootRouteWithContext, Outlet } from '@tanstack/react-router'
import type { ApiClient } from '../api/client'

// 1. Router kontekstining TypeScript shartnomasi
export interface RouterContext {
  apiClient: ApiClient
}

// 2. Root route'ni shu kontekst bilan bog'laymiz
export const Route = createRootRouteWithContext<RouterContext>()({
  component: () => (
    <div className="layout">
      <header>Mening Ilovam</header>
      <main>
        <Outlet />
      </main>
    </div>
  ),
})

3-qadam: Router yaratishda apiClientni taqdim etish

Router instansiyasi yaratilayotganda haqiqiy apiClient obyektini kontekstga uzatamiz:

// src/router.tsx
import { createRouter } from '@tanstack/react-router'
import { routeTree } from './routeTree.gen'
import { apiClient } from './api/client'

export const router = createRouter({
  routeTree,
  // Contextual Dependency Injection:
  context: {
    apiClient,
  },
})

4-qadam: Route Loader ichida to‘liq tiplangan foydalanish

Endi ilovaning istalgan burchagidagi route'da hech qanday global faylni import qilmasdan, to‘g‘ridan-to‘g‘ri context.apiClient orqali ma'lumotlarni tortib olamiz:

// src/routes/posts/index.tsx
import { createFileRoute } from '@tanstack/react-router'

export const Route = createFileRoute('/posts/')({
  // context ichida apiClient tayyor va 100% tiplangan!
  loader: async ({ context }) => {
    return context.apiClient.getPosts()
  },

  component: PostsListPage,
})

function PostsListPage() {
  const posts = Route.useLoaderData()

  return (
    <div className="posts-page">
      <h1>Maqolalar</h1>
      <ul>
        {posts.map((post) => (
          <li key={post.id}>{post.title}</li>
        ))}
      </ul>
    </div>
  )
}

3. Dependency Injection arxitekturasi va Testlash (Mermaid Diagram)

flowchart TD
    Contract["ApiClient Interfeysi (Shartnoma)"] --> Production["Haqiqiy apiClient (fetch / axios)"]
    Contract --> Testing["Soxta mockApiClient (In-Memory test data)"]

    Production --> RouterProd["Asosiy Ilova Routeri: context: { apiClient }"]
    Testing --> RouterTest["Test Runner Routeri: context: { mockApiClient }"]

    RouterProd & RouterTest --> RouteTree["Route Daraxti: loader: ({ context }) => context.apiClient.getPosts()"]
    
    RouteTree --> Result["Marshrut kodi o'zgarmaydi! Har ikkala holatda mukammal ishlaydi."]

4. Nima uchun bu yondashuv Oltin Standart?

+-----------------------------------------------------------------------------------+
|                           DEPENDENCY INJECTION USTUNLIKLARI                       |
+-----------------------------------------------------------------------------------+
| 1. Oson Unit va E2E Testlash:                                                     |
|    Router'ga haqiqiy API o'rniga soxta mockClient uzatish kifoya.                 |
|                                                                                   |
| 2. Markazlashgan Token va Avtorizatsiya:                                          |
|    Foydalanuvchi tizimga kirganda tokenni yangilash barcha loader'larga bir zumda|
|    ta'sir qiladi.                                                                 |
|                                                                                   |
| 3. SSR Xavfsizligi (No State Leak):                                               |
|    Har bir server so'rovi uchun shaxsiy apiClient yaratilib, ma'lumotlar          |
|    boshqa foydalanuvchilar bilan aralashib ketmaydi.                              |
+-----------------------------------------------------------------------------------+

5. Global Import vs Router Context taqqosi

Mezon To‘g‘ridan-to‘g‘ri import { api } Router Context (context.apiClient)
Bog‘liqlik (Coupling) Qattiq bog‘langan (Tight Coupling) Erkin va moslashuvchan (Loose Coupling)
Testlash (Mocking) jest.mock() yoki fayl tizimini buzish kerak Oddiygina context: { apiClient: mockApi } beriladi
SSR / Multi-tenant ❌ Xavfli (Session va Tokenlar aralashib ketadi) ✅ Har bir HTTP so‘rovi uchun izolyatsiyalangan
Type-Safe Autocomplete Mavjud Router darajasida 100% kafolatlangan

Xulosa

  • Har bir faylda global API klientini to‘g‘ridan-to‘g‘ri import qilish testlashni qiyinlashtiradi va SSR xavfsizligiga putur yetkazadi.
  • TanStack Router’da createRootRouteWithContext orqali apiClientni markaziy Dependency Injection tizimiga aylantirish tavsiya etiladi.
  • Barcha loader va beforeLoad funksiyalari o‘zlarining context.apiClient argumenti orqali to‘liq tiplangan metodlarga ega bo‘ladi.
  • Bu yondashuv kodni modulli, testlarga oson moslashuvchan va yuqori darajada xavfsiz qiladi.