aiteamutils 0.2.50__py3-none-any.whl → 0.2.52__py3-none-any.whl

aiteamutils/database.py

@@ -764,11 +764,12 @@ class DatabaseService:
             processed_data = self.preprocess_data(model, log_data)
             entity = model(**processed_data)
             
-            # 로그 엔티티 저장
-            self.db.add(entity)
-            await self.db.flush()
-            
-            return entity
+            async with self.get_session() as session:
+                # 로그 엔티티 저장
+                session.add(entity)
+                await session.flush()
+                await session.commit()
+                return entity
             
         except Exception as e:
             logging.error(f"Failed to create log: {str(e)}")
@@ -996,63 +997,49 @@ class DatabaseService:
                 original_error=e
             )
 
+    async def create_session(self) -> AsyncSession:
+        """새로운 데이터베이스 세션을 생성합니다.
+
+        Returns:
+            AsyncSession: 생성된 세션
+
+        Raises:
+            CustomException: 세션 생성 실패 시
+        """
+        if self.session_factory is None:
+            raise CustomException(
+                ErrorCode.DB_CONNECTION_ERROR,
+                detail="session_factory is not initialized",
+                source_function="DatabaseService.create_session"
+            )
+        
+        return self.session_factory()
+
 async def get_db() -> AsyncGenerator[AsyncSession, None]:
-    """데이터베이스 세션을 생성하고 반환하는 비동기 제너레이터.
-    
+    """데이터베이스 세션 의존성
+
     Yields:
         AsyncSession: 데이터베이스 세션
-        
+
     Raises:
-        CustomException: 세션 생성 실패 시
+        CustomException: 데이터베이스 연결 오류
     """
-    if not await DatabaseServiceManager.is_initialized():
-        raise CustomException(
-            ErrorCode.DB_CONNECTION_ERROR,
-            detail="Database service is not initialized",
-            source_function="get_db"
-        )
+    db_service = await get_database_service()
     
-    db_service = await DatabaseServiceManager.get_instance()
-    if not db_service or not db_service.engine:
-        raise CustomException(
-            ErrorCode.DB_CONNECTION_ERROR,
-            detail="Database service or engine is not properly initialized",
-            source_function="get_db"
-        )
-    
-    try:
-        session = db_service.get_session()
-        if session is None:
-            raise CustomException(
-                ErrorCode.DB_CONNECTION_ERROR,
-                detail="Failed to create database session",
-                source_function="get_db"
-            )
-        
-        # 세션이 유효한지 확인
+    async with db_service.get_session() as session:
         try:
+            # 세션이 유효한지 확인
             await session.execute(select(1))
+            yield session
         except Exception as e:
-            await session.close()
+            if isinstance(e, CustomException):
+                raise e
             raise CustomException(
                 ErrorCode.DB_CONNECTION_ERROR,
-                detail="Database session is not valid",
+                detail=f"Failed to get database session: {str(e)}",
                 source_function="get_db",
                 original_error=e
             )
-            
-        yield session
-    except Exception as e:
-        if isinstance(e, CustomException):
-            raise e
-        raise CustomException(
-            ErrorCode.DB_CONNECTION_ERROR,
-            detail=f"Failed to get database session: {str(e)}",
-            source_function="get_db",
-            original_error=e
-        )
-    finally:
-        await session.close()
 
 async def get_database_service() -> DatabaseService:
     """DatabaseService 의존성

aiteamutils/dependencies.py

@@ -1,135 +1,213 @@
-from typing import Type, Dict, Tuple, Any, Callable
-from fastapi import Depends, status
-from fastapi.security import OAuth2PasswordBearer
-from jose import JWTError, jwt
+"""의존성 관리 모듈."""
+from typing import Type, TypeVar, Dict, Any, Optional, Callable, List, AsyncGenerator
+from fastapi import Request, Depends, HTTPException, status
 from sqlalchemy.ext.asyncio import AsyncSession
+from jose import jwt, JWTError
 import logging
 
-from .database import DatabaseServiceManager, DatabaseService, get_db, get_database_service
 from .exceptions import CustomException, ErrorCode
 from .config import get_settings
+from .base_service import BaseService
+from .base_repository import BaseRepository
+from .database import db_manager
 
-class ServiceRegistry:
-    """서비스 레지스트리 클래스"""
-    def __init__(self):
-        self._services: Dict[str, Tuple[Type[Any], Type[Any]]] = {}
+T = TypeVar("T", bound=BaseService)
+R = TypeVar("R", bound=BaseRepository)
+
+_service_registry: Dict[str, Dict[str, Any]] = {}
+
+async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    """데이터베이스 세션을 반환합니다.
     
-    def register(self, name: str, repository_class: Type[Any], service_class: Type[Any]) -> None:
-        """서비스를 등록합니다.
+    Yields:
+        AsyncSession: 데이터베이스 세션
         
-        Args:
-            name (str): 서비스 이름
-            repository_class (Type[Any]): 레포지토리 클래스
-            service_class (Type[Any]): 서비스 클래스
-        """
-        self._services[name] = (repository_class, service_class)
+    Raises:
+        CustomException: 세션 생성 실패 시
+    """
+    try:
+        async with db_manager.get_session() as session:
+            yield session
+    except Exception as e:
+        raise CustomException(
+            ErrorCode.DATABASE_ERROR,
+            detail=str(e),
+            source_function="dependencies.get_db",
+            original_error=e
+        )
+
+def register_service(
+    service_class: Type[T],
+    repository_class: Optional[Type[R]] = None,
+    **kwargs
+) -> None:
+    """서비스를 등록합니다.
     
-    def get(self, name: str) -> Tuple[Type[Any], Type[Any]]:
-        """등록된 서비스를 가져옵니다.
+    Args:
+        service_class: 서비스 클래스
+        repository_class: 저장소 클래스 (선택)
+        **kwargs: 추가 의존성
+    """
+    service_name = service_class.__name__
+    _service_registry[service_name] = {
+        "service_class": service_class,
+        "repository_class": repository_class,
+        "dependencies": kwargs
+    }
+
+async def _get_service(
+    service_name: str,
+    session: AsyncSession,
+    request: Request
+) -> BaseService:
+    """서비스 인스턴스를 생성합니다.
+    
+    Args:
+        service_name: 서비스 이름
+        session: 데이터베이스 세션
+        request: FastAPI 요청 객체
         
-        Args:
-            name (str): 서비스 이름
-            
-        Returns:
-            Tuple[Type[Any], Type[Any]]: (레포지토리 클래스, 서비스 클래스)
-            
-        Raises:
-            CustomException: 등록되지 않은 서비스인 경우
-        """
-        if name not in self._services:
+    Returns:
+        BaseService: 서비스 인스턴스
+        
+    Raises:
+        CustomException: 서비스 생성 실패 시
+    """
+    try:
+        service_info = _service_registry.get(service_name)
+        if not service_info:
             raise CustomException(
-                ErrorCode.NOT_FOUND,
-                detail=f"Service '{name}' is not registered",
-                source_function="ServiceRegistry.get"
+                ErrorCode.SERVICE_NOT_FOUND,
+                detail=service_name,
+                source_function="dependencies._get_service"
             )
-        return self._services[name]
-
-# ServiceRegistry 초기화
-service_registry = ServiceRegistry()
-
-def get_service(name: str):
-    """등록된 서비스를 가져오는 의존성 함수
+            
+        service_class = service_info["service_class"]
+        repository_class = service_info["repository_class"]
+        dependencies = service_info["dependencies"]
+        
+        # 저장소 인스턴스 생성
+        repository = None
+        if repository_class:
+            repository = repository_class(session=session)
+            
+        # 서비스 인스턴스 생성
+        service = service_class(
+            repository=repository,
+            session=session,
+            request=request,
+            **dependencies
+        )
+        
+        return service
+        
+    except CustomException as e:
+        raise e
+    except Exception as e:
+        raise CustomException(
+            ErrorCode.INTERNAL_ERROR,
+            detail=str(e),
+            source_function="dependencies._get_service",
+            original_error=e
+        )
 
+def get_service(service_name: str) -> Callable:
+    """서비스 의존성을 반환합니다.
+    
     Args:
-        name (str): 서비스 이름
-
+        service_name: 서비스 이름
+        
     Returns:
-        Callable: 서비스 인스턴스를 반환하는 의존성 함수
+        Callable: 서비스 의존성 함수
     """
-    def _get_service(
-        db_service: DatabaseService = Depends(get_database_service),
+    async def _get_service_dependency(
+        request: Request,
         session: AsyncSession = Depends(get_db)
-    ):
-        try:
-            repository_class, service_class = service_registry.get(name)
-            repository = repository_class(db_service)
-            service = service_class(repository, db_service)
-            service.session = session
-            return service
-        except CustomException as e:
-            raise e
-        except Exception as e:
-            raise CustomException(
-                ErrorCode.INTERNAL_ERROR,
-                detail=f"Failed to create service '{name}': {str(e)}",
-                source_function="dependencies.get_service",
-                original_error=e
-            )
-    return _get_service
+    ) -> BaseService:
+        return await _get_service(service_name, session, request)
+    return _get_service_dependency
 
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/users/token")
 async def get_current_user(
-    token: str = Depends(oauth2_scheme),
-    db_service: DatabaseServiceManager = Depends(get_database_service)
-):
-    """현재 사용자를 가져오는 의존성 함수
-
+    request: Request,
+    session: AsyncSession = Depends(get_db),
+    auth_service: BaseService = Depends(get_service("AuthService"))
+) -> Dict[str, Any]:
+    """현재 사용자 정보를 반환합니다.
+    
     Args:
-        token (str): OAuth2 토큰
-        db_service (DatabaseServiceManager): DatabaseServiceManager 객체
-
+        request: FastAPI 요청 객체
+        session: 데이터베이스 세션
+        auth_service: 인증 서비스
+        
     Returns:
-        User: 현재 사용자
-
+        Dict[str, Any]: 사용자 정보
+        
     Raises:
-        CustomException: 인증 실패 시 예외
+        HTTPException: 인증 실패 시
     """
+    settings = get_settings()
+    
+    # Authorization 헤더 검증
+    authorization = request.headers.get("Authorization")
+    if not authorization or not authorization.startswith("Bearer "):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Not authenticated",
+            headers={"WWW-Authenticate": "Bearer"}
+        )
+        
+    token = authorization.split(" ")[1]
+    
     try:
-        settings = get_settings()
+        # JWT 토큰 디코딩
         payload = jwt.decode(
             token,
-            settings.JWT_SECRET,
-            algorithms=[settings.JWT_ALGORITHM],
-            audience=settings.TOKEN_AUDIENCE
+            settings.jwt_secret,
+            algorithms=[settings.jwt_algorithm],
+            issuer=settings.token_issuer,
+            audience=settings.token_audience
         )
-        user_ulid = payload.get("sub")
+        
+        # 토큰 타입 검증
+        token_type = payload.get("token_type")
+        if token_type != "access":
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid token type",
+                headers={"WWW-Authenticate": "Bearer"}
+            )
+            
+        # 사용자 조회
+        user_ulid = payload.get("user_ulid")
         if not user_ulid:
-            raise CustomException(
-                ErrorCode.INVALID_TOKEN,
-                source_function="dependencies.py / get_current_user"
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid token payload",
+                headers={"WWW-Authenticate": "Bearer"}
             )
-    except JWTError:
-        raise CustomException(
-            ErrorCode.INVALID_TOKEN,
-            detail=token[:10] + "...",
-            source_function="dependencies.py / get_current_user"
-        )
-
-    try:
-        repository_class, _ = service_registry.get("user")
-        user_repo = repository_class(db_service)
-        user = await user_repo.get_user(user_ulid, by="ulid")
-    except ValueError:
-        raise CustomException(
-            ErrorCode.SERVICE_NOT_REGISTERED,
-            detail="User service is not registered",
-            source_function="dependencies.py / get_current_user"
-        )
-
-    if not user:
-        raise CustomException(
-            ErrorCode.USER_NOT_FOUND,
-            source_function="dependencies.py / get_current_user"
+            
+        user = await auth_service.get_by_ulid(user_ulid)
+        if not user:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="User not found",
+                headers={"WWW-Authenticate": "Bearer"}
+            )
+            
+        return user
+        
+    except JWTError as e:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=str(e),
+            headers={"WWW-Authenticate": "Bearer"}
         )
-
-    return user
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        logging.error(f"Error in get_current_user: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Authentication failed",
+            headers={"WWW-Authenticate": "Bearer"}
+        )