FastAPI کون سے اعلیٰ dependency patterns کو سپورٹ کرتا ہے؟

Question

Accepted Answer

بنیادی `Depends` سے آگے، FastAPI کا dependency injection اعلیٰ patterns کو سپورٹ کرتا ہے: **sub-dependencies**، **dependencies with parameters** (class-based یا factories کے ذریعے)، **scoped resources** (yield)، **global/router dependencies**، اور **dependency overrides** testing کے لیے — یہ اسے حقیقی applications کو structured کرنے کے لیے ایک ورسٹائل ٹول بناتے ہیں۔

## Sub-dependencies (dependency trees)

```python
def get_token(authorization: str = Header()):
    return parse(authorization)

def get_current_user(token: str = Depends(get_token)):   # depends on another dependency
    return decode(token)

def get_admin(user: User = Depends(get_current_user)):    # depends on that, in turn
    if not user.is_admin: raise HTTPException(403)
    return user
# FastAPI resolves the whole chain, caching shared dependencies within a request
```

Dependencies دوسری dependencies پر منحصر ہو سکتی ہیں، ایک tree بناتے ہوئے جسے FastAPI خودکار طور پر resolve کرتا ہے (اور **caches** shared ones کو فی request، تو `get_token` ایک بار چلتا ہے یہاں تک کہ اگر کئی dependencies میں استعمال ہو)۔

## Parameterized (class-based) dependencies

```python
class RateLimiter:
    def __init__(self, calls: int):        # configure the dependency
        self.calls = calls
    def __call__(self, request: Request):  # callable → acts as a dependency
        check_rate_limit(request, self.calls)

@app.get("/items", dependencies=[Depends(RateLimiter(calls=100))])  # configured per route
def items(): ...
```

`__call__` والی class ایک **configurable** dependency ہے — آپ اسے use time پر parameterize کرتے ہیں (مثال کے طور پر مختلف rate limits مختلف routes کے لیے)۔

## Dependencies as side-effects (کوئی return کی ضرورت نہیں)

```python
@app.get("/admin", dependencies=[Depends(verify_admin)])   # run for the effect (auth check)
def admin(): ...                                            # don't need its return value
```

## Global اور router-level dependencies

```python
app = FastAPI(dependencies=[Depends(verify_api_key)])      # applies to EVERY route
router = APIRouter(dependencies=[Depends(get_current_user)])  # to all routes in a router
```
Dependencies کو app-wide یا فی-router apply کریں cross-cutting requirements کے لیے (auth، rate limiting)۔

## Testing کے لیے Overrides

```python
app.dependency_overrides[get_db] = get_test_db    # swap any dependency in tests
```

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

FastAPI کا dependency injection اس کی سب سے طاقتور خصوصیات میں سے ایک ہے، اور یہ اعلیٰ patterns وہ ہیں جو آپ کو حقیقی، پیچیدہ applications کو خوبصورتی سے structure کرنے دیتے ہیں۔

ان کو سمجھنا قیمتی senior-level knowledge ہے: **sub-dependencies** reusable layers بناتے ہیں (token → user → admin) خودکار resolution اور per-request caching کے ساتھ (غیر ضروری کام سے بچتے ہوئے)؛ **parameterized/class-based dependencies** configurable، reusable components بناتے ہیں (rate limiters، مختلف route کے لیے مختلف settings کے ساتھ permission checks)؛ **dependencies as side-effects** صاف طریقے سے requirements (auth) کو enforce کرتے ہیں بغیر function signatures کو cluttering کیے؛ اور **global/router-level dependencies** cross-cutting concerns (authentication، rate limiting) کو routes کے پورے گروپوں میں ایک جگہ apply کرتے ہیں۔

itحتی اہم طور پر، **dependency overrides** یہاں تک کہ پیچیدہ dependency graphs کو تافتی طور پر testable بناتے ہیں۔

ان patterns میں مہارت حاصل کرنا — dependencies کو compose کرنا، انہیں parameterize کرنا، انہیں globally یا per-router scope کرنا، اور tests میں انہیں override کرنا — یہ ہے جو clean، DRY، testable architecture کو non-trivial FastAPI applications میں قابل عمل بناتا ہے، ان developers کو الگ کرتے ہوئے جو framework کے DI system کو مکمل طور پر استعمال کر سکتے ہیں ان سے جو صرف بنیادی `Depends` استعمال کرتے ہیں۔

یہ well-structured، maintainable، large-scale FastAPI apps بنانے کے لیے ایک اہم موضوع ہے۔