Seriya: TanStack Router Dars 39

createRootRouteWithContext — Type-safe root context

TanStack Router'da createRootRouteWithContext: global kontekst uchun qat'iy TypeScript shartnomasi, Dependency Injection, dinamik RouterProvider context va React Router bilan taqqos.

39-dars

createRootRouteWithContext — Type-safe root context

Tasavvur qiling, siz zamonaviy ko‘p qavatli bino qurilishining bosh muhandisisiz. Oddiy bino poydevorida (createRootRoute) qanday kommunikatsiya tarmoqlari (yuqori kuchlanishli elektr, suv, optik tolali internet) ulanishi aniq yozilmagan bo‘lsa, har bir xonadonda chiroq yonadimi yoki yo‘qmi — noaniq qoladi.

createRootRouteWithContext esa qat'iy davlat standarti va shartnomasi: u poydevor qo‘yilayotgandayoq binoning har bir xonasi uchun majburiy bo‘lgan barcha muhandislik tarmoqlarining TypeScript spetsifikatsiyasini belgilab beradi. Agar quruvchi (createRouter) biron bir tarmoqni (masalan, auth yoki queryClient) ulashni unutib qoldirsa, texnik nazorat (TypeScript) binoni qabul qilmaydi va dastur ishga tushmaydi.


1. Oddiy createRootRoute va createRootRouteWithContext farqi

Oddiy createRootRoute() yordamida root route yaratganingizda, router ichiga tashqaridan qanday global xizmatlar uzatilishini TypeScript bila olmaydi:

// ❌ Muammoli yondashuv:
export const Route = createRootRoute({
  component: RootComponent,
})

// Boshqa fayldagi bola route:
export const Route = createFileRoute('/dashboard')({
  beforeLoad: ({ context }) => {
    // TypeScript context ichida nima borligini bilmaydi (context: {})
    // context.auth -> Property 'auth' does not exist on type '{}'
  }
})

createRootRouteWithContext<MyContext>()() esa global kontekstning turlarini (types) butun router daraxti uchun qat'iy standart sifatida ro‘yxatga oladi.


2. Qadam-baqadam to‘liq arxitektura

Keling, real loyihalarda eng ko‘p uchraydigan holatni ko‘rib chiqamiz: ilovaga TanStack Query (queryClient) va Autentifikatsiya holatini (auth) global kontekst sifatida kiritish.

1-qadam: Root faylida Kontekst interfeysini e'lon qilish

Root faylida barcha sahifalar uchun zarur bo‘lgan xizmatlar turini belgilaymiz:

// src/routes/__root.tsx
import { createRootRouteWithContext, Outlet, Link } from '@tanstack/react-router'
import type { QueryClient } from '@tanstack/react-query'

// 1. Global kontekst shartnomasi (Interface)
export interface RouterContext {
  queryClient: QueryClient
  auth: {
    isAuthenticated: boolean
    user: { id: string; email: string; name: string } | null
  }
}

// 2. createRootRouteWithContext orqali root route yaratamiz
export const Route = createRootRouteWithContext<RouterContext>()({
  component: RootLayout,
})

function RootLayout() {
  return (
    <div className="layout">
      <header className="navbar">
        <Link to="/">Bosh sahifa</Link>
        <Link to="/dashboard">Dashboard</Link>
      </header>
      <main>
        {/* Barcha ichki marshrutlar shu yerda chiqadi */}
        <Outlet />
      </main>
    </div>
  )
}

2-qadam: Router yaratish va kontekstni taqdim etish

Router instansiyasi yaratilayotganda createRootRouteWithContext talab qilgan barcha obyektlar kiritilishi shart:

// src/router.tsx
import { createRouter } from '@tanstack/react-router'
import { QueryClient } from '@tanstack/react-query'
import { routeTree } from './routeTree.gen'

export const queryClient = new QueryClient()

// 3. Router instansiyasini hosil qilamiz
export const router = createRouter({
  routeTree,
  // TypeScript RouterContext shartnomasini qat'iy tekshiradi:
  context: {
    queryClient,
    auth: {
      isAuthenticated: false,
      user: null,
    },
  },
})

// Type declaration orqali type-safe navigatsiyani ro'yxatga olamiz
declare module '@tanstack/react-router' {
  interface Register {
    router: typeof router
  }
}

3-qadam: React komponenti ichida dinamik kontekst uzatish

Haqiqiy loyihalarda foydalanuvchi tizimga kirganida yoki chiqqanida auth holati o‘zgaradi. <RouterProvider> komponenti orqali yangilangan kontekstni uzatish mumkin:

// src/App.tsx
import { RouterProvider } from '@tanstack/react-router'
import { QueryClientProvider } from '@tanstack/react-query'
import { router, queryClient } from './router'
import { useAuth } from './hooks/useAuth'

export function App() {
  const auth = useAuth() // { isAuthenticated, user, login, logout }

  return (
    <QueryClientProvider client={queryClient}>
      {/* auth holati o'zgarganda router butun daraxtni xabardor qiladi */}
      <RouterProvider 
        router={router} 
        context={{
          queryClient,
          auth,
        }} 
      />
    </QueryClientProvider>
  )
}

[!TIP] <RouterProvider router={router} context={{ ... }} /> ga yangi qiymat uzatilganda, TanStack Router avtomatik ravishda beforeLoad tekshiruvlarini qaytadan ishga tushiradi. Agar foydalanuvchi tizimdan chiqsa (logout), u darhol himoyalangan sahifadan chiqarib yuboriladi!


3. Bola routelarda kontekstdan foydalanish

Endi ilovangizning istalgan faylidagi bola route (src/routes/dashboard.tsx) ichida ushbu kontekstdan to‘liq xavfsiz foydalanish mumkin:

// src/routes/dashboard.tsx
import { createFileRoute, redirect } from '@tanstack/react-router'

export const Route = createFileRoute('/dashboard')({
  // 1. Himoya: beforeLoad ichida context.auth mavjud va tiplangan!
  beforeLoad: ({ context }) => {
    if (!context.auth.isAuthenticated) {
      throw redirect({
        to: '/login',
        search: { redirect: '/dashboard' },
      })
    }
  },

  // 2. Ma'lumot yuklash: loader ichida context.queryClient mavjud!
  loader: async ({ context }) => {
    return context.queryClient.ensureQueryData({
      queryKey: ['user-profile', context.auth.user?.id],
      queryFn: () => fetchUserProfile(context.auth.user!.id),
    })
  },

  component: DashboardPage,
})

function DashboardPage() {
  const { user } = Route.useRouteContext().auth

  return (
    <div>
      <h1>Xush kelibsiz, {user?.name}!</h1>
      <p>Email: {user?.email}</p>
    </div>
  )
}

async function fetchUserProfile(userId: string) {
  return { lastLogin: new Date().toISOString() }
}

4. Kontekst oqimi va Dependency Injection (Mermaid Diagram)

flowchart TD
    Contract["createRootRouteWithContext&lt;RouterContext&gt;()"] -->|"1. Shartnoma o'rnatiladi"| Tree["Route Tree"]

    App["App.tsx: useAuth() + queryClient"] -->|"2. Haqiqiy qiymatlar uzatiladi"| Provider["&lt;RouterProvider context={...} /&gt;"]

    Provider -->|"3. Type-Safe Context oqimi"| Tree

    Tree --> Child1["beforeLoad: ({ context }) -> auth tekshiruvi"]
    Tree --> Child2["loader: ({ context }) -> queryClient.ensureQueryData()"]
    Tree --> Child3["UI: Route.useRouteContext() -> user ma'lumotlari"]

5. Nima uchun bu arxitektura juda muhim?

+-----------------------------------------------------------------------------------+
|               createRootRouteWithContext NIMA UCHUN FOYDALI?                      |
+-----------------------------------------------------------------------------------+
| 1. Qat'iy Shartnoma (Strict Compile-Time Contract):                               |
|    Router yaratilayotganda barcha zarur xizmatlar berilgani kafolatlanadi.        |
|                                                                                   |
| 2. To'liq Autocomplete va Type Safety:                                            |
|    Ixtiyoriy route ichida context deb yozish bilan barcha metodlar ko'rinadi.     |
|                                                                                   |
| 3. Haqiqiy Dependency Injection (DI):                                             |
|    Global o'zgaruvchilarni to'g'ridan-to'g'ri import qilish o'rniga router        |
|    orqali markazlashgan boshqaruv.                                                |
|                                                                                   |
| 4. Testlash osonligi (Mockability):                                               |
|    Unit testlarda soxta (mock) queryClient yoki auth uzatish juda oson.           |
+-----------------------------------------------------------------------------------+

6. React Router va TanStack Router taqqosi

Xususiyat React Router TanStack Router (createRootRouteWithContext)
Global kontekst tipi ❌ Tizim darajasida yo‘q ✅ RouterContext orqali to‘liq tiplangan
Dependency Injection ❌ Faqat React UI darajasida (<Context.Provider>) ✅ Routing darajasida (Router darajasidagi DI)
Loader ichida xizmatlar ⚠️ Global singleton faylni to‘g‘ridan-to‘g‘ri import qilish kerak ✅ loader: ({ context }) => ... orqali toza inyeksiya
Testlash (Testing & Mocking) Qiyin, global importlarni mock qilish talab etiladi Juda oson, test routeriga soxta context berish kifoya
Dinamik yangilanish Router tashqarisida qayta re-render orqali <RouterProvider context={...} /> orqali avtomatik re-validation

Xulosa

  • createRootRouteWithContext — butun ilovaning marshrutlar daraxti uchun global kontekst turlarini belgilovchi maxsus funksiya.
  • U createRouter yaratilayotganda kontekstning to‘liq va to‘g‘ri taqdim etilishini TypeScript darajasida majburiy qiladi.
  • Dinamik holatlarni boshqarish uchun <RouterProvider context={...} /> orqali yangilangan kontekst obyektini uzatish mumkin.
  • Bu mexanizm orqali React Query, autentifikatsiya va boshqa xizmatlar sahifa render bo‘lishidan oldinroq beforeLoad va loader funksiyalariga yetkaziladi.