aiteamutils 0.2.58__py3-none-any.whl → 0.2.59__py3-none-any.whl

aiteamutils/base_service.py

@@ -1,393 +1,109 @@
 """기본 서비스 모듈."""
 from datetime import datetime
-from typing import TypeVar, Generic, Dict, Any, List, Optional, Type, Union
-from sqlalchemy.orm import DeclarativeBase, Load
-from sqlalchemy.exc import IntegrityError, SQLAlchemyError
+from typing import TypeVar, Generic, Dict, Any, List, Optional, Type
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import DeclarativeBase
+from fastapi import Request
+
 from .database import DatabaseService
 from .exceptions import CustomException, ErrorCode
 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)
 
 class BaseService(Generic[ModelType]):
-
-    ##################
-    # 1. 초기화 영역 #
-    ##################
     def __init__(
         self,
-        repository: BaseRepository[ModelType],
-        additional_models: Dict[str, Type[DeclarativeBase]] = None
+        db: DatabaseService,
+        repository: Optional[BaseRepository] = None,
+        request: Optional[Request] = None
     ):
-        """
-        Args:
-            repository (BaseRepository[ModelType]): 레포지토리 인스턴스
-            additional_models (Dict[str, Type[DeclarativeBase]], optional): 추가 모델 매핑. Defaults to None.
-        """
-        self.repository = repository
-        self.model = repository.model
-        self.additional_models = additional_models or {}
-        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. 이벤트 처리 메서드 #
-    #########################
-    async def pre_save(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """저장 전 처리를 수행합니다.
-
-        Args:
-            data (Dict[str, Any]): 저장할 데이터
-
-        Returns:
-            Dict[str, Any]: 처리된 데이터
-        """
-        return data
-
-    async def post_save(self, entity: ModelType) -> None:
-        """저장 후 처리를 수행합니다.
-
-        Args:
-            entity (ModelType): 저장된 엔티티
-        """
-        pass
-
-    async def pre_delete(self, ulid: str) -> None:
-        """삭제 전 처리를 수행합니다.
-
-        Args:
-            ulid (str): 삭제할 엔티티의 ULID
-        """
-        pass
-
-    async def post_delete(self, ulid: str) -> None:
-        """삭제 후 처리를 수행합니다.
-
-        Args:
-            ulid (str): 삭제된 엔티티의 ULID
-        """
-        pass
-
-    ######################
-    # 3. 캐시 관리 메서드 #
-    ######################
-    async def get_from_cache(self, key: str) -> Optional[Any]:
-        """캐시에서 데이터를 조회합니다.
-
-        Args:
-            key (str): 캐시 키
-
-        Returns:
-            Optional[Any]: 캐시된 데이터 또는 None
-        """
-        return None
-
-    async def set_to_cache(self, key: str, value: Any, ttl: int = 3600) -> None:
-        """데이터를 캐시에 저장합니다.
-
-        Args:
-            key (str): 캐시 키
-            value (Any): 저장할 값
-            ttl (int, optional): 캐시 유효 시간(초). Defaults to 3600.
-        """
-        pass
-
-    async def invalidate_cache(self, key: str) -> None:
-        """캐시를 무효화합니다.
-
-        Args:
-            key (str): 캐시 키
-        """
-        pass
-    
-    ##########################
-    # 4. 비즈니스 검증 메서드 #
-    ##########################
-    def _validate_business_rules(self, data: Dict[str, Any]) -> None:
-        """비즈니스 규칙을 검증합니다.
-
-        Args:
-            data (Dict[str, Any]): 검증할 데이터
-
-        Raises:
-            CustomException: 비즈니스 규칙 위반 시
-        """
-        pass
-
-    def _validate_permissions(self, request: Request, action: str) -> None:
-        """권한을 검증합니다.
-
-        Args:
-            request (Request): FastAPI 요청 객체
-            action (str): 수행할 작업
-
-        Raises:
-            CustomException: 권한이 없는 경우
-        """
-        pass
-
-    ########################
-    # 5. 응답 처리 메서드   #
-    ########################
-    def _handle_response_model(self, entity: ModelType, response_model: Any) -> Dict[str, Any]:
-        """응답 모델에 맞게 데이터를 처리합니다.
-
-        Args:
-            entity (ModelType): 처리할 엔티티
-            response_model (Any): 응답 모델
-
-        Returns:
-            Dict[str, Any]: 처리된 데이터
-        """
-        if not response_model:
-            return self._process_response(entity)
-            
-        result = self._process_response(entity)
+        """BaseService 초기화
         
-        # response_model에 없는 필드 제거
-        keys_to_remove = [key for key in result if key not in response_model.model_fields]
-        for key in keys_to_remove:
-            result.pop(key)
-            
-        # 모델 검증
-        return response_model(**result).model_dump()
-
-    def _handle_exclude_fields(self, data: Dict[str, Any], exclude_fields: List[str]) -> Dict[str, Any]:
-        """제외할 필드를 처리합니다.
-
         Args:
-            data (Dict[str, Any]): 처리할 데이터
-            exclude_fields (List[str]): 제외할 필드 목록
-
-        Returns:
-            Dict[str, Any]: 처리된 데이터
-        """
-        if not exclude_fields:
-            return data
-            
-        return {k: v for k, v in data.items() if k not in exclude_fields}
-
-    def _validate_ulid(self, ulid: str) -> bool:
-        """ULID 형식을 검증합니다.
-
-        Args:
-            ulid (str): 검증할 ULID
-
-        Returns:
-            bool: 유효한 ULID 여부
+            db: 데이터베이스 서비스
+            repository: 레포지토리 인스턴스 (선택)
+            request: FastAPI 요청 객체 (선택)
         """
-        try:
-            ULID.from_str(ulid)
-            return True
-        except (ValueError, AttributeError):
-            return False
-
-    def _process_columns(self, entity: ModelType, exclude_extra_data: bool = True) -> Dict[str, Any]:
-        """엔티티의 컬럼들을 처리합니다.
-
-        Args:
-            entity (ModelType): 처리할 엔티티
-            exclude_extra_data (bool, optional): extra_data 컬럼 제외 여부. Defaults to True.
-
-        Returns:
-            Dict[str, Any]: 처리된 컬럼 데이터
-        """
-        result = {}
-        for column in entity.__table__.columns:
-            if exclude_extra_data and column.name == 'extra_data':
-                continue
-                
-            # 필드 값 처리
-            if hasattr(entity, column.name):
-                value = getattr(entity, column.name)
-                if isinstance(value, datetime):
-                    value = value.isoformat()
-                result[column.name] = value
-            elif hasattr(entity, 'extra_data') and isinstance(entity.extra_data, dict):
-                result[column.name] = entity.extra_data.get(column.name)
-            else:
-                result[column.name] = None
-        
-        # extra_data의 내용을 최상위 레벨로 업데이트
-        if hasattr(entity, 'extra_data') and isinstance(entity.extra_data, dict):
-            result.update(entity.extra_data or {})
-                
-        return result
+        self.db = db
+        self.repository = repository
+        self.request = request
+        self.model = repository.model if repository else None
 
     def _process_response(self, entity: ModelType, response_model: Any = None) -> Dict[str, Any]:
         """응답 데이터를 처리합니다.
-        extra_data의 내용을 최상위 레벨로 변환하고, 라우터에서 선언한 응답 스키마에 맞게 데이터를 변환합니다.
-
+        
         Args:
-            entity (ModelType): 처리할 엔티티
-            response_model (Any, optional): 응답 스키마. Defaults to None.
-
+            entity: 처리할 엔티티
+            response_model: 응답 모델 클래스
+            
         Returns:
-            Dict[str, Any]: 처리된 엔티티 데이터
+            처리된 데이터
         """
         if not entity:
             return None
-
-        # 모든 필드 처리
-        result = self._process_columns(entity)
+            
+        # 기본 데이터 변환
+        result = {}
+        
+        # 테이블 컬럼 처리
+        for column in entity.__table__.columns:
+            value = getattr(entity, column.name)
+            if isinstance(value, datetime):
+                value = value.isoformat()
+            result[column.name] = value
         
-        # Relationship 처리 (이미 로드된 관계만 처리)
+        # Relationship 처리 (이미 로드된 관계만)
         for relationship in entity.__mapper__.relationships:
-            if not relationship.key in entity.__dict__:
+            if relationship.key not in entity.__dict__:
                 continue
                 
             try:
                 value = getattr(entity, relationship.key)
-                # response_model이 있는 경우 해당 필드의 annotation type을 가져옴
-                nested_response_model = None
-                if response_model and relationship.key in response_model.model_fields:
-                    field_info = response_model.model_fields[relationship.key]
-                    nested_response_model = field_info.annotation
-                
                 if value is not None:
                     if isinstance(value, list):
                         result[relationship.key] = [
-                            self._process_response(item, nested_response_model)
+                            self._process_response(item)
                             for item in value
                         ]
                     else:
-                        result[relationship.key] = self._process_response(value, nested_response_model)
+                        result[relationship.key] = self._process_response(value)
                 else:
                     result[relationship.key] = None
             except Exception:
                 result[relationship.key] = None
-
+        
         # response_model이 있는 경우 필터링
         if response_model:
-            # 현재 키 목록을 저장
-            current_keys = list(result.keys())
-            # response_model에 없는 키 제거
-            for key in current_keys:
-                if key not in response_model.model_fields:
-                    result.pop(key)
-            # 모델 검증 및 업데이트
-            result.update(response_model(**result).model_dump())
-                
+            # response_model에 없는 필드 제거
+            keys_to_remove = [key for key in result if key not in response_model.model_fields]
+            for key in keys_to_remove:
+                result.pop(key)
+            # 모델 검증
+            return response_model(**result).model_dump()
+            
         return result
 
-    def _process_basic_fields(self, entity: ModelType) -> Dict[str, Any]:
-        """엔티티의 기본 필드만 처리합니다.
-
+    async def create(
+        self,
+        data: Dict[str, Any],
+        response_model: Any = None
+    ) -> Dict[str, Any]:
+        """엔티티를 생성합니다.
+        
         Args:
-            entity (ModelType): 처리할 엔티티
-
-        Returns:
-            Dict[str, Any]: 기본 필드만 포함된 딕셔너리
-        """
-        if not entity:
-            return None
+            data: 생성할 데이터
+            response_model: 응답 모델 클래스
             
-        return self._process_columns(entity)
-
-    async def _create_for_model(self, model_name: str, data: Dict[str, Any], exclude_fields: List[str] = None) -> DeclarativeBase:
-        """지정된 모델에 대해 새로운 엔티티를 생성합니다.
-
-        Args:
-            model_name (str): 생성할 모델 이름
-            data (Dict[str, Any]): 생성할 엔티티 데이터
-            exclude_fields (List[str], optional): 제외할 필드 목록. Defaults to None.
-
-        Returns:
-            DeclarativeBase: 생성된 엔티티
-
-        Raises:
-            CustomException: 데이터베이스 작업 중 오류 발생 시
-        """
-        if model_name not in self.additional_models:
-            raise CustomException(
-                ErrorCode.INVALID_REQUEST,
-                detail=f"Model {model_name} not registered",
-                source_function=f"{self.__class__.__name__}._create_for_model"
-            )
-
-        try:
-            # 제외할 필드 처리
-            if exclude_fields:
-                data = {k: v for k, v in data.items() if k not in exclude_fields}
-
-            return await self.db_service.create_entity(self.additional_models[model_name], data)
-        except CustomException as e:
-            raise e
-        except Exception as e:
-            raise CustomException(
-                ErrorCode.DB_CREATE_ERROR,
-                detail=str(e),
-                source_function=f"{self.__class__.__name__}._create_for_model",
-                original_error=e
-            )
-
-    def _process_password(self, data: Dict[str, Any]) -> Dict[str, Any]:
-        """비밀번호 필드가 있는 경우 해시화합니다.
-
-        Args:
-            data (Dict[str, Any]): 처리할 데이터
-
-        Returns:
-            Dict[str, Any]: 처리된 데이터
-        """
-        if "password" in data:
-            data["password"] = hash_password(data["password"])
-        return data
-
-    #######################
-    # 6. CRUD 작업 메서드 #
-    #######################
-    async def create(self, data: Dict[str, Any], exclude_fields: List[str] = None, model_name: str = None) -> Union[ModelType, DeclarativeBase]:
-        """새로운 엔티티를 생성합니다.
-
-        Args:
-            data (Dict[str, Any]): 생성할 엔티티 데이터
-            exclude_fields (List[str], optional): 제외할 필드 목록. Defaults to None.
-            model_name (str, optional): 생성할 모델 이름. Defaults to None.
-
         Returns:
-            Union[ModelType, DeclarativeBase]: 생성된 엔티티
-
+            생성된 엔티티
+            
         Raises:
-            CustomException: 데이터베이스 작업 중 오류 발생 시
+            CustomException: 생성 실패 시
         """
         try:
-            # 비밀번호 해시화
-            data = self._process_password(data)
-
-            # 제외할 필드 처리
-            if exclude_fields:
-                data = {k: v for k, v in data.items() if k not in exclude_fields}
-
-            if model_name:
-                return await self._create_for_model(model_name, data)
-
-            return await self.repository.create(data)
+            entity = await self.db.create_entity(self.model, data)
+            return self._process_response(entity, response_model)
         except CustomException as e:
             raise e
         except Exception as e:
@@ -398,274 +114,147 @@ class BaseService(Generic[ModelType]):
                 original_error=e
             )
 
-    async def update(
+    async def get(
         self,
         ulid: str,
-        data: Dict[str, Any],
-        exclude_fields: List[str] = None,
-        model_name: str = None
-    ) -> Optional[ModelType]:
-        """기존 엔티티를 수정합니다.
-
+        response_model: Any = None
+    ) -> Dict[str, Any]:
+        """엔티티를 조회합니다.
+        
         Args:
-            ulid (str): 수정할 엔티티의 ULID
-            data (Dict[str, Any]): 수정할 데이터
-            exclude_fields (List[str], optional): 제외할 필드 목록. Defaults to None.
-            model_name (str, optional): 수정할 모델 이름. Defaults to None.
-
-        Returns:
-            Optional[ModelType]: 수정된 엔티티, 없으면 None
-
-        Raises:
-            CustomException: 데이터베이스 작업 중 오류 발생 시
-        """
-        try:
-            # 비밀번호 해시화
-            data = self._process_password(data)
-
-            # 제외할 필드 처리
-            if exclude_fields:
-                data = {k: v for k, v in data.items() if k not in exclude_fields}
-
-            async with self.db_service.transaction():
-                if model_name:
-                    if model_name not in self.additional_models:
-                        raise CustomException(
-                            ErrorCode.INVALID_REQUEST,
-                            detail=f"Model {model_name} not registered",
-                            source_function=f"{self.__class__.__name__}.update"
-                        )
-                    entity = await self.db_service.update_entity(
-                        self.additional_models[model_name],
-                        {"ulid": ulid},
-                        data
-                    )
-                    if not entity:
-                        raise CustomException(
-                            ErrorCode.NOT_FOUND,
-                            detail=f"{self.additional_models[model_name].__tablename__}|ulid|{ulid}",
-                            source_function=f"{self.__class__.__name__}.update"
-                        )
-                    return entity
-
-                entity = await self.repository.update(ulid, data)
-                if not entity:
-                    raise CustomException(
-                        ErrorCode.NOT_FOUND,
-                        detail=f"{self.model.__tablename__}|ulid|{ulid}",
-                        source_function=f"{self.__class__.__name__}.update"
-                    )
-                return entity
-        except CustomException as e:
-            raise e
-        except Exception as e:
-            raise CustomException(
-                ErrorCode.DB_UPDATE_ERROR,
-                detail=str(e),
-                source_function=f"{self.__class__.__name__}.update",
-                original_error=e
-            )
-
-    async def delete(self, ulid: str, model_name: str = None) -> bool:
-        """엔티티를 소프트 삭제합니다 (is_deleted = True)."""
-        try:
-            if model_name:
-                if model_name not in self.additional_models:
-                    raise CustomException(
-                        ErrorCode.INVALID_REQUEST,
-                        detail=f"Model {model_name} not registered",
-                        source_function=f"{self.__class__.__name__}.delete"
-                    )
-                
-                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
-
-            return await self.repository.delete(ulid)
+            ulid: 조회할 엔티티의 ULID
+            response_model: 응답 모델 클래스
             
-        except CustomException as e:
-            raise e
-        except Exception as e:
-            raise CustomException(
-                ErrorCode.DB_DELETE_ERROR,
-                detail=str(e),
-                source_function=f"{self.__class__.__name__}.delete",
-                original_error=e
-            )
-
-    async def real_row_delete(self, ulid: str, model_name: str = None) -> bool:
-        """엔티티를 실제로 삭제합니다.
-
-        Args:
-            ulid (str): 삭제할 엔티티의 ULID
-            model_name (str, optional): 삭제할 모델 이름. Defaults to None.
-
         Returns:
-            bool: 삭제 성공 여부
-
+            조회된 엔티티
+            
         Raises:
-            CustomException: 데이터베이스 작업 중 오류 발생 시
+            CustomException: 조회 실패 시
         """
         try:
-            if model_name:
-                if model_name not in self.additional_models:
-                    raise CustomException(
-                        ErrorCode.INVALID_REQUEST,
-                        detail=f"Model {model_name} not registered",
-                        source_function=f"{self.__class__.__name__}.real_row_delete"
-                    )
-                entity = await self.db_service.retrieve_entity(
-                    self.additional_models[model_name],
-                    {"ulid": ulid}
+            entity = await self.db.get_entity(self.model, {"ulid": ulid, "is_deleted": False})
+            if not entity:
+                raise CustomException(
+                    ErrorCode.NOT_FOUND,
+                    detail=f"{self.model.__tablename__}|ulid|{ulid}",
+                    source_function=f"{self.__class__.__name__}.get"
                 )
-                if entity:
-                    await self.db_service.delete_entity(entity)
-                    return True
-                return False
-
-            return await self.repository.real_row_delete(ulid)
+            return self._process_response(entity, response_model)
         except CustomException as e:
             raise e
         except Exception as e:
             raise CustomException(
-                ErrorCode.DB_DELETE_ERROR,
+                ErrorCode.DB_QUERY_ERROR,
                 detail=str(e),
-                source_function=f"{self.__class__.__name__}.real_row_delete",
+                source_function=f"{self.__class__.__name__}.get",
                 original_error=e
             )
 
-    #########################
-    # 7. 조회 및 검색 메서드 #
-    #########################
     async def list(
         self,
         skip: int = 0,
         limit: int = 100,
-        filters: Dict[str, Any] | None = None,
-        search_params: Dict[str, Any] | None = None,
-        model_name: str | None = None,
-        request: Request | None = None,
+        filters: Optional[Dict[str, Any]] = None,
         response_model: Any = None
     ) -> List[Dict[str, Any]]:
-        """엔티티 목록을 조회합니다."""
+        """엔티티 목록을 조회합니다.
+        
+        Args:
+            skip: 건너뛸 레코드 수
+            limit: 조회할 최대 레코드 수
+            filters: 필터 조건
+            response_model: 응답 모델 클래스
+            
+        Returns:
+            엔티티 목록
+            
+        Raises:
+            CustomException: 조회 실패 시
+        """
         try:
-            if model_name:
-                if model_name not in self.additional_models:
-                    raise CustomException(
-                        ErrorCode.INVALID_REQUEST,
-                        detail=f"Model {model_name} not registered",
-                        source_function=f"{self.__class__.__name__}.list"
-                    )
-                
-                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]
-
-            return await self.repository.list(
-                skip=skip,
-                limit=limit,
+            entities = await self.db.list_entities(
+                self.model,
                 filters=filters,
-                search_params=search_params
+                skip=skip,
+                limit=limit
             )
-            
+            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}"
-            e.source_function = f"{self.__class__.__name__}.list -> {e.source_function}"
             raise e
         except Exception as e:
             raise CustomException(
-                ErrorCode.INTERNAL_ERROR,
+                ErrorCode.DB_QUERY_ERROR,
                 detail=str(e),
                 source_function=f"{self.__class__.__name__}.list",
                 original_error=e
             )
 
-    async def get(
+    async def update(
         self,
         ulid: str,
-        model_name: str | None = None,
-        request: Request | None = None,
+        data: Dict[str, Any],
         response_model: Any = None
-    ) -> Optional[Dict[str, Any]]:
-        """특정 엔티티를 조회합니다.
-
+    ) -> Dict[str, Any]:
+        """엔티티를 수정합니다.
+        
         Args:
-            ulid (str): 조회할 엔티티의 ULID
-            model_name (str | None, optional): 조회할 모델 이름. Defaults to None.
-            request (Request | None, optional): 요청 객체. Defaults to None.
-            response_model (Any, optional): 응답 스키마. Defaults to None.
-
+            ulid: 수정할 엔티티의 ULID
+            data: 수정할 데이터
+            response_model: 응답 모델 클래스
+            
         Returns:
-            Optional[Dict[str, Any]]: 조회된 엔티티, 없으면 None
+            수정된 엔티티
             
         Raises:
-            CustomException: 데이터베이스 작업 중 오류 발생 시
+            CustomException: 수정 실패 시
         """
         try:
-            # ULID 검증
-            if not self._validate_ulid(ulid):
+            entity = await self.db.get_entity(self.model, {"ulid": ulid, "is_deleted": False})
+            if not entity:
                 raise CustomException(
-                    ErrorCode.VALIDATION_ERROR,
-                    detail=f"Invalid ULID format: {ulid}",
-                    source_function=f"{self.__class__.__name__}.get"
-                )
-
-            if model_name:
-                if model_name not in self.additional_models:
-                    raise CustomException(
-                        ErrorCode.INVALID_REQUEST,
-                        detail=f"Model {model_name} not registered",
-                        source_function=f"{self.__class__.__name__}.get"
-                    )
-                entity = await self.db_service.retrieve_entity(
-                    self.additional_models[model_name],
-                    {"ulid": ulid, "is_deleted": False}
+                    ErrorCode.NOT_FOUND,
+                    detail=f"{self.model.__tablename__}|ulid|{ulid}",
+                    source_function=f"{self.__class__.__name__}.update"
                 )
-                if not entity:
-                    raise CustomException(
-                        ErrorCode.NOT_FOUND,
-                        detail=f"{self.additional_models[model_name].__tablename__}|ulid|{ulid}",
-                        source_function=f"{self.__class__.__name__}.get"
-                    )
-                return self._process_response(entity, response_model)
+            updated = await self.db.update_entity(entity, data)
+            return self._process_response(updated, response_model)
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.DB_UPDATE_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}.update",
+                original_error=e
+            )
 
-            entity = await self.repository.get(ulid)
+    async def delete(self, ulid: str) -> bool:
+        """엔티티를 삭제합니다.
+        
+        Args:
+            ulid: 삭제할 엔티티의 ULID
+            
+        Returns:
+            삭제 성공 여부
+            
+        Raises:
+            CustomException: 삭제 실패 시
+        """
+        try:
+            entity = await self.db.get_entity(self.model, {"ulid": ulid, "is_deleted": False})
             if not entity:
                 raise CustomException(
                     ErrorCode.NOT_FOUND,
                     detail=f"{self.model.__tablename__}|ulid|{ulid}",
-                    source_function=f"{self.__class__.__name__}.get"
+                    source_function=f"{self.__class__.__name__}.delete"
                 )
-
-            return self._process_response(entity, response_model)
+            return await self.db.delete_entity(entity)
         except CustomException as e:
             raise e
         except Exception as e:
             raise CustomException(
-                ErrorCode.INTERNAL_ERROR,
+                ErrorCode.DB_DELETE_ERROR,
                 detail=str(e),
-                source_function=f"{self.__class__.__name__}.get",
+                source_function=f"{self.__class__.__name__}.delete",
                 original_error=e
             ) 

aiteamutils/dependencies.py

@@ -1,12 +1,9 @@
 """의존성 관리 모듈."""
 from typing import Type, TypeVar, Dict, Any, Optional, Callable, List, AsyncGenerator
-from fastapi import Request, Depends, HTTPException, status
+from fastapi import Request, Depends
 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 DatabaseService
@@ -20,8 +17,7 @@ _session_provider = None
 __all__ = [
     "setup_dependencies",
     "register_service",
-    "get_service",
-    "get_current_user"
+    "get_service"
 ]
 
 def setup_dependencies(session_provider: Callable[[], AsyncGenerator[AsyncSession, None]]) -> None:
@@ -139,89 +135,4 @@ def get_service(service_name: str) -> Callable:
         session: AsyncSession = Depends(_session_provider)
     ) -> BaseService:
         return await _get_service(service_name, session, request)
-    return _get_service_dependency
-
-async def get_current_user(
-    request: Request,
-    session: AsyncSession,
-    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"}
-        )
+    return _get_service_dependency

aiteamutils/version.py

@@ -1,2 +1,2 @@
 """버전 정보"""
-__version__ = "0.2.58"
+__version__ = "0.2.59"

{aiteamutils-0.2.58.dist-info → aiteamutils-0.2.59.dist-info}/METADATA

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

{aiteamutils-0.2.58.dist-info → aiteamutils-0.2.59.dist-info}/RECORD

@@ -1,16 +1,16 @@
 aiteamutils/__init__.py,sha256=U9UEyU0AqpLZzbPJiBvwDEh-s2405y1IeWZ0zCqFSl0,1307
 aiteamutils/base_model.py,sha256=ODEnjvUVoxQ1RPCfq8-uZTfTADIA4c7Z3E6G4EVsSX0,2708
 aiteamutils/base_repository.py,sha256=vqsundoN0h7FVvgqTBEnnJNMcFpvMK0s_nxBWdIYg-U,7846
-aiteamutils/base_service.py,sha256=s2AcA-6_ogOQKgt2xf_3AG2s6tqBceU4nJoXO1II7S8,24588
+aiteamutils/base_service.py,sha256=o4oeX__RmUFp5kV-fb4VwBhF8nTAZNMjoWJvK7G1Wmk,8615
 aiteamutils/cache.py,sha256=07xBGlgAwOTAdY5mnMOQJ5EBxVwe8glVD7DkGEkxCtw,1373
 aiteamutils/config.py,sha256=YdalpJb70-txhGJAS4aaKglEZAFVWgfzw5BXSWpkUz4,3232
 aiteamutils/database.py,sha256=x0x5gnSyGfwo_klL9O65RnGOQID6c9tH2miwFveVyoE,6326
-aiteamutils/dependencies.py,sha256=UjHGgee4qKxPwHJnfMZ3YKB7m7UQNIvKNr7IdOx590c,6899
+aiteamutils/dependencies.py,sha256=Qoy_M7r65Fv3Y8RMVBi81QLdfjfWIk-pm7O5_Przsa4,4084
 aiteamutils/enums.py,sha256=ipZi6k_QD5-3QV7Yzv7bnL0MjDz-vqfO9I5L77biMKs,632
 aiteamutils/exceptions.py,sha256=_lKWXq_ujNj41xN6LDE149PwsecAP7lgYWbOBbLOntg,15368
 aiteamutils/security.py,sha256=xFVrjttxwXB1TTjqgRQQgQJQohQBT28vuW8FVLjvi-M,10103
 aiteamutils/validators.py,sha256=3N245cZFjgwtW_KzjESkizx5BBUDaJLbbxfNO4WOFZ0,7764
-aiteamutils/version.py,sha256=57HkAV8pVrmV03eTVINw5qTQURkXwGPl2H--uJC4OWs,42
-aiteamutils-0.2.58.dist-info/METADATA,sha256=yULGE3mtpwvWXzHDczGJfqu52urFzknJhm5V9PgCOGc,1718
-aiteamutils-0.2.58.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aiteamutils-0.2.58.dist-info/RECORD,,
+aiteamutils/version.py,sha256=_ql6JzqtHA14js-9_8pUBJDK_7BZm5uHqA1j4jfryCs,42
+aiteamutils-0.2.59.dist-info/METADATA,sha256=OOT0-1lTWlUQv7fL2MtELHAUPSj18nqiaiXRyFc8QoQ,1718
+aiteamutils-0.2.59.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aiteamutils-0.2.59.dist-info/RECORD,,