chore: checkpoint current backend/runtime changes

backend/src/services/base/__init__.py

@@ -1,18 +1,28 @@
 from __future__ import annotations
 
-from services.base.redis import RedisService, redis_service
+from services.base.redis import RedisService, get_or_init_redis_client, redis_service
 from services.base.service_interface import (
     BaseServiceProvider,
     ServiceRegistry,
+    close_registered_services,
+    initialize_registered_services,
     register_service,
     register_service_instance,
+    resolve_registered_services,
 )
+from services.base.supabase import SupabaseService, supabase_service
 
 __all__ = [
     "BaseServiceProvider",
     "RedisService",
     "ServiceRegistry",
+    "SupabaseService",
+    "close_registered_services",
+    "get_or_init_redis_client",
+    "initialize_registered_services",
     "redis_service",
     "register_service",
     "register_service_instance",
+    "resolve_registered_services",
+    "supabase_service",
 ]

backend/src/services/base/redis.py

@@ -92,6 +92,14 @@ class RedisService(BaseServiceProvider):
         return self._require_client()
 
 
+async def get_or_init_redis_client() -> redis.Redis:
+    if not redis_service.is_initialized:
+        initialized = await redis_service.initialize()
+        if not initialized:
+            raise RuntimeError("Redis service initialization failed")
+    return redis_service.get_client()
+
+
 redis_service: RedisService = register_service_instance("redis", RedisService())
 
-__all__ = ["RedisService", "redis_service"]
+__all__ = ["RedisService", "get_or_init_redis_client", "redis_service"]

backend/src/services/base/service_interface.py

@@ -61,6 +61,12 @@ class ServiceRegistry:
     @classmethod
     def create_service(
         cls, service_name: str, **kwargs: Any
+    ) -> Optional[BaseServiceProvider]:
+        return cls.get_service(service_name, **kwargs)
+
+    @classmethod
+    def get_service(
+        cls, service_name: str, **kwargs: Any
     ) -> Optional[BaseServiceProvider]:
         factory = cls.get_service_factory(service_name)
         if not factory:
@@ -82,3 +88,71 @@ TService = TypeVar("TService", bound=BaseServiceProvider)
 def register_service_instance(service_name: str, service: TService) -> TService:
     ServiceRegistry.register(service_name, lambda: service)
     return service
+
+
+def resolve_registered_services(service_names: list[str]) -> list[BaseServiceProvider]:
+    services: list[BaseServiceProvider] = []
+    for service_name in service_names:
+        service = ServiceRegistry.get_service(service_name)
+        if service is None:
+            raise RuntimeError(f"Service is not registered: {service_name}")
+        services.append(service)
+    return services
+
+
+async def close_registered_services(services: list[BaseServiceProvider]) -> bool:
+    lifecycle_logger = get_logger("services.base.lifecycle")
+    all_closed = True
+    for service in reversed(services):
+        try:
+            closed = await service.close()
+        except Exception as exc:  # noqa: BLE001
+            lifecycle_logger.warning(
+                "Failed to close service",
+                service=service.service_name,
+                error=str(exc),
+            )
+            all_closed = False
+            continue
+        if not closed:
+            lifecycle_logger.warning(
+                "Service close returned false",
+                service=service.service_name,
+            )
+            all_closed = False
+    return all_closed
+
+
+async def initialize_registered_services(
+    service_names: list[str],
+) -> tuple[bool, list[BaseServiceProvider]]:
+    lifecycle_logger = get_logger("services.base.lifecycle")
+    initialized_services: list[BaseServiceProvider] = []
+    try:
+        services = resolve_registered_services(service_names)
+    except RuntimeError as exc:
+        lifecycle_logger.error("Failed to resolve registered services", error=str(exc))
+        return False, []
+
+    for service in services:
+        try:
+            initialized = await service.initialize()
+        except Exception as exc:  # noqa: BLE001
+            lifecycle_logger.warning(
+                "Service initialization raised exception",
+                service=service.service_name,
+                error=str(exc),
+            )
+            initialized = False
+
+        if not initialized:
+            lifecycle_logger.error(
+                "Service initialization failed, rolling back",
+                service=service.service_name,
+            )
+            await close_registered_services(initialized_services)
+            return False, []
+
+        initialized_services.append(service)
+
+    return True, initialized_services

backend/src/services/base/supabase.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+from supabase import create_client
+
+from core.config.settings import SupabaseSettings, config
+
+from .service_interface import BaseServiceProvider, register_service_instance
+
+
+class SupabaseService(BaseServiceProvider):
+    def __init__(self, settings: SupabaseSettings | None = None) -> None:
+        super().__init__("supabase")
+        self._settings = settings or config.supabase
+        self._client: Any = None
+        self._admin_client: Any = None
+
+    async def initialize(self, **_: Any) -> bool:
+        try:
+            self._client = create_client(
+                self._settings.url,
+                self._settings.anon_key,
+            )
+            self._admin_client = create_client(
+                self._settings.url,
+                self._settings.service_role_key,
+            )
+            self._set_initialized(True)
+            self.logger.info("Supabase service initialized")
+            return True
+        except Exception as exc:  # noqa: BLE001
+            self.logger.warning("Supabase service initialization failed", error=str(exc))
+            self._client = None
+            self._admin_client = None
+            self._set_initialized(False)
+            return False
+
+    async def close(self) -> bool:
+        self._client = None
+        self._admin_client = None
+        self._set_initialized(False)
+        self.logger.info("Supabase service closed")
+        return True
+
+    async def health_check(self) -> dict[str, Any]:
+        client = self._client
+        admin_client = self._admin_client
+        if client is None or admin_client is None:
+            return {"status": "unhealthy", "details": {"error": "not initialized"}}
+        try:
+            await asyncio.to_thread(client.auth.get_session)
+            await asyncio.to_thread(admin_client.auth.admin.list_users, page=1, per_page=1)
+            return {
+                "status": "healthy",
+                "details": {
+                    "anon_client": "ready",
+                    "admin_client": "ready",
+                },
+            }
+        except Exception as exc:  # noqa: BLE001
+            self.logger.warning("Supabase health check failed", error=str(exc))
+            return {"status": "unhealthy", "details": {"error": str(exc)}}
+
+    def get_client(self) -> Any:
+        return self._require_client()
+
+    def get_admin_client(self) -> Any:
+        return self._require_admin_client()
+
+    def _require_client(self) -> Any:
+        client = self._client
+        if client is None:
+            raise RuntimeError("Supabase client is not initialized")
+        return client
+
+    def _require_admin_client(self) -> Any:
+        admin_client = self._admin_client
+        if admin_client is None:
+            raise RuntimeError("Supabase admin client is not initialized")
+        return admin_client
+
+
+supabase_service: SupabaseService = register_service_instance(
+    "supabase", SupabaseService()
+)
+
+__all__ = ["SupabaseService", "supabase_service"]