APIRouter-ஐக் கொண்டு ஒரு பெரிய app-ஐ எவ்வாறு structure செய்வது?

Question

Accepted Answer

**`APIRouter`** ஒரு பெரிய FastAPI app-ஐ பல modules-ஆகப் பிரிக்க உங்களை அனுமதிக்கிறது — ஒவ்வொரு router-ம் தொடர்புடைய endpoints-ஐ (எ.கா. எல்லா `/users` routes) குழுவாக்குகிறது, மற்றும் main app அவற்றை சேர்க்கிறது. இது வளரும் codebase-ஐ ஒழுங்காகவும் maintainable-ஆகவும் வைத்திருக்கிறது.

## அதன் சொந்த module-இல் ஒரு router-ஐ வரையறுத்தல்

```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 போல செயல்படுகிறது — அதே decorators-ஐக் கொண்டு அதில் path operations-ஐ வரையறுக்கிறீர்கள், மேலும் ஒரு `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-ஐயும் main app-இல் mount செய்கிறது — modular துண்டுகளிலிருந்து முழு API-ஐயும் கூட்டமைக்கிறது.

## ஒரு வழக்கமான project structure

```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-level 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-ஐ navigate செய்யக்கூடியதாக ஆக்குகிறது, மேலும் teams-ஐ வெவ்வேறு பகுதிகளில் சுயாதீனமாக வேலை செய்ய அனுமதிக்கிறது.

`prefix` மற்றும் `tags` routes மற்றும் documentation-ஐ ஒழுங்காக வைத்திருக்கின்றன, மேலும் **router-level dependencies** (ஒரு முழு குழுவிற்கும் admin auth தேவைப்படுவது போல) சுத்தமான, group-wide behavior-ஐ வழங்குகின்றன.

இந்த modular structure உண்மையான FastAPI applications-க்கான standard நடைமுறையாகும், இது `APIRouter` மற்றும் அதைச் சுற்றியுள்ள project-organization patterns-ஐ scalable, maintainable APIs-ஐ உருவாக்குவதற்கான முக்கியமான, நடைமுறையில் அவசியமான அறிவாக மாற்றுகிறது.