Recap — DI Patterns: get_db, get_current_user, get_settings

# DI Patterns: get_db, get_current_user, get_settings Dependency injection is FastAPI's mechanism for sharing logic across endpoints — database sessions, auth checks, configuration, anything reusable. ## What's a dependency Any callable (function or class) that can be declared as a dependency of an endpoint: ```python from fastapi import Depends def get_db(): db = SessionLocal() try: yield db finally: db.close() @app.get("/users/{user_id}") def get_user(user_id: int, db: Session = Depends(get_db)): return db.query(User).filter_by(id=user_id).first() ``` FastAPI calls `get_db()`, passes its result as `db` to the endpoint. ## yield-based dependencies (setup + teardown) ```python def get_db(): db = SessionLocal() try: yield db # endpoint uses db here finally: db.close() # runs after endpoint returns (even on exception) ``` `yield` is the boundary — code before sets up; code after cleans up. Like a context manager. ## Common dependencies ### 1. Database session ```python def get_db(): db = SessionLocal() try: yield db finally: db.close() ``` ### 2. Current user (from JWT) ```python from fastapi.security import OAuth2PasswordBearer oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token") def get_current_user( token: str = Depends(oauth2_scheme), db: Session = Depends(get_db), ): payload = decode_jwt(token) user = db.query(User).filter_by(id=payload["sub"]).first() if not user: raise HTTPException(401, "Invalid token") return user @app.get("/me") def me(user: User = Depends(get_current_user)): return user ``` Dependencies compose: `get_current_user` itself depends on `get_db`. FastAPI resolves the chain. ### 3. Settings ```python from functools import lru_cache from pydantic_settings import BaseSettings class Settings(BaseSettings): database_url: str secret_key: str @lru_cache def get_settings() -> Settings: return Settings() @app.get("/info") def info(settings: Settings = Depends(get_settings)): return {"db_configured": bool(settings.database_url)} ``` `lru_cache` makes settings load once across all requests. ### 4. Pagination ```python from typing import Annotated def pagination_params(skip: int = 0, limit: int = 100): return {"skip": skip, "limit": min(limit, 1000)} # cap at 1000 @app.get("/users") def list_users( pagination: dict = Depends(pagination_params), db: Session = Depends(get_db), ): return db.query(User).offset(pagination["skip"]).limit(pagination["limit"]).all() ``` Reusable across many endpoints. ## Annotated syntax (Python 3.9+) Cleaner with `Annotated`: ```python from typing import Annotated DBSession = Annotated[Session, Depends(get_db)] CurrentUser = Annotated[User, Depends(get_current_user)] @app.get("/me") def me(user: CurrentUser): return user @app.get("/posts") def list_posts(user: CurrentUser, db: DBSession): return db.query(Post).filter_by(user_id=user.id).all() ``` Type aliases for repeated patterns. Recommended. ## Dependency overrides (for testing) ```python def get_test_db(): db = TestSessionLocal() try: yield db finally: db.close() app.dependency_overrides[get_db] = get_test_db # tests use the test DB ``` For auth tests: ```python app.dependency_overrides[get_current_user] = lambda: User(id=1, name="Test") ``` Removes the need for real auth in tests. ## Sub-dependencies ```python def require_admin(user: User = Depends(get_current_user)): if not user.is_admin: raise HTTPException(403, "Admin only") return user @app.delete("/users/{user_id}") def delete_user(user_id: int, admin: User = Depends(require_admin)): ... ``` Dependencies stack. `delete_user` depends on `require_admin`, which depends on `get_current_user`, which depends on `get_db`. FastAPI resolves the full chain. ## Class-based dependencies For stateful dependencies: ```python class CommonQueryParams: def __init__(self, q: str | None = None, skip: int = 0, limit: int = 100): self.q = q self.skip = skip self.limit = limit @app.get("/items") def list_items(commons: CommonQueryParams = Depends()): return {"q": commons.q, "skip": commons.skip} ``` `Depends()` with no args = use the class. ## Global dependencies Apply a dependency to ALL routes: ```python app = FastAPI(dependencies=[Depends(verify_api_key)]) ``` Useful for: API key check on all endpoints; rate limiting; tenant resolution. Or per-router: ```python router = APIRouter(dependencies=[Depends(get_current_user)]) ``` All endpoints in this router require auth. ## Yield with try/except ```python def get_db(): db = SessionLocal() try: yield db except Exception as e: db.rollback() raise finally: db.close() ``` Rollback on exception; close in finally. ## Common DI mistakes 1. **Not using Depends.** H