feat(api): implement lifespan with DB and Redis connection pooling

- Refactor database.py to use init_db()/close_db() lifecycle
- Add create_db_engine() with pool_size=10, max_overflow=20, pool_pre_ping=True
- Replace cache.py stub with real Redis client using redis.asyncio
- Implement init_redis()/close_redis() with graceful error handling
- Replace no-op lifespan in main.py with proper startup/shutdown
- Enhance health endpoint to check DB and Redis connectivity
- Add tests for database, cache, and health endpoint lifecycle

Co-Authored-By: Paperclip <noreply@paperclip.ing>

api/src/cartsnitch_api/cache.py

@@ -1,9 +1,41 @@
 """Redis/DragonflyDB caching helpers."""
 
+import logging
+from typing import TYPE_CHECKING
+
 import redis.asyncio as redis
+from redis.asyncio import Redis
 
 from cartsnitch_api.config import settings
 
+if TYPE_CHECKING:
+    from cartsnitch_api.config import Settings
+
+logger = logging.getLogger(__name__)
+
+_redis: "Redis | None" = None
+
+
+def get_settings() -> "Settings":
+    return settings
+
+
+async def init_redis() -> None:
+    global _redis
+    _redis = redis.from_url(settings.redis_url)
+    await _redis.ping()
+
+
+async def close_redis() -> None:
+    global _redis
+    if _redis is not None:
+        await _redis.aclose()
+        _redis = None
+
+
+def get_redis() -> Redis | None:
+    return _redis
+
 
 class CacheClient:
     """Redis/DragonflyDB caching with connection pooling.

api/src/cartsnitch_api/database.py

@@ -1,28 +1,60 @@
 """Database session management for the API gateway."""
 
 from collections.abc import AsyncGenerator
+from typing import TYPE_CHECKING
 
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
 
 from cartsnitch_api.config import settings
 
-engine = create_async_engine(
-    settings.database_url,
-    echo=False,
-    pool_size=10,
-    max_overflow=20,
-    pool_pre_ping=True,
-    pool_recycle=3600,
-)
-async_session_factory = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+if TYPE_CHECKING:
+    from sqlalchemy.engine import Engine
+
+
+_engine: "Engine | None" = None
+async_session_factory: async_sessionmaker[AsyncSession] | None = None
+
+
+def create_db_engine():
+    return create_async_engine(
+        settings.database_url,
+        pool_size=10,
+        max_overflow=20,
+        pool_pre_ping=True,
+        pool_recycle=3600,
+        echo=False,
+    )
+
+
+async def init_db() -> None:
+    global _engine, async_session_factory
+    _engine = create_db_engine()
+    async_session_factory = async_sessionmaker(_engine, class_=AsyncSession, expire_on_commit=False)
+
+
+async def close_db() -> None:
+    global _engine, async_session_factory
+    if _engine is not None:
+        await _engine.dispose()
+        _engine = None
+    async_session_factory = None
+
+
+def get_engine():
+    return _engine
 
 
 async def get_db() -> AsyncGenerator[AsyncSession, None]:
-    """FastAPI dependency that yields an async DB session."""
+    if async_session_factory is None:
+        raise RuntimeError("Database not initialized. Call init_db() first.")
     async with async_session_factory() as session:
         yield session
 
 
-async def dispose_engine() -> None:
-    """Dispose the database engine, closing all pooled connections."""
-    await engine.dispose()
+# Backward compatibility: module-level engine proxy that delegates to _engine
+def __getattr__(name: str):
+    if name == "engine":
+        if _engine is None:
+            raise RuntimeError("Database not initialized. Call init_db() first.")
+        return _engine
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

api/src/cartsnitch_api/main.py

@@ -26,10 +26,14 @@ from cartsnitch_api.routes.user import router as user_router
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    await cache_client.initialize()
+    from cartsnitch_api.database import init_db, close_db
+    from cartsnitch_api.cache import init_redis, close_redis
+
+    await init_db()
+    await init_redis()
     yield
-    await cache_client.close()
-    await dispose_engine()
+    await close_redis()
+    await close_db()
 
 
 def create_app() -> FastAPI:

api/src/cartsnitch_api/routes/health.py

@@ -1,8 +1,11 @@
 """Health check and error metrics endpoints."""
 
 from fastapi import APIRouter, Depends
+from sqlalchemy import text
 
 from cartsnitch_api.auth.dependencies import verify_service_key
+from cartsnitch_api.cache import get_redis
+from cartsnitch_api.database import get_engine
 from cartsnitch_api.middleware.error_handler import get_error_monitor
 
 router = APIRouter(tags=["health"])
@@ -10,7 +13,27 @@ router = APIRouter(tags=["health"])
 
 @router.get("/health")
 async def health():
-    return {"status": "ok"}
+    engine = get_engine()
+    db_ok = False
+    redis_ok = False
+
+    try:
+        async with engine.connect() as conn:
+            await conn.execute(text("SELECT 1"))
+        db_ok = True
+    except Exception:
+        pass
+
+    try:
+        r = get_redis()
+        if r:
+            await r.ping()
+            redis_ok = True
+    except Exception:
+        pass
+
+    status = "ok" if db_ok else "degraded"
+    return {"status": status, "db": db_ok, "redis": redis_ok}
 
 
 @router.get("/internal/error-stats", dependencies=[Depends(verify_service_key)])