aiteamutils 0.2.72__py3-none-any.whl → 0.2.75__py3-none-any.whl

aiteamutils/base_model.py

@@ -23,10 +23,17 @@ class BaseColumn(Base):
         doc="ULID",
         nullable=False
     )
-    created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow)
+    created_at: Mapped[datetime] = mapped_column(
+        default=datetime.utcnow,
+        index=True
+    )
     updated_at: Mapped[datetime] = mapped_column(
         default=datetime.utcnow,
-        onupdate=datetime.utcnow
+        onupdate=datetime.utcnow,
+        index=True
+    )
+    deleted_at: Mapped[datetime] = mapped_column(
+        default=None,
     )
     is_deleted: Mapped[bool] = mapped_column(
         default=False,

aiteamutils/base_repository.py

@@ -7,7 +7,13 @@ from sqlalchemy import select
 
 #패키지 라이브러리
 from .exceptions import ErrorCode, CustomException
-from .database import list_entities
+from .database import (
+    list_entities,
+    get_entity,
+    create_entity,
+    update_entity,
+    delete_entity
+)
 
 ModelType = TypeVar("ModelType", bound=DeclarativeBase)
 
@@ -29,13 +35,62 @@ class BaseRepository(Generic[ModelType]):
                 source_function=f"{self.__class__.__name__}.session"
             )
         self._session = value
+   
+    #######################
+    # 입력 및 수정, 삭제 #
+    ####################### 
+    async def create(self, entity_data: Dict[str, Any]) -> ModelType:
+        try:
+            return await create_entity(
+                session=self.session,
+                model=self.model,
+                entity_data=entity_data
+            )
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}.create",
+                original_error=e
+            )
+        
+    async def update(
+        self,
+        update_data: Dict[str, Any],
+        conditions: Dict[str, Any]
+    ) -> ModelType:
+        try:
+            return await update_entity(
+                session=self.session,
+                model=self.model,
+                update_data=update_data,
+                conditions=conditions
+            )
+        except CustomException as e:
+            raise e
+        
+    async def delete(
+        self,
+        conditions: Dict[str, Any]
+    ) -> None:
+        await delete_entity(
+            session=self.session,
+            model=self.model,
+            conditions=conditions
+        )
     
+    #########################
+    # 조회 및 검색 메서드 #
+    #########################
     async def list(
         self,
         skip: int = 0,
         limit: int = 100,
         filters: Optional[Dict[str, Any]] = None,
-        joins: Optional[List[Any]] = None,
+        explicit_joins: Optional[List[Any]] = None,
+        loading_joins: Optional[List[Any]] = None
     ) -> List[ModelType]:
         """
         엔티티 목록 조회.
@@ -48,11 +103,10 @@ class BaseRepository(Generic[ModelType]):
                 skip=skip,
                 limit=limit,
                 filters=filters,
-                joins=joins,
+                explicit_joins=explicit_joins,
+                loading_joins=loading_joins
             )
         except CustomException as e:
-            e.detail = f"Repository list error for {self.model.__tablename__}: {e.detail}"
-            e.source_function = f"{self.__class__.__name__}.list -> {e.source_function}"
             raise e
         except Exception as e:
             raise CustomException(
@@ -61,3 +115,27 @@ class BaseRepository(Generic[ModelType]):
                 source_function=f"{self.__class__.__name__}.list",
                 original_error=e
             )
+        
+    async def get(
+        self,
+        conditions: Dict[str, Any] | None = None,
+        explicit_joins: Optional[List[Any]] = None,
+        loading_joins: Optional[List[Any]] = None
+    ) -> ModelType:
+        try:
+            return await get_entity(
+                session=self.session,
+                model=self.model,
+                conditions=conditions,
+                explicit_joins=explicit_joins,
+                loading_joins=loading_joins
+            )
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}.get",
+                original_error=e
+            )

aiteamutils/base_service.py

@@ -1,18 +1,19 @@
 #기본 라이브러리
 from fastapi import Request
-from typing import TypeVar, Generic, Type, Dict, Any, Union, List
+from typing import TypeVar, Generic, Type, Dict, Any, Union, List, Optional
 from sqlalchemy.orm import DeclarativeBase
 from sqlalchemy.ext.asyncio import AsyncSession
 from datetime import datetime
+from ulid import ULID
 
 #패키지 라이브러리
 from .exceptions import ErrorCode, CustomException
 from .base_repository import BaseRepository
 from .database import (
     process_response,
-    build_search_filters
+    validate_unique_fields
 )
-
+from .security import hash_password
 ModelType = TypeVar("ModelType", bound=DeclarativeBase)
 
 class BaseService(Generic[ModelType]):
@@ -30,27 +31,151 @@ class BaseService(Generic[ModelType]):
         self.repository = repository
         self.db_session = db_session
         self.additional_models = additional_models or {},
+    
+    #######################
+    # 입력 및 수정, 삭제 #
+    #######################
+    async def create(
+        self,
+        entity_data: Dict[str, Any],
+        model_name: str | None = None,
+        response_model: Any = None,
+        exclude_entities: List[str] | None = None,
+        unique_check: List[Dict[str, Any]] | None = None,
+        fk_check: List[Dict[str, Any]] | None = None,
+    ) -> ModelType:
+        
+        try:
+            # 고유 검사 수행
+            if unique_check:
+                await validate_unique_fields(self.db_session, unique_check, find_value=True)
+            # 외래 키 검사 수행
+            if fk_check:
+                await validate_unique_fields(self.db_session, fk_check, find_value=False)
+            # 비밀번호가 있으면 해시 처리
+            if "password" in entity_data:
+                entity_data["password"] = hash_password(entity_data["password"])
+            # 제외할 엔티티가 있으면 제외
+            if exclude_entities:
+                entity_data = {k: v for k, v in entity_data.items() if k not in exclude_entities}
+
+            # repository의 create 메서드를 트랜잭션 내에서 실행
+            return await self.repository.create(entity_data)
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            # 다른 예외 처리
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}.create",
+                original_error=e
+            )
+        
+    async def update(
+        self,
+        ulid: str | None = None,
+        update_data: Dict[str, Any] | None = None,
+        conditions: Dict[str, Any] | None = None,
+        unique_check: List[Dict[str, Any]] | None = None,
+        exclude_entities: List[str] | None = None
+    ) -> ModelType:
+        try:
+            # 고유 검사 수행
+            if unique_check:
+                await validate_unique_fields(self.db_session, unique_check, find_value=True)
+            # 비밀번호가 있으면 해시 처리
+            if "password" in update_data:
+                update_data["password"] = hash_password(update_data["password"])
+            # 제외할 엔티티가 있으면 제외
+            if exclude_entities:
+                update_data = {k: v for k, v in update_data.items() if k not in exclude_entities}
+
+            if not ulid and not conditions:
+                raise CustomException(
+                    ErrorCode.INVALID_INPUT,
+                    detail="Either 'ulid' or 'conditions' must be provided.",
+                    source_function="database.update_entity"
+                )
+
+            # ulid로 조건 생성
+            if ulid:
+                if not ULID.from_str(ulid):
+                    raise CustomException(
+                        ErrorCode.VALIDATION_ERROR,
+                        detail=ulid,
+                        source_function=f"{self.__class__.__name__}.update"
+                    )
+                
+                conditions = {"ulid": ulid}
+
+            return await self.repository.update(
+                update_data=update_data,
+                conditions=conditions
+            )
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}.update",
+                original_error=e
+            )
+
+    async def delete(
+        self,
+        ulid: str | None = None,
+        conditions: Dict[str, Any] | None = None
+    ) -> None:
+        try:
+            if not ULID.from_str(ulid):
+                raise CustomException(
+                    ErrorCode.VALIDATION_ERROR,
+                    detail=ulid,
+                    source_function=f"{self.__class__.__name__}.delete"
+                )
+            
+            if not ulid and not conditions:
+                raise CustomException(
+                    ErrorCode.INVALID_INPUT,
+                    detail="Either 'ulid' or 'conditions' must be provided.",
+                    source_function="database.update_entity"
+                )
 
+            # ulid로 조건 생성
+            if ulid:
+                conditions = {"ulid": ulid}
+
+            conditions["is_deleted"] = False
+
+            return await self.repository.delete(
+                conditions=conditions
+            )
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}.delete",
+                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,
+        filters: List[Dict[str, Any]] | None = None,
         model_name: str | None = None,
-        request: Request | None = None,
-        response_model: Any = None
+        response_model: Any = None,
+        explicit_joins: Optional[List[Any]] = None,
+        loading_joins: Optional[List[Any]] = None
     ) -> List[Dict[str, Any]]:
         try:
-            # 검색 조건 처리 및 필터 병합
-            if search_params:
-                search_filters = build_search_filters(request, search_params)
-                if filters:
-                    # 기존 filters와 search_filters 병합 (search_filters가 우선 적용)
-                    filters.update(search_filters)
-                else:
-                    filters = search_filters
-
             # 모델 이름을 통한 동적 처리
             if model_name:
                 if model_name not in self.additional_models:
@@ -60,19 +185,74 @@ class BaseService(Generic[ModelType]):
                         source_function=f"{self.__class__.__name__}.list"
                     )
                 model = self.additional_models[model_name]
-                return await self.repository.list(skip=skip, limit=limit, filters=filters, model=model)
+                entities = await self.repository.list(
+                    skip=skip,
+                    limit=limit,
+                    filters=filters,
+                    model=model
+                )
+                return [process_response(entity, response_model) for entity in entities]
 
-            return await self.repository.list(skip=skip, limit=limit, filters=filters)
+            entities = await self.repository.list(
+                skip=skip,
+                limit=limit,
+                filters=filters,
+                explicit_joins=explicit_joins,
+                loading_joins=loading_joins
+            )
+            return [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,
-                detail=str(e),
                 source_function=f"{self.__class__.__name__}.list",
                 original_error=e
             )
+        
+    async def get(
+        self,
+        ulid: str,
+        model_name: str | None = None,
+        response_model: Any = None,
+        conditions: Dict[str, Any] | None = None,
+        explicit_joins: Optional[List[Any]] = None,
+        loading_joins: Optional[List[Any]] = None
+    ):
+        try:
+            if not ulid and not conditions:
+                raise CustomException(
+                    ErrorCode.INVALID_INPUT,
+                    detail="Either 'ulid' or 'conditions' must be provided.",
+                    source_function="database.update_entity"
+                )
+
+            # ulid로 조건 생성
+            if ulid:
+                if not ULID.from_str(ulid):
+                    raise CustomException(
+                        ErrorCode.VALIDATION_ERROR,
+                        detail=ulid,
+                        source_function=f"{self.__class__.__name__}.update"
+                    )
+                
+                conditions = {"ulid": ulid}
+            
+            entity = await self.repository.get(
+                conditions=conditions,
+                explicit_joins=explicit_joins,
+                loading_joins=loading_joins
+            )
+            return process_response(entity, response_model)
 
+        except CustomException as e:
+            raise e
+        except Exception as e:
+            raise CustomException(
+                ErrorCode.INTERNAL_ERROR,
+                detail=str(e),
+                source_function=f"{self.__class__.__name__}.get",
+                original_error=e
+            )
 

aiteamutils/database.py

@@ -1,10 +1,24 @@
 #기본 라이브러리
-from typing import TypeVar, Generic, Type, Any, Dict, List, Optional
+from typing import (
+    TypeVar, 
+    Generic, 
+    Type, 
+    Any, 
+    Dict, 
+    List, 
+    Optional, 
+    AsyncGenerator
+)
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, and_
-from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy import select, and_, or_
+from sqlalchemy.orm import DeclarativeBase, joinedload, selectinload
 from sqlalchemy.exc import SQLAlchemyError
 from datetime import datetime
+from contextlib import asynccontextmanager
+from sqlalchemy.ext.asyncio import AsyncSession
+from fastapi import Request
+from ulid import ULID
+from sqlalchemy import MetaData, Table, insert
 
 #패키지 라이브러리
 from .exceptions import ErrorCode, CustomException
@@ -15,8 +29,62 @@ ModelType = TypeVar("ModelType", bound=DeclarativeBase)
 ##################
 # 전처리 #
 ##################
+def process_entity_data(
+    model: Type[ModelType],
+    entity_data: Dict[str, Any],
+    existing_data: Dict[str, Any] = None
+) -> Dict[str, Any]:
+    """
+    엔티티 데이터를 전처리하고 모델 속성과 extra_data를 분리합니다.
+
+    이 함수는 다음과 같은 작업을 수행합니다:
+    1. 모델의 기본 속성을 식별합니다.
+    2. Swagger 자동 생성 속성을 제외합니다.
+    3. 모델 속성에 해당하는 데이터는 model_data에 저장
+    4. 모델 속성에 없는 데이터는 extra_data에 저장
+    5. 기존 엔티티 데이터의 extra_data를 유지할 수 있습니다.
+
+    Args:
+        model (Type[ModelType]): 데이터 모델 클래스
+        entity_data (Dict[str, Any]): 처리할 엔티티 데이터
+        existing_entity_data (Dict[str, Any], optional): 기존 엔티티 데이터. Defaults to None.
+
+    Returns:
+        Dict[str, Any]: 전처리된 모델 데이터 (extra_data 포함)
+    """
+    # 모델의 속성을 가져와서 전처리합니다.
+    model_attr = {
+        attr for attr in dir(model)
+        if not attr.startswith('_') and not callable(getattr(model, attr))
+    }
+    model_data = {}
+    extra_data = {}
+
+    # 기존 엔티티 데이터가 있으면 추가
+    if existing_data and "extra_data" in existing_data:
+        extra_data = existing_data["extra_data"].copy()
+
+
+    # Swagger 자동 생성 속성 패턴
+    swagger_patterns = {"additionalProp1", "additionalProp2", "additionalProp3"}
+
+    for key, value in entity_data.items():
+        # Swagger 자동 생성 속성 무시
+        if key in swagger_patterns:
+            continue
+
+        # 모델 속성에 있는 경우 model_data에 추가
+        if key in model_attr:
+            model_data[key] = value
+        # 모델 속성에 없는 경우 extra_data에 추가
+        else:
+            extra_data[key] = value
 
+    # extra_data가 있고 모델에 extra_data 속성이 있는 경우 추가
+    if extra_data and "extra_data" in model_attr:
+        model_data["extra_data"] = extra_data
 
+    return model_data
 
 ##################
 # 응답 처리 #
@@ -115,81 +183,224 @@ def process_response(
             
     return result
 
-
 ##################
 # 조건 처리 #
 ##################
-def build_search_filters(
-        request: Dict[str, Any],
-        search_params: Dict[str, Dict[str, Any]]
-) -> Dict[str, Any]:
-    """
-    요청 데이터와 검색 파라미터를 기반으로 필터 조건을 생성합니다.
-
-    Args:
-        request: 요청 데이터 (key-value 형태).
-        search_params: 검색 조건 설정을 위한 파라미터.
-
-    Returns:
-        filters: 필터 조건 딕셔너리.
-    """
-    filters = {}
-    for key, param in search_params.items():
-        value = request.get(key)
-        if value is not None:
-            if param["like"]:
-                filters[key] = {"field": param["fields"][0], "operator": "like", "value": f"%{value}%"}
-            else:
-                filters[key] = {"field": param["fields"][0], "operator": "eq", "value": value}
-    return filters
-
 def build_conditions(
-        filters: Dict[str, Any],
-        model: Type[ModelType]
+    filters: List[Dict[str, Any]],
+    model: Type[ModelType]
 ) -> List[Any]:
     """
     필터 조건을 기반으로 SQLAlchemy 조건 리스트를 생성합니다.
 
     Args:
-        filters: 필터 조건 딕셔너리.
+        filters: 필터 조건 리스트.
         model: SQLAlchemy 모델 클래스.
 
     Returns:
         List[Any]: SQLAlchemy 조건 리스트.
     """
     conditions = []
-    for filter_data in filters.values():
-        if "." in filter_data["field"]:
-            # 관계를 따라 암묵적으로 연결된 모델의 필드 가져오기
-            related_model_name, field_name = filter_data["field"].split(".")
-            relationship_property = getattr(model, related_model_name)
-            related_model = relationship_property.property.mapper.class_
-            field = getattr(related_model, field_name)
-        else:
-            # 현재 모델의 필드 가져오기
-            field = getattr(model, filter_data["field"])
 
-        # 조건 생성
-        operator = filter_data["operator"]
-        value = filter_data["value"]
+    for filter_item in filters:
+        value = filter_item.get("value")
+        if not value:  # 값이 없으면 건너뜀
+            continue
+
+        operator = filter_item.get("operator", "eq")
+        or_conditions = []
 
-        if operator == "like":
-            conditions.append(field.ilike(f"%{value}%"))
-        elif operator == "eq":
-            conditions.append(field == value)
+        for field_path in filter_item.get("fields", []):
+            current_model = model
+
+            # 관계를 따라 필드 가져오기
+            for part in field_path.split(".")[:-1]:
+                relationship_property = getattr(current_model, part)
+                current_model = relationship_property.property.mapper.class_
+
+            field = getattr(current_model, field_path.split(".")[-1])
+
+            # 조건 생성
+            if operator == "like":
+                or_conditions.append(field.ilike(f"%{value}%"))
+            elif operator == "eq":
+                or_conditions.append(field == value)
+
+        if or_conditions:  # OR 조건이 있을 때만 추가
+            conditions.append(or_(*or_conditions))
 
     return conditions
 
 ##################
 # 쿼리 실행 #
 ##################
+async def create_entity(
+    session: AsyncSession,
+    model: Type[ModelType],
+    entity_data: Dict[str, Any]
+) -> ModelType:
+    """
+    새로운 엔티티를 데이터베이스에 생성합니다.
+
+    Args:
+        session (AsyncSession): 데이터베이스 세션
+        model (Type[ModelType]): 생성할 모델 클래스
+        entity_data (Dict[str, Any]): 엔티티 생성에 필요한 데이터
+
+    Returns:
+        ModelType: 생성된 엔티티
+
+    Raises:
+        CustomException: 엔티티 생성 중 발생하는 데이터베이스 오류
+    """
+    try:
+        # 엔티티 데이터 전처리
+        processed_data = process_entity_data(model, entity_data)
+
+        # 외래 키 필드 검증
+        
+        # 새로운 엔티티 생성
+        entity = model(**processed_data)
+        
+        # 세션에 엔티티 추가
+        session.add(entity)
+        
+        # 데이터베이스에 커밋
+        await session.flush()
+        await session.commit()
+        await session.refresh(entity)
+        
+        # 생성된 엔티티 반환
+        return entity
+    
+    except SQLAlchemyError as e:
+        # 데이터베이스 오류 발생 시 CustomException으로 변환
+        raise CustomException(
+            ErrorCode.DB_CREATE_ERROR,
+            detail=f"{model.__name__}|{str(e)}",
+            source_function="database.create_entity",
+            original_error=e
+        )
+
+async def update_entity(
+    session: AsyncSession,
+    model: Type[ModelType],
+    conditions: Dict[str, Any],
+    update_data: Dict[str, Any]
+) -> ModelType:
+    """
+    조건을 기반으로 엔티티를 조회하고 업데이트합니다.
+
+    Args:
+        session (AsyncSession): 데이터베이스 세션
+        model (Type[ModelType]): 업데이트할 모델 클래스
+        conditions (Dict[str, Any]): 엔티티 조회 조건 
+            conditions = {"user_id": 1, "status": "active"}
+        update_data (Dict[str, Any]): 업데이트할 데이터
+            update_data = {"status": "inactive"}
+    Returns:
+        ModelType: 업데이트된 엔티티
+
+    Raises:
+        CustomException: 엔티티 조회 또는 업데이트 중 발생하는 데이터베이스 오류
+    """
+    try:
+        # 조건 기반 엔티티 조회
+        stmt = select(model)
+        for key, value in conditions.items():
+            stmt = stmt.where(getattr(model, key) == value)
+
+        result = await session.execute(stmt)
+        entity = result.scalar_one_or_none()
+
+        if not entity:
+            raise CustomException(
+                ErrorCode.NOT_FOUND,
+                detail=f"{model.__name__}|{conditions}.",
+                source_function="database.update_entity"
+            )
+
+        # 기존 데이터를 딕셔너리로 변환
+        existing_data = {
+            column.name: getattr(entity, column.name)
+            for column in entity.__table__.columns
+        }
+
+        # 데이터 병합 및 전처리
+        processed_data = process_entity_data(model, update_data, existing_data)
+
+        # 엔티티 데이터 업데이트
+        for key, value in processed_data.items():
+            if hasattr(entity, key):
+                setattr(entity, key, value)
+
+        # 변경 사항 커밋
+        await session.flush()
+        await session.commit()
+        await session.refresh(entity)
+
+        return entity
+
+    except SQLAlchemyError as e:
+        raise CustomException(
+            ErrorCode.DB_UPDATE_ERROR,
+            detail=f"{model.__name__}|{conditions}",
+            source_function="database.update_entity",
+            original_error=e
+        )
+
+async def delete_entity(
+    session: AsyncSession,
+    model: Type[ModelType],
+    conditions: Dict[str, Any]
+) -> None:
+    try:
+        stmt = select(model)
+        for key, value in conditions.items():
+            stmt = stmt.where(getattr(model, key) == value)
+
+        result = await session.execute(stmt)
+        entity = result.scalar_one_or_none()
+
+        if not entity:
+            raise CustomException(
+                ErrorCode.NOT_FOUND,
+                detail=f"{model.__name__}|{conditions}.",
+                source_function="database.delete_entity"
+            )
+
+        entity.is_deleted = True
+        entity.deleted_at = datetime.now()
+
+        await session.flush()
+        await session.commit()
+        await session.refresh(entity)
+
+    except SQLAlchemyError as e:
+        raise CustomException(
+            ErrorCode.DB_DELETE_ERROR,
+            detail=f"{model.__name__}|{conditions}",
+            source_function="database.delete_entity",
+            original_error=e
+        )
+
+async def purge_entity(
+    session: AsyncSession,
+    model: Type[ModelType],
+    entity: ModelType
+) -> None:
+    # 엔티티를 영구 삭제합니다.
+    await session.delete(entity)
+    await session.commit()
+
 async def list_entities(
     session: AsyncSession,
     model: Type[ModelType],
     skip: int = 0,
     limit: int = 100,
     filters: Optional[Dict[str, Any]] = None,
-    joins: Optional[List[Any]] = None
+    explicit_joins: Optional[List[Any]] = None,
+    loading_joins: Optional[List[Any]] = None
 ) -> List[Dict[str, Any]]:
     """
     엔터티 리스트를 필터 및 조건에 따라 가져오는 함수.
@@ -220,20 +431,26 @@ async def list_entities(
     try:
         query = select(model)
 
+        # 명시적 조인 적용
+        if explicit_joins:
+            for join_target in explicit_joins:
+                query = query.join(join_target)  # 명시적으로 정의된 조인 추가
+
+        # 조인 로딩 적용
+        if loading_joins:
+            for join_option in loading_joins:
+                query = query.options(join_option)
+
         # 필터 조건 적용
         if filters:
             conditions = build_conditions(filters, model)
             query = query.where(and_(*conditions))
 
-        # 조인 로딩 적용
-        if joins:
-            for join_option in joins:
-                query = query.options(join_option)
-
         # 페이지네이션 적용
         query = query.limit(limit).offset(skip)
 
         result = await session.execute(query)
+        
         return result.scalars().unique().all()
     except SQLAlchemyError as e:
         raise CustomException(
@@ -242,3 +459,125 @@ async def list_entities(
             source_function="database.list_entities",
             original_error=e
         )
+
+async def get_entity(
+    session: AsyncSession,
+    model: Type[ModelType],
+    conditions: Dict[str, Any],
+    explicit_joins: Optional[List[Any]] = None,
+    loading_joins: Optional[List[Any]] = None
+) -> ModelType:
+    try:
+        query = select(model)
+
+        if explicit_joins:
+            for join_target in explicit_joins:
+                query = query.join(join_target)
+
+        if loading_joins:
+            for join_option in loading_joins:
+                query = query.options(join_option)
+
+        if conditions:
+            for key, value in conditions.items():
+                query = query.where(getattr(model, key) == value)
+
+        result = await session.execute(query)
+        return result.scalars().unique().one_or_none()
+
+    except SQLAlchemyError as e:
+        raise CustomException(
+            ErrorCode.DB_READ_ERROR,
+            detail=str(e),
+            source_function="database.get_entity",
+            original_error=str(e)
+        )
+    
+##################
+# 로그 등 #
+##################
+async def log_create(
+    session: AsyncSession,
+    table_name: str,
+    log_data: Dict[str, Any],
+    request: Request = None
+) -> None:
+    try:
+        # ULID 생성
+        if "ulid" not in log_data:
+            log_data["ulid"] = ULID()
+
+        # 사용자 에이전트 및 IP 주소 추가
+        if request:
+            log_data["user_agent"] = request.headers.get("user-agent")
+            log_data["ip_address"] = request.headers.get("x-forwarded-for") or request.client.host
+
+        # 동적으로 테이블 로드
+        metadata = MetaData(bind=session.bind)
+        table = Table(table_name, metadata, autoload_with=session.bind)
+
+        # 데이터 삽입
+        insert_stmt = insert(table).values(log_data)
+        await session.execute(insert_stmt)
+        await session.commit()
+
+    except Exception as e:
+        raise CustomException(
+            ErrorCode.INTERNAL_ERROR,
+            detail=f"{model.__name__}|{str(e)}",
+            source_function="database.log_create",
+            original_error=e
+        )
+
+######################
+# 검증 #
+######################
+async def validate_unique_fields(
+    session: AsyncSession,
+    unique_check: List[Dict[str, Any]] | None = None,
+    find_value: bool = True  # True: 값이 있는지, False: 값이 없는지 확인
+) -> None:
+    try:
+        for check in unique_check:
+            value = check["value"]
+            model = check["model"]
+            fields = check["fields"]
+
+            # 여러 개의 컬럼이 있을 경우 모든 조건을 만족해야 한다
+            conditions = [getattr(model, column) == value for column in fields]
+
+            # 쿼리 실행
+            query = select(model).where(or_(*conditions))
+            result = await session.execute(query)
+            existing = result.scalar_one_or_none()
+
+            # 값이 있는지 확인 (find_value=True) 또는 값이 없는지 확인 (find_value=False)
+            if find_value and existing:  # 값이 존재하는 경우
+                raise CustomException(
+                    ErrorCode.FIELD_INVALID_UNIQUE,
+                    detail=f"{model.name}|{value}",
+                    source_function="database.validate_unique_fields.existing"
+                )
+            elif not find_value and not existing:  # 값이 존재하지 않는 경우
+                raise CustomException(
+                    ErrorCode.FIELD_INVALID_NOT_EXIST,
+                    detail=f"{model.name}|{value}",
+                    source_function="database.validate_unique_fields.not_existing"
+                )
+
+    except CustomException as e:
+        # 특정 CustomException 처리
+        raise CustomException(
+            e.error_code,
+            detail=str(e),
+            source_function="database.validate_unique_fields.Exception",
+            original_error=e
+        )
+    except Exception as e:
+        # 알 수 없는 예외 처리
+        raise CustomException(
+            ErrorCode.INTERNAL_ERROR,
+            detail=f"Unexpected error: {str(e)}",
+            source_function="database.validate_unique_fields.Exception",
+            original_error=e
+        )

aiteamutils/exceptions.py

@@ -64,12 +64,16 @@ class ErrorCode(Enum):
     VALIDATION_ERROR = ErrorResponse(4001, "VALIDATION_ERROR", 422, "유효성 검사 오류")
     FIELD_INVALID_FORMAT = ErrorResponse(4002, "FIELD_INVALID_FORMAT", 400, "잘못된 형식입니다")
     REQUIRED_FIELD_MISSING = ErrorResponse(4003, "VALIDATION_REQUIRED_FIELD_MISSING", 400, "필수 필드가 누락되었습니다")
+    FIELD_INVALID_UNIQUE = ErrorResponse(4004, "VALIDATION_FIELD_INVALID_UNIQUE", 400, "중복된 값이 존재합니다")
+    FIELD_INVALID_NOT_EXIST = ErrorResponse(4005, "VALIDATION_FIELD_INVALID_NOT_EXIST", 400, "존재하지 않는 값입니다")
     
     # General 에러: 5000번대
     NOT_FOUND = ErrorResponse(5001, "GENERAL_NOT_FOUND", 404, "리소스를 찾을 수 없습니다")
     INTERNAL_ERROR = ErrorResponse(5002, "GENERAL_INTERNAL_ERROR", 500, "내부 서버 오류")
     SERVICE_UNAVAILABLE = ErrorResponse(5003, "GENERAL_SERVICE_UNAVAILABLE", 503, "서비스를 사용할 수 없습니다")
     SERVICE_NOT_REGISTERED = ErrorResponse(5003, "GENERAL_SERVICE_UNAVAILABLE", 503, "서비스를 사용할 수 없습니다")
+    LOGIN_ERROR = ErrorResponse(5004, "LOGIN_ERROR", 401, "로그인 오류")
+    TOKEN_ERROR = ErrorResponse(5005, "TOKEN_ERROR", 401, "토큰 오류")
 
 class CustomException(Exception):
     """사용자 정의 예외 클래스"""
@@ -98,7 +102,7 @@ class CustomException(Exception):
         
         self.error_chain.append({
             "error_code": str(self.error_code),
-            "detail": str(self.detail),
+            "detail": str(self.detail) if self.detail else None,
             "source_function": self.source_function,
             "original_error": str(self.original_error) if self.original_error else None
         })
@@ -115,7 +119,7 @@ class CustomException(Exception):
         """에러 정보를 딕셔너리로 반환합니다."""
         return {
             "error_code": self.error_code.name,
-            "detail": self.detail,
+            "detail": self.detail if self.detail else None,
             "source_function": self.source_function,
             "error_chain": self.error_chain,
             "original_error": str(self.original_error) if self.original_error else None

aiteamutils/security.py

@@ -6,10 +6,11 @@ from functools import wraps
 from jose import jwt, JWTError
 from passlib.context import CryptContext
 import logging
+from sqlalchemy.ext.asyncio import AsyncSession
 
 from .exceptions import CustomException, ErrorCode
 from .enums import ActivityType
-from .config import get_settings
+from .database import log_create
 
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
 
@@ -115,7 +116,6 @@ def rate_limit(
                 except Exception as e:
                     raise CustomException(
                         ErrorCode.INTERNAL_ERROR,
-                        detail=str(e),
                         source_function=func.__name__,
                         original_error=e
                     )
@@ -125,7 +125,6 @@ def rate_limit(
             except Exception as e:
                 raise CustomException(
                     ErrorCode.INTERNAL_ERROR,
-                    detail=str(e),
                     source_function="rate_limit",
                     original_error=e
                 )
@@ -136,20 +135,20 @@ def rate_limit(
 async def create_jwt_token(
     user_data: Dict[str, Any],
     token_type: Literal["access", "refresh"],
-    db_service: Any,
-    request: Optional[Request] = None
+    db_session: AsyncSession,
+    token_settings: Dict[str, str],
+    request: Optional[Request] = None,
 ) -> str:
     """JWT 토큰을 생성하고 로그를 기록합니다."""
     try:
-        settings = get_settings()
-        
+        # 토큰 데이터 구성
         if token_type == "access":
-            expires_at = datetime.now(UTC) + timedelta(minutes=settings.access_token_expire_minutes)
+            expires_at = datetime.now(UTC) + timedelta(minutes=token_settings.ACCESS_TOKEN_EXPIRE_MINUTES)
             token_data = {
                 # 등록 클레임
-                "iss": settings.token_issuer,
+                "iss": token_settings.TOKEN_ISSUER,
                 "sub": user_data["username"],
-                "aud": settings.token_audience,
+                "aud": token_settings.TOKEN_AUDIENCE,
                 "exp": expires_at,
                 
                 # 공개 클레임
@@ -172,22 +171,23 @@ async def create_jwt_token(
         else:  # refresh token
             expires_at = datetime.now(UTC) + timedelta(days=14)
             token_data = {
-                "iss": settings.token_issuer,
+                "iss": token_settings.TOKEN_ISSUER,
                 "sub": user_data["username"],
                 "exp": expires_at,
                 "token_type": token_type,
                 "user_ulid": user_data["ulid"]
             }
 
+        # JWT 토큰 생성
         try:
             token = jwt.encode(
                 token_data,
-                settings.jwt_secret,
-                algorithm=settings.jwt_algorithm
+                token_settings.JWT_SECRET,
+                algorithm=token_settings.JWT_ALGORITHM
             )
         except Exception as e:
             raise CustomException(
-                ErrorCode.INTERNAL_ERROR,
+                ErrorCode.TOKEN_ERROR,
                 detail=f"token|{token_type}",
                 source_function="security.create_jwt_token",
                 original_error=e
@@ -195,14 +195,18 @@ async def create_jwt_token(
         
         # 로그 생성
         try:
-            activity_type = ActivityType.ACCESS_TOKEN_ISSUED if token_type == "access" else ActivityType.REFRESH_TOKEN_ISSUED
-            await db_service.create_log(
-                {
-                    "type": activity_type,
-                    "user_ulid": user_data["ulid"],
-                    "token": token
-                },
-                request
+            log_data = {
+                "type": ActivityType.ACCESS_TOKEN_ISSUED if token_type == "access" else ActivityType.REFRESH_TOKEN_ISSUED,
+                "user_ulid": user_data["ulid"],
+                "token": token
+            }
+
+            # log_create 함수 호출
+            await log_create(
+                session=db_session,
+                table_name="user_logs",
+                log_data=log_data,
+                request=request
             )
         except Exception as e:
             # 로그 생성 실패는 토큰 생성에 영향을 주지 않음
@@ -217,9 +221,10 @@ async def create_jwt_token(
             ErrorCode.INTERNAL_ERROR,
             detail=str(e),
             source_function="security.create_jwt_token",
-            original_error=e
+            original_error=str(e)
         )
 
+
 async def verify_jwt_token(
     token: str,
     expected_type: Optional[Literal["access", "refresh"]] = None

aiteamutils/version.py

@@ -1,2 +1,2 @@
 """버전 정보"""
-__version__ = "0.2.72"
+__version__ = "0.2.75"

{aiteamutils-0.2.72.dist-info → aiteamutils-0.2.75.dist-info}/METADATA

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

aiteamutils-0.2.75.dist-info/RECORD

@@ -0,0 +1,15 @@
+aiteamutils/__init__.py,sha256=kRBpRjark0M8ZwFfmKiMFol6CbIILN3WE4f6_P6iIq0,1089
+aiteamutils/base_model.py,sha256=TJiiA7bFhePObPJEzF1Qz4ekPfFoIxKGpe848BBdHLc,2840
+aiteamutils/base_repository.py,sha256=oTZP3mrkqZwAGv8cNqi0tp9wellvTuO6EXN1P1o7zRs,4285
+aiteamutils/base_service.py,sha256=tkGGVN8wrx9dmCVVnRSsoYGPmVD2H7NmEz-PoifIvW0,9300
+aiteamutils/cache.py,sha256=07xBGlgAwOTAdY5mnMOQJ5EBxVwe8glVD7DkGEkxCtw,1373
+aiteamutils/config.py,sha256=YdalpJb70-txhGJAS4aaKglEZAFVWgfzw5BXSWpkUz4,3232
+aiteamutils/database.py,sha256=8T8c7RpcPEcBXO-AU_-1UhnTI4RwkPLxWF0eWQYwnME,19080
+aiteamutils/enums.py,sha256=ipZi6k_QD5-3QV7Yzv7bnL0MjDz-vqfO9I5L77biMKs,632
+aiteamutils/exceptions.py,sha256=3FUCIqXgYmMqonnMgUlh-J2xtApiiCgg4WM-2UV4vmQ,15823
+aiteamutils/security.py,sha256=7cKY6XhiSEkQJe-XYE2tyYc2u1JLYeXUEjg7AUzEnQY,10277
+aiteamutils/validators.py,sha256=PvI9hbMEAqTawgxPbiWRyx2r9yTUrpNBQs1AD3w4F2U,7726
+aiteamutils/version.py,sha256=FgfB6O4LkLSpldQbG5FG5Fai_x5fo9cg9AQ85w_3RF8,42
+aiteamutils-0.2.75.dist-info/METADATA,sha256=QtxRHW3XcGt5NndEB95Fue80VRGgM54zWbLtssOtkcI,1718
+aiteamutils-0.2.75.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+aiteamutils-0.2.75.dist-info/RECORD,,

aiteamutils-0.2.72.dist-info/RECORD

@@ -1,15 +0,0 @@
-aiteamutils/__init__.py,sha256=kRBpRjark0M8ZwFfmKiMFol6CbIILN3WE4f6_P6iIq0,1089
-aiteamutils/base_model.py,sha256=ODEnjvUVoxQ1RPCfq8-uZTfTADIA4c7Z3E6G4EVsSX0,2708
-aiteamutils/base_repository.py,sha256=tG_xz4hHYAN3-wkrLvEPxyTucV4pzT6dihoKVJp2JIc,2079
-aiteamutils/base_service.py,sha256=CfNBAgFREqOC1791ex2plKLZiSZ1U5el4GvvkVsN4qU,2901
-aiteamutils/cache.py,sha256=07xBGlgAwOTAdY5mnMOQJ5EBxVwe8glVD7DkGEkxCtw,1373
-aiteamutils/config.py,sha256=YdalpJb70-txhGJAS4aaKglEZAFVWgfzw5BXSWpkUz4,3232
-aiteamutils/database.py,sha256=CbX7eNFwqz9O4ywVQMLlLrb6hDUJPtsgGg_Hgef-p2I,8126
-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=PvI9hbMEAqTawgxPbiWRyx2r9yTUrpNBQs1AD3w4F2U,7726
-aiteamutils/version.py,sha256=9RIZRehNxp6dA61_1-bTUirXc1q9QDosp-QZ_woFu0g,42
-aiteamutils-0.2.72.dist-info/METADATA,sha256=WsFA3r2H1XUIsDXmhenz97uj3eT5jyZpN4CbNbps8rA,1718
-aiteamutils-0.2.72.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-aiteamutils-0.2.72.dist-info/RECORD,,