Refactor Phase 2: Split stories.py into Schema/Service/Controller, add missing endpoints, fix async bug

backend/app/services/provider_cache.py

@@ -1,31 +1,109 @@
-"""In-memory cache for providers loaded from DB."""
+"""Redis-backed cache for providers loaded from DB."""
 
+import json
 from collections import defaultdict
 from typing import Literal
 
+from pydantic import BaseModel
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.core.logging import get_logger
+from app.core.redis import get_redis
 from app.db.admin_models import Provider
 
+logger = get_logger(__name__)
+
 ProviderType = Literal["text", "image", "tts", "storybook"]
 
-_cache: dict[ProviderType, list[Provider]] = defaultdict(list)
+
+class CachedProvider(BaseModel):
+    """Serializable provider configuration matching DB model fields."""
+    id: str
+    name: str
+    type: str
+    adapter: str
+    model: str | None = None
+    api_base: str | None = None
+    api_key: str | None = None
+    timeout_ms: int = 60000
+    max_retries: int = 1
+    weight: int = 1
+    priority: int = 0
+    enabled: bool = True
+    config_json: dict | None = None
+    config_ref: str | None = None
 
 
-async def reload_providers(db: AsyncSession):
-    result = await db.execute(select(Provider).where(Provider.enabled == True))  # noqa: E712
-    providers = result.scalars().all()
-    grouped: dict[ProviderType, list[Provider]] = defaultdict(list)
-    for p in providers:
-        grouped[p.type].append(p)
-    # sort by priority desc, then weight desc
-    for k in grouped:
-        grouped[k].sort(key=lambda x: (x.priority, x.weight), reverse=True)
-    _cache.clear()
-    _cache.update(grouped)
-    return _cache
+# Local memory fallback (L1 cache)
+_local_cache: dict[ProviderType, list[CachedProvider]] = defaultdict(list)
+CACHE_KEY = "dreamweaver:providers:config"
 
 
-def get_providers(provider_type: ProviderType) -> list[Provider]:
-    return _cache.get(provider_type, [])
+async def reload_providers(db: AsyncSession) -> dict[ProviderType, list[CachedProvider]]:
+    """Reload providers from DB and update Redis cache."""
+    try:
+        result = await db.execute(select(Provider).where(Provider.enabled == True))  # noqa: E712
+        providers = result.scalars().all()
+        
+        # Convert to Pydantic models
+        cached_list = []
+        for p in providers:
+            cached_list.append(CachedProvider(
+                id=p.id,
+                name=p.name,
+                type=p.type,
+                adapter=p.adapter,
+                model=p.model,
+                api_base=p.api_base,
+                api_key=p.api_key,
+                timeout_ms=p.timeout_ms,
+                max_retries=p.max_retries,
+                weight=p.weight,
+                priority=p.priority,
+                enabled=p.enabled,
+                config_json=p.config_json,
+                config_ref=p.config_ref
+            ))
+
+        # Group by type
+        grouped: dict[str, list[CachedProvider]] = defaultdict(list)
+        for cp in cached_list:
+            grouped[cp.type].append(cp)
+
+        # Sort
+        for k in grouped:
+            grouped[k].sort(key=lambda x: (x.priority, x.weight), reverse=True)
+
+        # Update Redis
+        redis = await get_redis()
+        # Serialize entire dict structure
+        # Pydantic -> dict -> json
+        json_data = {k: [p.model_dump() for p in v] for k, v in grouped.items()}
+        await redis.set(CACHE_KEY, json.dumps(json_data))
+        
+        # Update local cache
+        _local_cache.clear()
+        _local_cache.update(grouped)
+        return grouped
+            
+    except Exception as e:
+        logger.error("failed_to_reload_providers", error=str(e))
+        raise
+
+
+async def get_providers(provider_type: ProviderType) -> list[CachedProvider]:
+    """Get providers from Redis (preferred) or local fallback."""
+    try:
+        redis = await get_redis()
+        data = await redis.get(CACHE_KEY)
+        if data:
+            raw_dict = json.loads(data)
+            if provider_type in raw_dict:
+                return [CachedProvider(**item) for item in raw_dict[provider_type]]
+            return []
+    except Exception as e:
+        logger.warning("redis_cache_read_failed", error=str(e))
+    
+    # Fallback to local memory
+    return _local_cache.get(provider_type, [])