APIRouter को साथ एक ठूलो app को कसरी संरचना गर्नुहुन्छ?

Question

Accepted Answer

**`APIRouter`** ले तपाईंलाई एक ठूलो FastAPI app लाई बहुविध modules मा विभाजित गर्न दिन्छ — प्रत्येक router सम्बन्धित endpoints (जस्तै सबै `/users` routes) को समूह बनाउँछ, र मुख्य app ले तिनलाई समावेश गर्छ। यो बढ्दो codebase लाई संगठित र कायम राख्नयोग्य राख्छ।

## Router लाई यसको आफ्नै module मा परिभाषित गर्दै

```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` एक mini-app जस्तै काम गर्छ — तपाई यसमा path operations लाई समान decorators को साथ परिभाषित गर्नुहुन्छ, र `prefix` ले तिनका सबैलाई लागु गर्छ।

## Main app मा routers लाई समावेश गर्दै

```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()` ले प्रत्येक router को endpoints लाई मुख्य app मा माउन्ट गर्छ — modular pieces बाट पूर्ण API लाई जोडीपन गर्दै।

## एक सामान्य project संरचना

```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
```

प्रत्येक feature/domain ले आफ्नो router module पाउँछ — सम्बन्धित routes र codebase लाई राम्रोसँग संगठित राख्दै।

## Router-स्तरीय dependencies र config

```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
```

Routers ले साझा dependencies (जस्तै एक पूरै routes समूहको लागि admin auth आवश्यक) लाई बहन गर्न सक्छन् — तिनका सबै endpoints मा एकै पटकमा लागु गरीन्छ।

## यो किन महत्त्वपूर्ण छ

`APIRouter` कुनै पनि तुच्छ FastAPI app भन्दा बढी कुरा निर्माण गर्नको लागि आवश्यक छ — यो बिना सबै endpoints एक file मा रहन्छन्, जो API बढ्दै जाँदा अप्रबन्धनीय हुन्छ।

यो बुझ्न महत्त्वपूर्ण छ **code organization र maintainability** को लागि: endpoints लाई feature-आधारित router modules (users, items, auth) मा विभाजित गर्नु ले सम्बन्धित code लाई एक ठाउँमा राख्छ, project लाई नेभिगेट गर्न योग्य बनाउँछ, र teams लाई विभिन्न क्षेत्रहरूमा स्वतन्त्रतापूर्वक काम गर्न दिन्छ।

`prefix` र `tags` ले routes र documentation लाई संगठित राख्छन्, र **router-स्तरीय dependencies** (जस्तै एक पूरै समूहको लागि admin auth आवश्यक) ले सफा, समूह-व्यापी व्यवहार प्रदान गर्छन्।

यो modular संरचना वास्तविक FastAPI applications को लागि मानक अभ्यास हो, `APIRouter` र यसको वरिपरि project-organization patterns लाई महत्त्वपूर्ण, व्यावहारिक-आवश्यक ज्ञान बनाउँछ scalable, maintainable APIs निर्माण गर्नको लागि।