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 ravishdabeforeLoadtekshiruvlarini 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<RouterContext>()"] -->|"1. Shartnoma o'rnatiladi"| Tree["Route Tree"]
App["App.tsx: useAuth() + queryClient"] -->|"2. Haqiqiy qiymatlar uzatiladi"| Provider["<RouterProvider context={...} />"]
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
createRouteryaratilayotganda 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
beforeLoadvaloaderfunksiyalariga yetkaziladi.