Dependency injection (Depends) कसरी काम गर्छ?

Question

Accepted Answer

FastAPI को **dependency injection** प्रणालीले तपाइँलाई पुन: प्रयोगयोग्य dependencies (functions/classes) घोषणा गर्न दिन्छ जुन FastAPI कल गर्छ र `Depends()` मार्फत तपाइँको path operations मा **inject** गर्छ। यो database sessions, authentication, र साझा parameters जस्ता साझा तर्कको लागि प्रयोग गरिन्छ — कोड DRY र testable राख्छ।

## एक आधारभूत dependency

```python
from fastapi import Depends

# a dependency is just a callable that returns something
def pagination(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/items")
def list_items(params: dict = Depends(pagination)):   # FastAPI calls pagination() and injects the result
    return params
# the skip/limit query params are now handled by the reusable dependency
```

`params = Depends(pagination)` घोषणा गर्नुले FastAPI लाई `pagination` कल गर्न बताउँछ (यसको parameters अनुरोध देखि समाधान गर्दै) र परिणाम तपाइँको function मा पास गर्छ। Dependency धेरै endpoints भर पुन: प्रयोगयोग्य छ।

## Cleanup (yield) संग dependencies — जस्तै database sessions

```python
def get_db():
    db = SessionLocal()
    try:
        yield db                  # provide the session to the endpoint
    finally:
        db.close()                # cleanup runs AFTER the response — guaranteed

@app.get("/users")
def list_users(db = Depends(get_db)):
    return db.query(User).all()    # uses the injected, auto-closed session
```

एक `yield` dependency ले एक resource प्रदान गर्छ र अनुरोध पछि teardown चलाउँछ — database sessions को लागि मानक pattern (अगाडि खोलनुहोस्, पछि बन्द गर्नुहोस्, स्वचालित रूपमा)।

## Dependencies अन्य dependencies मा निर्भर हुन सक्छ

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

@app.get("/me")
def me(user: User = Depends(get_current_user)):           # auth via injection
    return user
```

Dependencies एक tree बनाउँछन् — FastAPI पूरो chain समाधान गर्छ। यो कसरी authentication सामान्यतया गरिन्छ (`get_current_user` dependency)।

## Class dependencies र पुन: प्रयोग

```python
@app.get("/items", dependencies=[Depends(verify_api_key)])   # run a dependency without using its return
def items(): ...                                              # e.g. enforce auth as a side effect
```

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

Dependency injection FastAPI को सबै शक्तिशाली र महत्त्वपूर्ण विशेषताहरू मध्ये एक हो — यो कसरी तपाइँ endpoints भर तर्क स्वच्छ रूपमा साझा र पुन: प्रयोग गर्नुहुन्छ (database sessions, authentication, साझा query parameters, permission checks) बिना duplication को।

यो बुझ्नु आवश्यक छ किनभने यो मूल patterns को आधार हो: **`yield` dependency** database sessions व्यवस्थापन गर्न (प्रत्येक अनुरोध पछि गारान्टीशुदा cleanup संग) मानक तरिका हो, र **`get_current_user` dependency** authentication लागू गर्न idiomatic तरिका हो।

DI ले पनि कोड अत्यधिक **testable** बनाउँछ — तपाइँ tests मा dependencies लाई mocks संग override गर्न सक्नुहुन्छ।

प्रणालीको elegance (dependencies आफ्नै parameters अनुरोध देखि समाधान गर्छन्, अन्य dependencies मा निर्भर हुन सक्छन् एक tree बनाएर, र docs संग integrate हुन्छन्) यो वास्तविक applications को संरचना गर्न एक बहुमुखी उपकरण बनाउँछ, त्यसैले `Depends` मा महारत हासिल गर्नु राम्रो-संगठित, maintainable, testable FastAPI apps निर्माण गर्न कुञ्जी हो।