Seriya: TanStack Router Dars 38

Inherited route context — Parent context'ni child route'larda ishlatish

TanStack Router'da kontekst merosi: ota marshrutning beforeLoad orqali bola routelarga ma'lumot uzatish, takroriy so'rovlarni oldini olish va Type-safe ierarxiya.

38-dars

Inherited route context — Parent context'ni child route'larda ishlatish

Tasavvur qiling, siz katta korporativ biznes markazida filial ochyapsiz. Binoning bosh ofisi (/projects/$projectId) markaziy litsenziya, bino pasporti va asosiy loyiha shartnomasini (Project Data) bir marta qabul qilib oladi.

Ushbu filial ichida joylashgan buxgalteriya bo'limi (/settings), xodimlar bo'limi (/members) yoki tahlil guruhi (/analytics) har kuni shahar ma'muriyatiga borib loyiha shartnomasini alohida-alohida qaytadan so‘rab o‘tirmaydi. Bosh ofis o‘zidagi loyiha kontekstini barcha ichki bo‘limlarga avtomatik ravishda taqdim etadi.

TanStack Router ierarxik (daraxtsimon) arxitekturaga ega bo‘lgani sababli, har qanday ota marshrutning beforeLoad funksiyasidan qaytarilgan ma'lumotlar avtomatik ravishda uning barcha bola (child) marshrutlariga meros bo‘lib o‘tadi (Inherited Context).


1. Meros qilib olish mexanizmi qanday ishlaydi?

Loyihalar boshqaruvi tizimini misol sifatida olaylik. URL strukturasi quyidagicha tashkil topgan:

  • /projects/$projectId — Ota route: loyiha ma'lumotlarini yuklaydi va umumiy navigatsiya layoutini taqdim etadi.
  • /projects/$projectId/settings — Bola route: aynan shu loyihaning sozlamalari.
  • /projects/$projectId/members — Bola route: aynan shu loyihaning jamoa a'zolari.

Agar kontekst merosi bo‘lmasa, /settings sahifasiga kirilganda loyiha nomi va ID'sini olish uchun bitta so‘rov, sozlamalarni olish uchun ikkinchi so‘rov yuborilishi kerak bo‘lardi. TanStack Router’da esa ota route ma'lumotni bir marta tortadi va bolalariga ulashadi.

Ota Route: src/routes/projects/$projectId.tsx

// src/routes/projects/$projectId.tsx
import { createFileRoute, Outlet, Link, notFound } from '@tanstack/react-router'

interface Project {
  id: string
  name: string
  role: 'admin' | 'member'
}

export const Route = createFileRoute('/projects/$projectId')({
  // 1. beforeLoad orqali loyihani bir marta yuklaymiz
  beforeLoad: async ({ params }) => {
    const project = await fetchProjectById(params.projectId)
    
    if (!project) {
      throw notFound()
    }

    // 2. Qaytarilgan bu obyekt barcha bola routelar uchun context'ga aylanadi!
    return {
      project,
    }
  },

  component: ProjectLayout,
})

function ProjectLayout() {
  const { projectId } = Route.useParams()

  return (
    <div className="project-container">
      <header className="project-header">
        <h1>Loyiha boshqaruvi</h1>
        <nav className="tab-navigation">
          <Link to="/projects/$projectId/settings" params={{ projectId }}>
            Sozlamalar
          </Link>
          <Link to="/projects/$projectId/members" params={{ projectId }}>
            A'zolar
          </Link>
        </nav>
      </header>

      {/* 3. Outlet orqali bola komponentlar render qilinadi */}
      <main className="project-content">
        <Outlet />
      </main>
    </div>
  )
}

async function fetchProjectById(id: string): Promise<Project | null> {
  // Simulyatsiya qilingan API so'rovi
  return { id, name: 'SaaS Platform', role: 'admin' }
}

2. Bola Route'da Parent Context'ni qabul qilish

Bola route yaratilganda, uning beforeLoad, loader funksiyalarida hamda komponentlarida ota route'dan qaytarilgan project konteksti tayyor va 100% tiplangan holda turadi:

Bola Route: src/routes/projects/$projectId/settings.tsx

// src/routes/projects/$projectId/settings.tsx
import { createFileRoute } from '@tanstack/react-router'

export const Route = createFileRoute('/projects/$projectId/settings')({
  // 1. loader ichida ota route'dan meros bo'lib kelgan context tayyor!
  loader: async ({ context }) => {
    // context.project avtomatik mavjud va to'liq tiplangan!
    console.log("Joriy loyiha:", context.project.name)

    // Faqat sozlamalarni olish uchun so'rov jo'natamiz
    const settings = await fetchSettingsApi(context.project.id)

    return {
      settings,
    }
  },

  component: ProjectSettingsPage,
})

function ProjectSettingsPage() {
  // A. loader ma'lumotlarini olish
  const { settings } = Route.useLoaderData()

  // B. Ota route'dan meros qolgan kontekstni komponentda to'g'ridan-to'g'ri olish:
  const { project } = Route.useRouteContext()

  return (
    <div>
      <h2>{project.name} sozlamalari</h2>
      <p>Sizning huquqingiz: <strong>{project.role}</strong></p>
      <div>Bildirishnomalar: {settings.notifications ? 'Yoqilgan' : 'O\'chirilgan'}</div>
    </div>
  )
}

async function fetchSettingsApi(projectId: string) {
  return { notifications: true, theme: 'dark' }
}

[!TIP] Komponent ichida ota route'ning kontekstiga ehtiyoj tug'ilsa, qo‘shimcha props uzatish shart emas. Route.useRouteContext() hook'i joriy route'gacha yetib kelgan barcha birlashgan (merged) kontekstni qaytaradi.


3. Kontekstning qavatma-qavat birlashishi (Context Stacking)

TanStack Router'da kontekst yuqoridan pastga qarab oqadi va har bir bosqichda yangi ma'lumotlar bilan boyitiladi:

  1. Root Context: Ilovaning global obyektlari (queryClient, auth).
  2. Parent Route Context: Ma'lum bo'limga xos ma'lumotlar (project).
  3. Child Route Context: Bola route o‘z navbatida yana yangi kontekst qo‘shishi mumkin (permissions).
flowchart TD
    Root["Root Route: { queryClient, auth }"] --> Parent["Ota Route: /projects/$projectId"]
    
    subgraph ParentStage["Parent beforeLoad"]
        Parent --> PFetch["const project = fetchProject(id)"]
        PFetch --> PReturn["return { project }"]
    end

    PReturn --> Combined["Meros bo'lgan Context: { queryClient, auth, project }"]

    Combined --> Child1["Bola Route: /settings"]
    Combined --> Child2["Bola Route: /members"]

    Child1 --> L1["loader: ({ context }) => fetchSettings(context.project.id)"]
    Child2 --> L2["loader: ({ context }) => fetchMembers(context.project.id)"]

Ushbu ierarxiya orqali /settings yoki /members sahifasiga o‘tilganda, context ichida bir vaqtning o‘zida ham queryClient, ham auth, ham project mavjud bo‘ladi!


4. Meros qilib olishning asosiy afzalliklari

+-----------------------------------------------------------------------------------+
|                        INHERITED ROUTE CONTEXT AVZALLIKLARI                       |
+-----------------------------------------------------------------------------------+
| 1. Takroriy so'rovlar yo'qligi (Zero Duplicate Requests):                         |
|    Ota route ma'lumotni bir marta tortadi. Ichki tablar o'rtasida harakatlanganda |
|    loyiha qaytadan yuklanmaydi.                                                   |
|                                                                                   |
| 2. To'liq Type Safety zanjiri (End-to-End TypeScript):                            |
|    Parent beforeLoad qanday tur qaytarsa, Child context o'sha turni aniq taniydi.|
|                                                                                   |
| 3. Prop Drilling yo'qolishi (No Prop Drilling):                                   |
|    <Outlet context={...}> orqali noaniq tipli props tarqatish shart emas.        |
+-----------------------------------------------------------------------------------+
  1. Takroriy so‘rovlarning oldini olish (No Duplicate Requests): Foydalanuvchi /projects/12/settingsdan /projects/12/membersga o‘tganda, ota route qayta yuklanmaydi, faqat bola route'ning loader'i ishlaydi. Loyiha ma'lumotlari esa xotirada tayyor turadi.

  2. To‘liq Type Safety zanjiri: TypeScript ota route'ning beforeLoad funksiyasi nimani qaytarishini oldindan tahlil qiladi va bola route faylidagi ({ context }) argumentiga mos tiplarni avtomatik biriktiradi. Siz kod yozayotganda context. deb yozishingiz bilan barcha maydonlar avtomatik ko‘rinadi.

  3. Toza va barqaror arxitektura: Har bir komponent faqat o‘ziga tegishli vazifani bajaradi. Global Redux yoki Zustand store'lariga loyiha ID'si yoki holatini majburiy saqlashga ehtiyoj qolmaydi.


5. React Router va TanStack Router taqqosi

Xususiyat React Router (useOutletContext) TanStack Router (Inherited Route Context)
Kontekst qayerda uzatiladi? Faqat JSX komponentida (<Outlet context={...} />) Routing bosqichida (beforeLoad: () => ({ ... }))
loader ichida foydalanish ❌ Mumkin emas (Loader componentdan oldin ishlaydi) ✅ To‘liq qo‘llab-quvvatlanadi (loader: ({ context }) => ...)
Type-Safe kafolat ⚠️ Qo‘lda generic berish kerak (useOutletContext<Type>()) ✅ 100% avtomatik Type Inference
Qatlamli meros (Chaining) Bir nechta qatlamda chalkashib ketadi Yuqoridan pastga avtomatik birlashadi (Shallow merge)
Sahifaga kirishdan oldin tekshirish Komponent render bo‘lgandan keyin beforeLoadda yuklanishdan oldinoq amalga oshadi

Xulosa

  • Inherited Context — TanStack Router'da ota marshrutning beforeLoad funksiyasidan qaytgan ma'lumotlarning barcha bola routelarga avtomatik meros bo‘lib o‘tishidir.
  • Bola marshrutlar ota kontekstga o‘zlarining loader, beforeLoad va Route.useRouteContext() hook'i orqali kirish imkoniyatiga ega.
  • Bu yondashuv tarmoq so‘rovlarining takrorlanishini (duplicate requests) oldini oladi va dastur tezligini keskin oshiradi.
  • TypeScript butun ierarxiya bo‘ylab kontekst turlarini avtomatik tahlil qiladi va to‘liq xavfsizlikni kafolatlaydi.