როგორ სტრუქტურირებთ დიდ აპლიკაციას APIRouter-ის გამოყენებით?

Question

Accepted Answer

**`APIRouter`** საშუალებას გაძლევთ დიდი FastAPI აპლიკაციის დაყოფას რამდენიმე მოდულად — თითოეული როუტერი აჯგროვებს დაკავშირებული ენდპოინტებს (მაგ. ყველა `/users` მარშრუტი), და მთავარი აპლიკაცია მათ შედის. ეს ზრდაკადი კოდბეისის ორგანიზებული და შენარჩუნებადი შენახავს.

## როუტერის განსაზღვრა აქვსე მოდულში

```python
# routers/users.py
from fastapi import APIRouter

router = APIRouter(
    prefix="/users",          # all routes here start with /users
    tags=["users"],           # grouped under "users" in the docs
)

@router.get("/")              # GET /users/
def list_users(): ...

@router.get("/{user_id}")     # GET /users/{user_id}
def get_user(user_id: int): ...
```

`APIRouter` იმუშავებს მინი-აპლიკაციის მსგავსად — თქვენ განსაზღვრავთ path operations-ს იმავე დეკორატორებით, და `prefix` გამოიყენება ყველაზე.

## როუტერების შეყვანა მთავარ აპლიკაციაში

```python
# main.py
from fastapi import FastAPI
from routers import users, items, auth

app = FastAPI()
app.include_router(users.router)     # mounts /users/* endpoints
app.include_router(items.router)
app.include_router(auth.router)
```

`app.include_router()` აერთიანებს თითოეული როუტერის ენდპოინტებს მთავარ აპლიკაციაში — სრული API-ს აკრიფება მოდულური ნაწილებიდან.

## ტიპიური პროექტის სტრუქტურა

```text
app/
  main.py              # creates the app, includes routers
  routers/
    users.py           # APIRouter for /users
    items.py           # APIRouter for /items
    auth.py            # APIRouter for /auth
  models.py            # Pydantic models
  database.py          # DB setup
  dependencies.py      # shared dependencies
```

თითოეული ფიჩური/დომენი ღებულობს საკუთარ როუტერის მოდულს — დაკავშირებული მარშრუტების შენახვა და კოდბეის კარგი ორგანიზაციის უზრუნველყოფა.

## როუტერის დონის დამოკიდებულებები და კონფიგურაცია

```python
router = APIRouter(
    prefix="/admin",
    dependencies=[Depends(verify_admin)],   # apply a dependency to ALL routes in the router
)
# you can also nest routers via include_router on a router
```

როუტერებს შეუძლია გქონდეთ გაზიარებული დამოკიდებულებები (მაგ. მთელი ჯგუფი მარშრუტის ადმინის ავტორიზაციის მოთხოვნა) — გამოიყენება ყველა მათ ენდპოინტზე ერთდროულად.

## რატომ არის ეს მნიშვნელოვანი

`APIRouter` აუცილებელია რაიმე უფრო მსგავს FastAPI აპლიკაციის აგებისთვის — მის გარეშე, ყველა ენდპოინტი ერთ ფაილში იყოს, რაც ხელიდან გამოსვლილი ხდება API-ს ზრდასთან ერთად.

ამის გაგება მნიშვნელოვანია **კოდის ორგანიზაციისა და შენარჩუნებისთვის**: ენდპოინტების დაყოფა ფიჩურაზე დაფუძნებულ როუტერის მოდულებად (ხელმისაწვდომი, ელემენტები, ავტორიზაცია) ქმნის კოდის შესაბამის ნაწილებს ერთად, პროექტს გამოსაკითხი ხდის და გუნდებს საშუალებას აძლევს დამოუკიდებელი სამუშაოს შეასრულონ სხვადსხვა სფეროში.

`prefix` და `tags` მარშრუტებს და დოკუმენტაციას ორგანიზებენ, ხოლო **როუტერის დონის დამოკიდებულებები** (მაგ. მთელი ჯგუფის ადმინის ავტორიზაციის მოთხოვნა) სუფთა, ჯგუფის დონის ქცევას უზრუნველყოფენ.

ეს მოდულური სტრუქტურა სტანდარტული პრაქტიკაა რეალური FastAPI აპლიკაციებისთვის, რაც `APIRouter` და მის ირგვლივ პროექტის ორგანიზაციის ნიმუშებს აუცილებელ, პრაქტიკულად აუცილებელ ცოდნას აკეთებს მასშტაბური და შენარჩუნებადი API-ების აგებისთვის.