FastAPI میں request lifecycle کیسے کام کرتا ہے؟

Question

IT Interview Practice · Accepted Answer

FastAPI **ASGI** پر چلتا ہے، اس لیے ایک request ایک async pipeline سے گزرتی ہے: ASGI server اسے قبول کرتا ہے، middleware اسے لپیٹتا ہے، router ایک path کو میچ کرتا ہے، **dependencies حل ہوتی ہیں**، آپ کا path operation چلتا ہے، اور return ہونے والی value کو response میں serialize کیا جاتا ہے۔

## مراحل

```
uvicorn (ASGI server)
   │  scope + receive/send
   ▼
ASGI / Starlette middleware  ── (CORS, GZip, custom)
   ▼
Routing  ── method + path میچ کریں → path operation
   ▼
Dependencies (Depends)  ── sub-deps, security, yield-setup حل کریں
   ▼
Path operation function  ── آپ کا handler چلتا ہے
   ▼
Response model  ── validate + JSON میں serialize کریں
   ▼
Background tasks  ── response بھیجنے کے بعد چلتا ہے
   ▼
Response ──▶ client
```

1. **ASGI server** (uvicorn/hypercorn) کنکشن قبول کرتا ہے اور app کو ایک `scope` کے ساتھ `receive`/`send` callable بھیجتا ہے۔
2. **Middleware** اندر جاتے وقت باہر-سے-اندر اور باہر آتے وقت اندر-سے-باہر چلتا ہے (`BaseHTTPMiddleware` یا خالص ASGI middleware)۔ CORS, GZip، اور custom timing یہاں رہتے ہیں۔
3. **Routing** HTTP method + path کو ایک path operation سے میچ کرتا ہے؛ path/query/body parameters کو **Pydantic** کے ذریعے نکالا اور validate کیا جاتا ہے۔
4. **Dependency injection** — `Depends(...)` ہر dependency (DB session، موجودہ user، settings) کو حل کرتا ہے اور request کے اندر cache کرتا ہے۔ `yield` والی dependency handler سے پہلے setup اور بعد میں teardown چلاتی ہے۔
5. **Path operation** — آپ کا `async def` (یا threadpool میں چلنے والا `def`) business logic کو execute کرتا ہے۔
6. **Response** — return ہونے والی value کو اعلان کردہ `response_model` میں تبدیل کیا جاتا ہے، validate کیا جاتا ہے، اور JSON میں serialize کیا جاتا ہے؛ status code اور headers لاگو ہوتے ہیں۔
7. **Background tasks** جو `BackgroundTasks` کے ذریعے رجسٹر ہوتے ہیں، response بھیجے جانے کے *بعد* چلتے ہیں۔

```python
from fastapi import FastAPI, Depends, Request

app = FastAPI()

@app.middleware("http")
async def timing(request: Request, call_next):   # 2. middleware
    response = await call_next(request)
    response.headers["X-Time"] = "..."
    return response

async def get_db():                               # 4. dependency (yield)
    db = Session()
    try:
        yield db
    finally:
        db.close()

@app.get("/items/{id}")                           # 3. routing
async def read_item(id: int, db=Depends(get_db)): # 5. handler
    return db.get(Item, id)                        # 6. response_model کے ذریعے serialize کیا جاتا ہے
```

استثناءات (exceptions) کو **exception handlers** (`@app.exception_handler(...)` / `HTTPException`) پکڑتے ہیں، جو انہیں request کو crash کرنے کے بجائے responses میں تبدیل کر دیتے ہیں۔

## یہ کیوں اہم ہے

request lifecycle وہ جگہ ہے جہاں FastAPI کی نمایاں خصوصیات دراصل واقع ہوتی ہیں: async I/O، Pydantic validation، اور dependency injection سب مخصوص مراحل میں جُڑتے ہیں۔ ترتیب کو جاننا — middleware، پھر routing، پھر dependencies، پھر handler، پھر serialization — آپ کو cross-cutting logic کو صحیح جگہ رکھنے دیتا ہے (auth بطور dependency، timing بطور middleware، cleanup ایک `yield` dependency میں)، یہ debug کرنے دیتا ہے کہ آپ کے code چلنے سے پہلے کوئی validation یا auth error کیوں چلتی ہے، اور ایک async handler کے اندر event loop کو block کرنے سے بچاتا ہے۔

مراحل

یہ کیوں اہم ہے

متعلقہ سوالات