aiteamutils 0.2.51__tar.gz → 0.2.53__tar.gz

{aiteamutils-0.2.51 → aiteamutils-0.2.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiteamutils
-Version: 0.2.51
+Version: 0.2.53
 Summary: AI Team Utilities
 Project-URL: Homepage, https://github.com/yourusername/aiteamutils
 Project-URL: Issues, https://github.com/yourusername/aiteamutils/issues

aiteamutils-0.2.53/aiteamutils/base_repository.py

@@ -0,0 +1,208 @@
+"""기본 레포지토리 모듈."""
+from typing import TypeVar, Generic, Dict, Any, List, Optional, Type, Union
+from sqlalchemy.orm import DeclarativeBase, Load
+from sqlalchemy.exc import IntegrityError, SQLAlchemyError
+from sqlalchemy import select, or_, and_
+from .exceptions import CustomException, ErrorCode
+from sqlalchemy.orm import joinedload
+from sqlalchemy.sql import Select
+from fastapi import Request
+from sqlalchemy.ext.asyncio import AsyncSession
+
+ModelType = TypeVar("ModelType", bound=DeclarativeBase)
+
+class BaseRepository(Generic[ModelType]):
+    ##################
+    # 1. 초기화 영역 #
+    ##################
+    def __init__(self, session: AsyncSession, model: Type[ModelType]):
+        """
+        Args:
+            session (AsyncSession): 데이터베이스 세션
+            model (Type[ModelType]): 모델 클래스
+        """
+        self.session = session
+        self.model = model
+    
+    @property
+    def session(self):
+        """현재 세션을 반환합니다."""
+        if self._session is None:
+            raise CustomException(
+                ErrorCode.DB_CONNECTION_ERROR,
+                detail="Database session is not set",
+                source_function=f"{self.__class__.__name__}.session"
+            )
+        return self._session
+    
+    @session.setter
+    def session(self, value):
+        """세션을 설정합니다."""
+        self._session = value
+
+    #######################
+    # 2. CRUD 작업     #
+    #######################
+    async def get(
+        self,
+        ulid: str
+    ) -> Optional[Dict[str, Any]]:
+        """ULID로 엔티티를 조회합니다."""
+        try:
+            stmt = select(self.model).filter_by(ulid=ulid, is_deleted=False)
+            result = await self.session.execute(stmt)
+            entity = result.scalars().unique().first()
+            
+            if not entity:
+                raise CustomException(
+                    ErrorCode.DB_NO_RESULT,
+                    detail=f"{self.model.__tablename__}|ulid|{ulid}",
+                    source_function=f"{self.__class__.__name__}.get"
+                )
+            return entity
+        except CustomException as e:
+            e.detail = f"Repository error for {self.model.__tablename__}: {e.detail}"
+            e.source_function = f"{self.__class__.__name__}.get -> {e.source_function}"
+            raise e
+        except SQLAlchemyError as e:
+            raise CustomException(
+                ErrorCode.DB_QUERY_ERROR,
+                detail=f"Database error in {self.model.__tablename__}: {str(e)}",
+                source_function=f"{self.__class__.__name__}.get",
+                original_error=e
+            )
+
+    async def list(
+        self,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Dict[str, Any] | None = None,
+        search_params: Dict[str, Any] | None = None
+    ) -> List[Any]:
+        """엔티티 목록을 조회합니다."""
+        try:
+            stmt = select(self.model).where(self.model.is_deleted == False)
+
+            # 필터 적용
+            if filters:
+                stmt = self._apply_filters(stmt, filters)
+
+            # 검색 적용
+            if search_params:
+                stmt = self._apply_search_params(stmt, search_params)
+
+            # 페이지네이션 적용
+            stmt = stmt.limit(limit).offset(skip)
+
+            result = await self.session.execute(stmt)
+            return result.scalars().unique().all()
+
+        except SQLAlchemyError as e:
+            raise CustomException(
+                ErrorCode.DB_QUERY_ERROR,
+                detail=f"Unexpected repository list error in {self.model.__tablename__}: {str(e)}",
+                source_function=f"{self.__class__.__name__}.list",
+                original_error=e,
+            )
+
+    async def create(self, data: Dict[str, Any]) -> ModelType:
+        """새로운 엔티티를 생성합니다."""
+        try:
+            entity = self.model(**data)
+            self.session.add(entity)
+            await self.session.flush()
+            await self.session.refresh(entity)
+            return entity
+        except IntegrityError as e:
+            await self.session.rollback()
+            self._handle_integrity_error(e, "create", data)
+        except SQLAlchemyError as e:
+            await self.session.rollback()
+            raise CustomException(
+                ErrorCode.DB_CREATE_ERROR,
+                detail=f"Database create error in {self.model.__tablename__}: {str(e)}",
+                source_function=f"{self.__class__.__name__}.create",
+                original_error=e
+            )
+
+    async def update(self, ulid: str, data: Dict[str, Any]) -> Optional[ModelType]:
+        """기존 엔티티를 수정합니다."""
+        try:
+            stmt = select(self.model).filter_by(ulid=ulid, is_deleted=False)
+            result = await self.session.execute(stmt)
+            entity = result.scalars().first()
+            
+            if not entity:
+                raise CustomException(
+                    ErrorCode.DB_NO_RESULT,
+                    detail=f"{self.model.__tablename__}|ulid|{ulid}",
+                    source_function=f"{self.__class__.__name__}.update"
+                )
+
+            for key, value in data.items():
+                setattr(entity, key, value)
+            
+            await self.session.flush()
+            await self.session.refresh(entity)
+            return entity
+            
+        except IntegrityError as e:
+            await self.session.rollback()
+            self._handle_integrity_error(e, "update", data)
+        except SQLAlchemyError as e:
+            await self.session.rollback()
+            raise CustomException(
+                ErrorCode.DB_UPDATE_ERROR,
+                detail=f"Database update error in {self.model.__tablename__}: {str(e)}",
+                source_function=f"{self.__class__.__name__}.update",
+                original_error=e
+            )
+
+    async def delete(self, ulid: str) -> bool:
+        """엔티티를 소프트 삭제합니다."""
+        try:
+            stmt = select(self.model).filter_by(ulid=ulid, is_deleted=False)
+            result = await self.session.execute(stmt)
+            entity = result.scalars().first()
+            
+            if not entity:
+                raise CustomException(
+                    ErrorCode.DB_NO_RESULT,
+                    detail=f"{self.model.__tablename__}|ulid|{ulid}",
+                    source_function=f"{self.__class__.__name__}.delete"
+                )
+
+            entity.is_deleted = True
+            await self.session.flush()
+            return True
+            
+        except SQLAlchemyError as e:
+            await self.session.rollback()
+            raise CustomException(
+                ErrorCode.DB_DELETE_ERROR,
+                detail=f"Database delete error in {self.model.__tablename__}: {str(e)}",
+                source_function=f"{self.__class__.__name__}.delete",
+                original_error=e
+            )
+
+    async def real_delete(self, ulid: str) -> bool:
+        """엔티티를 실제로 삭제합니다."""
+        try:
+            stmt = select(self.model).filter_by(ulid=ulid)
+            result = await self.session.execute(stmt)
+            entity = result.scalars().first()
+            
+            if entity:
+                await self.session.delete(entity)
+                await self.session.flush()
+                return True
+            return False
+            
+        except SQLAlchemyError as e:
+            await self.session.rollback()
+            raise CustomException(
+                ErrorCode.DB_DELETE_ERROR,
+                detail=f"Database real delete error in {self.model.__tablename__}: {str(e)}",
+                source_function=f"{self.__class__.__name__}.real_delete",
+                original_error=e
+            ) 

{aiteamutils-0.2.51 → aiteamutils-0.2.53}/aiteamutils/base_service.py

@@ -9,6 +9,7 @@ from .base_repository import BaseRepository
 from .security import hash_password
 from fastapi import Request
 from ulid import ULID
+from sqlalchemy import select
 
 ModelType = TypeVar("ModelType", bound=DeclarativeBase)
 
@@ -30,11 +31,29 @@ class BaseService(Generic[ModelType]):
         self.repository = repository
         self.model = repository.model
         self.additional_models = additional_models or {}
-        self.db_service = repository.db_service
+        self._session = None
         self.searchable_fields = {
             "name": {"type": "text", "description": "이름"},
             "organization_ulid": {"type": "exact", "description": "조직 ID"}
         }
+    
+    @property
+    def session(self):
+        """현재 세션을 반환합니다."""
+        if self._session is None:
+            raise CustomException(
+                ErrorCode.DB_CONNECTION_ERROR,
+                detail="Database session is not set",
+                source_function=f"{self.__class__.__name__}.session"
+            )
+        return self._session
+    
+    @session.setter
+    def session(self, value):
+        """세션을 설정합니다."""
+        self._session = value
+        if hasattr(self.repository, 'session'):
+            self.repository.session = value
 
     #########################
     # 2. 이벤트 처리 메서드 #
@@ -448,18 +467,7 @@ class BaseService(Generic[ModelType]):
             )
 
     async def delete(self, ulid: str, model_name: str = None) -> bool:
-        """엔티티를 소프트 삭제합니다 (is_deleted = True).
-
-        Args:
-            ulid (str): 삭제할 엔티티의 ULID
-            model_name (str, optional): 삭제할 모델 이름. Defaults to None.
-
-        Returns:
-            bool: 삭제 성공 여부
-
-        Raises:
-            CustomException: 데이터베이스 작업 중 오류 발생 시
-        """
+        """엔티티를 소프트 삭제합니다 (is_deleted = True)."""
         try:
             if model_name:
                 if model_name not in self.additional_models:
@@ -468,23 +476,24 @@ class BaseService(Generic[ModelType]):
                         detail=f"Model {model_name} not registered",
                         source_function=f"{self.__class__.__name__}.delete"
                     )
-                entity = await self.db_service.soft_delete_entity(self.additional_models[model_name], ulid)
+                
+                stmt = select(self.additional_models[model_name]).filter_by(ulid=ulid, is_deleted=False)
+                result = await self.session.execute(stmt)
+                entity = result.scalars().first()
+                
                 if not entity:
                     raise CustomException(
                         ErrorCode.NOT_FOUND,
                         detail=f"{self.additional_models[model_name].__tablename__}|ulid|{ulid}",
                         source_function=f"{self.__class__.__name__}.delete"
                     )
+                
+                entity.is_deleted = True
+                await self.session.flush()
                 return True
 
-            entity = await self.repository.delete(ulid)
-            if not entity:
-                raise CustomException(
-                    ErrorCode.NOT_FOUND,
-                    detail=f"{self.model.__tablename__}|ulid|{ulid}",
-                    source_function=f"{self.__class__.__name__}.delete"
-                )
-            return True
+            return await self.repository.delete(ulid)
+            
         except CustomException as e:
             raise e
         except Exception as e:
@@ -549,20 +558,7 @@ class BaseService(Generic[ModelType]):
         request: Request | None = None,
         response_model: Any = None
     ) -> List[Dict[str, Any]]:
-        """엔티티 목록을 조회합니다.
-
-        Args:
-            skip (int, optional): 건너뛸 레코드 수. Defaults to 0.
-            limit (int, optional): 조회할 최대 레코드 수. Defaults to 100.
-            filters (Dict[str, Any] | None, optional): 필터링 조건. Defaults to None.
-            search_params (Dict[str, Any] | None, optional): 검색 파라미터. Defaults to None.
-            model_name (str | None, optional): 조회할 모델 이름. Defaults to None.
-            request (Request | None, optional): 요청 객체. Defaults to None.
-            response_model (Any, optional): 응답 스키마. Defaults to None.
-
-        Returns:
-            List[Dict[str, Any]]: 엔티티 목록
-        """
+        """엔티티 목록을 조회합니다."""
         try:
             if model_name:
                 if model_name not in self.additional_models:
@@ -571,21 +567,28 @@ class BaseService(Generic[ModelType]):
                         detail=f"Model {model_name} not registered",
                         source_function=f"{self.__class__.__name__}.list"
                     )
-                entities = await self.db_service.list_entities(
-                    self.additional_models[model_name],
-                    skip=skip,
-                    limit=limit,
-                    filters=filters
+                
+                stmt = select(self.additional_models[model_name]).where(
+                    self.additional_models[model_name].is_deleted == False
                 )
+                
+                if filters:
+                    for key, value in filters.items():
+                        if value is not None:
+                            stmt = stmt.where(getattr(self.additional_models[model_name], key) == value)
+                
+                stmt = stmt.offset(skip).limit(limit)
+                result = await self.session.execute(stmt)
+                entities = result.scalars().all()
+                
                 return [self._process_response(entity, response_model) for entity in entities]
 
-            entities = await self.repository.list(
+            return await self.repository.list(
                 skip=skip,
                 limit=limit,
                 filters=filters,
                 search_params=search_params
             )
-            return [self._process_response(entity, response_model) for entity in entities]
             
         except CustomException as e:
             e.detail = f"Service list error for {self.repository.model.__tablename__}: {e.detail}"

{aiteamutils-0.2.51 → aiteamutils-0.2.53}/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,6 +997,24 @@ 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]:
     """데이터베이스 세션 의존성
 

aiteamutils-0.2.53/aiteamutils/dependencies.py

@@ -0,0 +1,213 @@
+"""의존성 관리 모듈."""
+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 .exceptions import CustomException, ErrorCode
+from .config import get_settings
+from .base_service import BaseService
+from .base_repository import BaseRepository
+from .database import db_manager
+
+T = TypeVar("T", bound=BaseService)
+R = TypeVar("R", bound=BaseRepository)
+
+_service_registry: Dict[str, Dict[str, Any]] = {}
+
+async def get_db() -> AsyncGenerator[AsyncSession, None]:
+    """데이터베이스 세션을 반환합니다.
+    
+    Yields:
+        AsyncSession: 데이터베이스 세션
+        
+    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:
+    """서비스를 등록합니다.
+    
+    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 요청 객체
+        
+    Returns:
+        BaseService: 서비스 인스턴스
+        
+    Raises:
+        CustomException: 서비스 생성 실패 시
+    """
+    try:
+        service_info = _service_registry.get(service_name)
+        if not service_info:
+            raise CustomException(
+                ErrorCode.SERVICE_NOT_FOUND,
+                detail=service_name,
+                source_function="dependencies._get_service"
+            )
+            
+        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:
+        service_name: 서비스 이름
+        
+    Returns:
+        Callable: 서비스 의존성 함수
+    """
+    async def _get_service_dependency(
+        request: Request,
+        session: AsyncSession = Depends(get_db)
+    ) -> BaseService:
+        return await _get_service(service_name, session, request)
+    return _get_service_dependency
+
+async def get_current_user(
+    request: Request,
+    session: AsyncSession = Depends(get_db),
+    auth_service: BaseService = Depends(get_service("AuthService"))
+) -> Dict[str, Any]:
+    """현재 사용자 정보를 반환합니다.
+    
+    Args:
+        request: FastAPI 요청 객체
+        session: 데이터베이스 세션
+        auth_service: 인증 서비스
+        
+    Returns:
+        Dict[str, Any]: 사용자 정보
+        
+    Raises:
+        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:
+        # JWT 토큰 디코딩
+        payload = jwt.decode(
+            token,
+            settings.jwt_secret,
+            algorithms=[settings.jwt_algorithm],
+            issuer=settings.token_issuer,
+            audience=settings.token_audience
+        )
+        
+        # 토큰 타입 검증
+        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 HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid token payload",
+                headers={"WWW-Authenticate": "Bearer"}
+            )
+            
+        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"}
+        )
+    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"}
+        )