feat: enhanced repository usages

app/api/chat_api.py

@@ -22,14 +22,17 @@ router = APIRouter(prefix="/v1", tags=["chat"])
 service = ChatService()
 auth_service = AuthService()
 
+
 class VersionResponse(BaseModel):
     version: str = "0.0.1"
 
+
 # version api from pyproject.toml
 @router.get("/version", response_model=VersionResponse)
 async def get_version():
     return VersionResponse()
 
+
 ################
 # chat completion api list
 ################

app/config/db.py

@@ -10,7 +10,6 @@ class DBConfig(BaseSettings):
         extra="ignore",
     )
 
-
     DATABASE_TYPE: Literal["mongodb", "embedded"] = "embedded"
     DATABASE_NAME: str = "openai_chatbot_api"
 
@@ -19,8 +18,6 @@ class DBConfig(BaseSettings):
     MONGO_HOST: str = "localhost"
     MONGO_PORT: int = 27017
     MONGO_URI: str = f"mongodb://{MONGO_USER}:{MONGO_PASSWORD}@{MONGO_HOST}:{MONGO_PORT}/{DATABASE_NAME}"
-    
-
 
     def get_mongo_uri(self) -> str:
         return self.MONGO_URI

app/config/{secret.py → security_config.py}

@@ -1,17 +1,21 @@
 from pydantic_settings import BaseSettings, SettingsConfigDict
+from functools import lru_cache
 
 
-class SecretConfig(BaseSettings):
-    """Secret configuration to be set in env variables"""
+class SecurityConfig(BaseSettings):
+    """Security configuration to be set in env variables"""
 
     model_config = SettingsConfigDict(
-        env_prefix="SECRET_",
+        env_prefix="SECURITY_",
         env_file=".env",
         env_file_encoding="utf-8",
         extra="ignore",
     )
 
-    KEY: str = "mock-secret-key"
+    SECRET_KEY: str = "your-secret-key-here"
+    ENABLED: bool = True
+    DEFAULT_USERNAME: str = "admin"
 
-
-secret_config = SecretConfig()
+@lru_cache()
+def get_security_config() -> SecurityConfig:
+    return SecurityConfig() 

app/core/db_client.py

@@ -1,110 +1,114 @@
 from abc import ABC, abstractmethod
-from typing import Optional, Dict, Any
+from typing import Optional, Any
 from motor.motor_asyncio import AsyncIOMotorClient
 from unittest.mock import AsyncMock
 
+
 class DatabaseClient(ABC):
     """Abstract base class for database clients"""
-    
+
     @abstractmethod
     async def connect(self) -> None:
         """Connect to the database"""
         pass
-    
+
     @abstractmethod
     async def disconnect(self) -> None:
         """Disconnect from the database"""
         pass
-    
+
     @abstractmethod
     async def get_database(self) -> Any:
         """Get database instance"""
         pass
 
+
 class MongoClient(DatabaseClient):
     """Real MongoDB client implementation"""
-    
+
     def __init__(self, connection_string: str):
         self.connection_string = connection_string
         self._client: Optional[AsyncIOMotorClient] = None
-    
+
     async def connect(self) -> None:
         self._client = AsyncIOMotorClient(self.connection_string)
-    
+
     async def disconnect(self) -> None:
         if self._client:
             self._client.close()
-    
+
     async def get_database(self) -> AsyncIOMotorClient:
         if not self._client:
             await self.connect()
         return self._client
 
+
 class MockMongoClient(DatabaseClient):
     """Mock MongoDB client for testing"""
-    
+
     def __init__(self):
         self._client = AsyncMock()
-    
+
     async def connect(self) -> None:
         pass
-    
+
     async def disconnect(self) -> None:
         pass
-    
+
     async def get_database(self) -> AsyncMock:
         return self._client
 
+
 class DatabaseClientFactory:
     """Factory for creating database clients"""
-    
-    _instance: Optional['DatabaseClientFactory'] = None
+
+    _instance: Optional["DatabaseClientFactory"] = None
     _client: Optional[DatabaseClient] = None
-    
+
     def __new__(cls):
         if cls._instance is None:
             cls._instance = super().__new__(cls)
         return cls._instance
-    
+
     @classmethod
     def create_client(cls, db_type: str, connection_string: Optional[str] = None) -> DatabaseClient:
         """
         Create a database client based on the database type
-        
+
         Args:
             db_type: Type of database ('mongodb' or 'mock')
             connection_string: Connection string for the database
-            
+
         Returns:
             DatabaseClient: Instance of the appropriate database client
         """
         if cls._client is None:
-            if db_type.lower() == 'mongodb':
+            if db_type.lower() == "mongodb":
                 if not connection_string:
                     raise ValueError("Connection string is required for MongoDB")
                 cls._client = MongoClient(connection_string)
-            elif db_type.lower() == 'mock':
+            elif db_type.lower() == "mock":
                 cls._client = MockMongoClient()
             else:
                 raise ValueError(f"Unsupported database type: {db_type}")
-        
+
         return cls._client
-    
+
     @classmethod
     async def get_client(cls) -> DatabaseClient:
         """
         Get the current database client instance
-        
+
         Returns:
             DatabaseClient: Current database client instance
         """
         if cls._client is None:
             raise RuntimeError("Database client not initialized")
         return cls._client
-    
+
     @classmethod
     async def reset_client(cls) -> None:
         """Reset the current database client instance"""
         if cls._client:
             await cls._client.disconnect()
-        cls._client = None 
+        cls._client = None

app/core/initial_setup/setup.py

@@ -6,20 +6,21 @@ from app.model.chat_model import ChatCompletion
 from app.repository.chat_repository import ChatRepository
 from app.config.db import db_config
 
+
 class InitialSetup:
     """Initial setup manager for the application when database type is embedded"""
-    
+
     def __init__(self):
         self._chat_repository: Optional[ChatRepository] = None
         self.data_dir = os.path.join(os.path.dirname(__file__), "data")
-    
+
     @property
     def chat_repository(self) -> ChatRepository:
         """Lazy loading of ChatRepository"""
         if self._chat_repository is None:
             self._chat_repository = ChatRepository()
         return self._chat_repository
-    
+
     def _load_initial_data(self) -> List[ChatCompletion]:
         """Load initial data from JSON files"""
         try:
@@ -29,30 +30,47 @@ class InitialSetup:
         except Exception as e:
             logger.error(f"Error loading initial data: {e}")
             return []
-    
+
     async def setup(self) -> None:
         """Setup initial data if database type is embedded"""
-        if db_config.DATABASE_TYPE != "embedded":
-            logger.info("Skipping initial setup as database type is not embedded")
-            return
-        
-        logger.info("Starting initial setup for embedded database")
-        
-        # Load and save initial chat completions
-        chat_completions = self._load_initial_data()
-        for completion in chat_completions:
-            try:
-                await self.chat_repository.save(completion)
-                logger.info(f"Saved initial chat completion: {completion.completion_id}")
-            except Exception as e:
-                logger.error(f"Error saving chat completion {completion.completion_id}: {e}")
-        
+        try:
+            # if db_config.DATABASE_TYPE != "embedded":
+            #     logger.info("Skipping initial setup as database type is not embedded")
+            #     return
+            
+            # delete all chat completions in the embedded database
+            logger.warning("Deleting all chat completions in the embedded database")
+            await self.chat_repository.db.chat_completion.delete_many({})
+            logger.warning("Deleting all chat completions in the embedded database done")
+            
+            chat_completions = self._load_initial_data()
+            logger.info(f"Loaded {len(chat_completions)} initial chat completions")
+            
+            for completion in chat_completions:
+                try:
+                    found_id = await self.chat_repository.find_by_id(completion.completion_id)
+                    if found_id:
+                        logger.debug(f"Chat completion already exists: {found_id}")
+                        continue
+                        
+                    saved = await self.chat_repository.save(completion)
+                    logger.info(f"Successfully saved chat completion: {saved.completion_id}")
+                    
+                except Exception as e:
+                    logger.error(f"Error saving chat completion {completion.completion_id}: {e}")
+                    raise
+                
+        except Exception as e:
+            logger.error(f"Setup failed: {e}")
+            raise
+
         # query of the saved chat completions
         saved_chat_completions = await self.chat_repository.find()
         logger.debug("********** Begin of Saved chat completions**********")
         logger.trace(f"{saved_chat_completions}")
-        logger.debug(f"saved_chat_completions[0].messages[0]: {saved_chat_completions[0].messages[0]}")
+        chat = saved_chat_completions[0]
+        chat.messages = []
+        logger.debug(f"saved_chat_completions[0] : {chat}")
         logger.debug("********** End of Saved chat completions**********")
 
-
-        logger.info("Initial setup completed successfully for embedded database") 
+        logger.info("Initial setup completed successfully for embedded database")

app/db/client.py

@@ -1,7 +1,8 @@
 # mongodb client with motor and pymongo
 
 from abc import ABC, abstractmethod
-from typing import  Protocol
+from typing import Protocol
+
 
 class DatabaseClientProtocol(Protocol):
     """
@@ -19,6 +20,7 @@ class DatabaseClientProtocol(Protocol):
     - https://www.python.org/dev/peps/pep-0544/
     - https://realpython.com/duck-typing-python/
     """
+
     async def connect(self) -> None: ...
     async def close(self) -> None: ...
     @property

app/db/embedded.py

@@ -1,12 +1,10 @@
-from typing import Optional 
+from typing import Optional
 from mongomock_motor import AsyncMongoMockClient
 from app.config.db import db_config
 from loguru import logger
 from app.db.client import DatabaseClient
 
 
-
-
 class EmbeddedMongoClient(DatabaseClient):
     """
     Mock MongoDB client implementation for local machine and development environment.

app/db/factory.py

@@ -5,6 +5,7 @@ from app.db.mongo import PersistentMongoClient
 from app.db.embedded import EmbeddedMongoClient
 from app.config.db import db_config
 
+
 class DatabaseClientFactory:
     """Factory class for creating database clients"""
 
@@ -33,9 +34,6 @@ class DatabaseClientFactory:
                 cls._client = EmbeddedMongoClient()
         logger.info(f"Returning DatabaseClientFactory.client. Host: {cls._client.client.host}")
         return cls._client
-    
-
-
 
 
 # Global instance

app/db/mongo.py

@@ -4,6 +4,7 @@ from app.config.db import db_config
 from loguru import logger
 from app.db.client import DatabaseClient
 
+
 class PersistentMongoClient(DatabaseClient):
     """Real MongoDB client implementation"""
 
@@ -57,4 +58,4 @@ class PersistentMongoClient(DatabaseClient):
             logger.warning(f"Error while closing MongoDB connection: {e}")
             self._client = None
             self._db = None
-            self._is_connected = False
+            self._is_connected = False

app/mapper/base_mapper.py

@@ -0,0 +1,26 @@
+from abc import ABC, abstractmethod
+from typing import TypeVar, Generic, List
+
+T = TypeVar('T')
+U = TypeVar('U')
+
+class BaseMapper(Generic[T, U], ABC):
+    """Base mapper class for mapping between model and schema objects."""
+    
+    @abstractmethod
+    def to_schema(self, model: T) -> U:
+        """Map from model to schema."""
+        pass
+    
+    @abstractmethod
+    def to_model(self, schema: U) -> T:
+        """Map from schema to model."""
+        pass
+    
+    def to_schema_list(self, models: List[T]) -> List[U]:
+        """Map a list of models to schemas."""
+        return [self.to_schema(model) for model in models]
+    
+    def to_model_list(self, schemas: List[U]) -> List[T]:
+        """Map a list of schemas to models."""
+        return [self.to_model(schema) for schema in schemas] 

app/mapper/chat_mapper.py

@@ -0,0 +1,47 @@
+from datetime import datetime
+from typing import Optional
+from app.mapper.base_mapper import BaseMapper
+from app.model.chat_model import ChatCompletion, ChatMessage
+from app.schema.chat_schema import ChatCompletionResponse, ChatCompletionRequest, MessageResponse, ChoiceResponse
+
+
+class ChatMapper(BaseMapper[ChatCompletion, ChatCompletionResponse]):
+    """Mapper for converting between ChatCompletion model and schema objects."""
+
+    def to_schema(self, model: ChatCompletion) -> ChatCompletionResponse:
+        """Convert ChatCompletion model to ChatCompletionResponse schema."""
+        # Convert datetime to Unix timestamp
+        created_timestamp = int(model.created_date.timestamp()) if model.created_date else None
+
+        # Map the last message to a response message
+        last_message = model.messages[-1] if model.messages else None
+        message_response = None
+        if last_message:
+            message_response = MessageResponse(
+                message_id=last_message.message_id,
+                role=last_message.role,
+                content=last_message.content,
+                figure=last_message.figure,
+            )
+
+        # Create choice response
+        choice = ChoiceResponse(index=0, message=message_response, finish_reason="stop") if message_response else None
+
+        return ChatCompletionResponse(
+            completion_id=model.completion_id, model=model.model, created=created_timestamp, choices=[choice] if choice else []
+        )
+
+    def to_model(self, schema: ChatCompletionRequest) -> ChatCompletion:
+        """Convert ChatCompletionRequest schema to ChatCompletion model."""
+        # Convert messages to ChatMessage objects
+        messages = []
+        if schema.messages:
+            for msg in schema.messages:
+                messages.append(ChatMessage(role=msg.role, content=msg.content))
+
+        return ChatCompletion(
+            completion_id=schema.completion_id,
+            model=schema.model or "gpt-4o",  # Default model
+            messages=messages,
+            stream=schema.stream or False,
+        )

app/model/chat_model.py

@@ -1,12 +1,9 @@
 # chat model for chat completion database
 
 import json
-import uuid
-from enum import Enum
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from datetime import datetime
-from pydantic import Field
-from typing import List, Optional
+from typing import List, Optional, Dict, Any
 
 # Chat completion payload example
 # {
@@ -54,70 +51,44 @@ from typing import List, Optional
 # }
 
 
-class MessageRole(str, Enum):
-    USER = "user"
-    ASSISTANT = "assistant"
-    SYSTEM = "system"
-
-
 class ChatMessage(BaseModel):
     """
     A message in a chat completion.
     """
 
-    message_id: str = Field(
-        ...,
-        description="The unique identifier for the message",
-        default_factory=lambda: str(uuid.uuid4()),
-    )
-    role: MessageRole = Field(
-        ...,
-        description="The role of the message sender",
-        examples=[
-            MessageRole.USER,
-            MessageRole.ASSISTANT,
-            MessageRole.SYSTEM,
-        ],
-    )
+    message_id: str = Field(..., description="The unique identifier for the message")
+    role: Optional[str] = Field(None, description="The role of the message sender", examples=["user", "assistant", "system"])
     content: str = Field(..., description="The content of the message")
-    figure: Optional[dict] = Field(None, description="The figure of the message")
-    created_date: datetime = Field(
-        default_factory=datetime.now,
-        description="The timestamp of the message",
-    )
+    figure: Optional[Dict[str, Any]] = Field(None, description="The figure data for visualization")
+    created_date: datetime = Field(default_factory=datetime.now, description="The timestamp of the message")
 
-    # write a formattet and graceful to string method
     def __str__(self):
         return f"""
         ChatMessage(
             message_id={self.message_id},
             role={self.role},
             content={self.content},
-            figure={json.dumps(self.figure, indent=4)},
+            figure={json.dumps(self.figure, indent=4) if self.figure else None},
             created_date={self.created_date})
             """
-    
+
     def __repr__(self):
         return self.__str__()
-    
+
     def __format__(self, format_spec):
         return self.__str__()
 
 
-
 class ChatCompletion(BaseModel):
     """
     A chat completion.
     """
 
+    #id: Optional[str] = Field(None, alias="_id", description="MongoDB document ID")
     completion_id: Optional[str] = Field(None, description="The unique identifier for the chat completion")
 
     # openai compatible fields
-    model: str = Field(
-        ...,
-        description="The model used for the chat completion",
-        examples=["gpt-4o-mini", "gpt-4o", "gpt-3.5-turbo"],
-    )
+    model: Optional[str] = Field(None, description="The model used for the chat completion", examples=["gpt-4o-mini", "gpt-4o", "gpt-3.5-turbo"])
     messages: List[ChatMessage] = Field(..., description="The messages in the chat completion")
 
     # not implemented yet
@@ -128,27 +99,36 @@ class ChatCompletion(BaseModel):
     # presence_penalty: float = Field(default=0.0, ge=-2.0, le=2.0, description="Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics.")
     # n: int = Field(default=1, ge=1, le=10, description="How many chat completion choices to generate for each prompt.")
 
-    stream: bool = Field(
-        default=False,
-        description="If set to true, the model response data will be streamed to the client as it is generated using [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format). See the [Streaming section below](/docs/api-reference/chat/streaming) for more information, along with the [streaming responses](/docs/guides/streaming-responses) guide for more information on how to handle the streaming events. ",
+    stream: Optional[bool] = Field(
+        None,
+        description="If set to true, the model response data will be streamed to the client as it is generated using server-sent events.",
     )
 
+    title: Optional[str] = Field(None, description="The title of the chat completion")
+    object_field: Optional[str] = Field(None, alias="object_field", description="The object field of the chat completion")
+    is_archived: Optional[bool] = Field(None, description="Whether the chat completion is archived")
+    is_starred: Optional[bool] = Field(None, description="Whether the chat completion is starred")
+
     # audit fields
-    created_by: str = Field(..., description="The user who created the chat completion")
+    created_by: Optional[str] = Field(None, description="The user who created the chat completion")
     created_date: datetime = Field(
         default_factory=datetime.now,
         description="The date and time the chat completion was created",
     )
-    last_updated_by: str = Field(..., description="The user who last updated the chat completion")
-    last_updated_date: datetime = Field(
+    last_updated_by: Optional[str] = Field(None, description="The user who last updated the chat completion")
+    last_updated_date: Optional[datetime] = Field(
         default_factory=datetime.now,
         description="The date and time the chat completion was last updated",
     )
 
-    # write a formattet and graceful to string method
+
+    class Config:
+        populate_by_name = True
+        arbitrary_types_allowed = True
+
     def __str__(self):
         return f"""
-        ChatCompletion(
+        ChatCompletion( 
             completion_id={self.completion_id},
             model={self.model},
             messages={self.messages},
@@ -158,11 +138,8 @@ class ChatCompletion(BaseModel):
             last_updated_date={self.last_updated_date})
             """
 
-
     def __repr__(self):
         return self.__str__()
 
-
     def __format__(self, format_spec):
         return self.__str__()
-    

app/repository/chat_repository.py

@@ -1,8 +1,10 @@
+import datetime
 from typing import List
 from app.db.factory import db_client
 from app.model.chat_model import ChatMessage, ChatCompletion
 from loguru import logger
 import uuid
+import pymongo
 
 
 class ChatRepository:
@@ -15,61 +17,125 @@ class ChatRepository:
         """
         Upsert a chat completion into the database. If the chat completion already exists, it will be updated. If it does not exist, it will be created.
         """
-        logger.debug(f"BEGIN: save chat completion. input data: completion_id: {entity.completion_id}")
+        logger.debug(f"BEGIN REPO: save chat completion. username: {entity.created_by}, completion_id: {entity.completion_id}")
+        entity_dict = entity.model_dump(by_alias=True)
         if entity.completion_id is None:
-            logger.warning("completion_id is None. Generating a new one")
+            generated_completion_id = str(uuid.uuid4())
+            logger.warning(f"completion_id was None. Generated a new one: {generated_completion_id}")
+            entity.completion_id = generated_completion_id
+            entity_dict["completion_id"] = generated_completion_id
+
+            query = {"completion_id": generated_completion_id}
+            update = {
+                "$set": entity_dict,
+                "$setOnInsert": {
+                    "created_date": entity.created_date.isoformat()
+                    if entity.created_date
+                    else datetime.datetime.now(datetime.timezone.utc).isoformat(),
+                    "created_by": entity.created_by,
+                },
+            }
         else:
             logger.debug(f"completion_id is not None. Using the existing one: {entity.completion_id}")
+            query = {"completion_id": entity.completion_id}
+            update_payload = entity_dict.copy()
+            update_payload.pop("created_date", None)  # created_date is not updatable
+            update_payload.pop("created_by", None)  # created_by is not updatable
+            update_payload.pop("completion_id", None)  # completion_id is not updatable
+            update = {"$set": update_payload}
 
-        query = {"completion_id": entity.completion_id}
-        update = {"$set": entity.model_dump()}
-
-        upserted_entity = await self.db.chat_completion.update_one(query, update, upsert=True)
-        logger.debug(f"upserted_entity: {upserted_entity}")
+        upsert_result = await self.db.chat_completion.update_one(query, update, upsert=True)
+        logger.debug(f"upserted_entity. _id: {upsert_result.upserted_id}")
 
-        completion_id = entity.completion_id if entity.completion_id else str(uuid.uuid4())
-        entity.completion_id = completion_id
+        if upsert_result.upserted_id:
+            logger.info(f"Inserted new chat completion with ID: {entity.completion_id} (upserted_id: {upsert_result.upserted_id})")
+        elif upsert_result.modified_count > 0:
+            logger.info(f"Updated existing chat completion with ID: {entity.completion_id}")
+        elif upsert_result.matched_count > 0:
+            logger.info(f"Chat completion with ID: {entity.completion_id} matched but not modified.")
+        else:
+            logger.warning(
+                f"Chat completion with ID: {entity.completion_id} - No operation performed (no match, no upsert, no modification). This might be unexpected."
+            )
 
         # save conversation if new chat completion
         # TODO: save conversation
 
-        result = await self.find_by_id(completion_id)
-        logger.debug("END: save chat completion")
-        return result
+        # after upsert, find the final db entity. if is there any trigger, default, etc. return the latest one
+        final_entity = await self.find_by_id(entity.completion_id)
+        if not final_entity:
+            # This should not happen, upsert should be successful.
+            logger.error(f"CRITICAL: Failed to retrieve chat completion {entity.completion_id} immediately after save operation.")
+            raise Exception(f"Data integrity issue: Could not find chat completion {entity.completion_id} after saving.")
 
-    async def find(self, query: dict = {}, page: int = 1, limit: int = 10, sort: dict = {"created_date": -1}, project: dict = None) -> List[ChatCompletion]:
+        logger.debug(f"END REPO: save chat completion, returning final_entity_id: {final_entity.completion_id}")
+        return final_entity
+
+    async def find(
+        self, query: dict = {}, page: int = 1, limit: int = 10, sort: dict = {"created_date": -1}, projection: dict = None
+    ) -> List[ChatCompletion]:
         """
         Find a chat completion by a given query. with pagination
         Example : query = {"created_by": "admin"}
         """
-        logger.debug(f"BEGIN: find chat completion. input parameters: query: {query}, page: {page}, limit: {limit}, sort: {sort}, project: {project}")
+        logger.debug(f"BEGIN REPO: find chat completion. query: {query}, page: {page}, limit: {limit}, sort: {sort}, projection: {projection}")
         skip = (page - 1) * limit
-        sort = sort if sort else {"created_date": -1}
+        sort_query = sort if sort else [("created_date", pymongo.DESCENDING)]
+
+        cursor = self.db.chat_completion.find(query, projection).skip(skip).limit(limit).sort(sort_query)
+        db_docs = await cursor.to_list(length=limit)
+        result_models = []
+        for item in db_docs:
+            try:
+                result_models.append(ChatCompletion(**item))
+            except Exception as e:
+                logger.error(f"Error parsing ChatCompletion from DB for item with id {item.get('_id', 'N/A')}: {e}", exc_info=True)
+                # TODO: handle error
 
-        cursor = self.db.chat_completion.find(query, project).skip(skip).limit(limit).sort(sort)
-        result = await cursor.to_list(length=limit)
-        logger.trace(f"result: {result}")
-        result = [ChatCompletion(**item) for item in result]
-        logger.debug("END: find chat completion")
-        return result
+        logger.trace(f"REPO find result (raw): {db_docs}")
+        logger.trace(f"REPO find result (models): {result_models}")
+        logger.debug(f"END REPO: find, returning {len(result_models)} models.")
+        return result_models
 
-    async def find_by_id(self, completion_id: str, project: dict = None) -> ChatCompletion:
+    async def find_by_id(self, completion_id: str, projection: dict = None) -> ChatCompletion:
         """
         Find a chat completion by a given id.
         Example : completion_id = "123"
         """
-        logger.debug(f"BEGIN: find chat completion by id. input parameters: completion_id: {completion_id}, project: {project}")
-        entity = await self.db.chat_completion.find_one({"completion_id": completion_id}, project)
-        result = ChatCompletion(**entity)
-        logger.debug("END: find chat completion by id")
-        return result
+        logger.debug(f"BEGIN REPO: find chat completion by id. input parameters: completion_id: {completion_id}, projection: {projection}")
+
+        entity_doc = await self.db.chat_completion.find_one({"completion_id": completion_id}, projection)
+
+        if entity_doc:
+            logger.trace(f"REPO find_by_id. Found entity_doc: {entity_doc}")
+            try:
+                final_entity = ChatCompletion(**entity_doc)
+                logger.debug(f"END REPO: find_by_id. Found: {final_entity.completion_id}")
+                return final_entity
+            except Exception as e:
+                logger.error(f"Error parsing ChatCompletion from DB for id {completion_id}: {e}", exc_info=True)
+                return None  # Parse hatası durumunda None döndür
+        else:
+            logger.info(f"Chat completion with ID {completion_id} not found in DB.")
+            return None
 
     async def find_messages(self, completion_id: str) -> List[ChatMessage]:
         """
         Find all messages for a given chat completion id.
         Example : completion_id = "123"
         """
-        # query = {"completion_id": completion_id}
-        project = {"messages": 1}
-        result = await self.find_by_id(completion_id, project)
-        return [ChatMessage(**item) for item in result["messages"]]
+        logger.debug(f"BEGIN REPO: find messages for chat completion id. input parameters: completion_id: {completion_id}")
+        projection = {"messages": 1, "_id": 0}
+        chat_doc = await self.db.chat_completion.find_one({"completion_id": completion_id}, projection)
+
+        if chat_doc and "messages" in chat_doc and chat_doc["messages"]:
+            try:
+                messages_list = [ChatMessage(**item) for item in chat_doc["messages"]]
+                logger.debug(f"END REPO: find_messages. Found {len(messages_list)} messages.")
+                return messages_list
+            except Exception as e:
+                logger.error(f"Error parsing messages for completion_id {completion_id}: {e}", exc_info=True)
+                return []
+
+        logger.info(f"No messages found for completion_id {completion_id} or messages field is empty/missing.")
+        return []

app/schema/chat_schema.py

@@ -1,18 +1,5 @@
 from typing import List, Optional
 from pydantic import BaseModel, Field
-from enum import Enum
-
-
-class ChoiceSchemaFinishReasonType(str, Enum):
-    STOP = "stop"
-    LENGTH = "length"
-    CONTENT_FILTER = "content_filter"
-
-
-class MessageSchemaRoleType(str, Enum):
-    USER = "user"
-    ASSISTANT = "assistant"
-    SYSTEM = "system"
 
 
 class MessageRequest(BaseModel):
@@ -20,15 +7,15 @@ class MessageRequest(BaseModel):
     Represents a message in a chat completion.
     """
 
-    role: MessageSchemaRoleType = Field(..., description="The role of the message")
-    content: str = Field(..., description="The content of the message")
-
+    role: Optional[str] = Field(None, description="The role of the message", examples=["user", "assistant", "system"])
+    content: Optional[str] = Field(None, description="The content of the message")
 
 
 class ChatCompletionRequest(BaseModel):
     """
     Represents a chat completion request. Starting a new chat or continuing a previous chat.
     """
+
     completion_id: Optional[str] = Field(
         None,
         description="The unique identifier for the chat completion. When starting a new chat, this will be a new UUID. When continuing a previous chat, this will be the same as the previous chat completion id.",
@@ -44,15 +31,16 @@ class MessageResponse(BaseModel):
     """
 
     message_id: Optional[str] = Field(None, description="The unique identifier for the message")
-    role: Optional[MessageSchemaRoleType] = Field(None, description="The role of the message")
+    role: Optional[str] = Field(None, description="The role of the message", examples=["user", "assistant", "system"])
     content: Optional[str] = Field(None, description="The content of the message")
     figure: Optional[dict] = Field(None, description="The figure data to be visualized")
 
 
 class ChoiceResponse(BaseModel):
-    finish_reason: Optional[ChoiceSchemaFinishReasonType] = Field(
+    finish_reason: Optional[str] = Field(
         None,
         description="The reason the model stopped generating tokens. This will be `stop` if the model hit a natural stop point or a provided stop sequence, `length` if the maximum number of tokens specified in the request was reached, `content_filter` if content was omitted due to a flag from our content filters",
+        examples=["stop", "length", "content_filter"],
     )
     index: Optional[int] = Field(None, description="The index of the choice in the list of choices.")
     message: Optional[MessageResponse] = Field(None, description="The message to use for the chat completion")

app/security/auth_service.py

@@ -1,5 +1,5 @@
-from app.config.secret import secret_config as secret
-from fastapi import HTTPException, status, Security
+from app.config.security_config import get_security_config
+from fastapi import HTTPException, status, Security, Depends
 from fastapi.security import APIKeyHeader
 from loguru import logger
 import base64
@@ -12,13 +12,14 @@ api_key_header = APIKeyHeader(
     name="Authorization",
     scheme_name="ApiKeyAuth",
     description="API key in the format: sk-{username}-{base64_encoded_data}",
+    auto_error=False  # API key olmadığında otomatik hata vermesini engelle
 )
 
 
 class AuthService:
-    def __init__(self):
-        self.secret = secret
+    def __init__(self): 
         self.api_key_header = api_key_header
+        self.security_config = get_security_config()
 
     def decode_api_key(self, api_key: str) -> str:
         """Decode API key to extract username and verify signature."""
@@ -58,10 +59,10 @@ class AuthService:
             }
             json_str = json.dumps(json_data)
             logger.trace(f"JSON data for signature: {json_str}")
-            logger.trace(f"Secret key: {self.secret.KEY}")
+            logger.trace(f"Secret key: {self.security_config.SECRET_KEY}")
 
             expected_signature = hmac.new(
-                self.secret.KEY.encode(),
+                self.security_config.SECRET_KEY.encode(),
                 json_str.encode(),
                 hashlib.sha256,
             ).hexdigest()
@@ -86,11 +87,21 @@ class AuthService:
                 detail=f"Invalid API key: {str(e)}",
             )
 
-    def verify_credentials(self, api_key: str = Security(api_key_header)) -> str:
+    async def verify_credentials(self, api_key: str =  Security(api_key_header)) -> str:
         """Verify API key and extract username."""
         logger.trace(f"BEGIN: api_key: {api_key}")
+        
+        if not self.security_config.ENABLED:
+            logger.info("Security is disabled, using default username: " + self.security_config.DEFAULT_USERNAME)
+            return self.security_config.DEFAULT_USERNAME
+        
+        if not api_key:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="API key is required when security is enabled",
+            )
+            
         username = self.decode_api_key(api_key)
-
         result = username
         logger.trace(f"END: result: {result}")
         return result

app/service/chat_service.py

@@ -8,6 +8,7 @@ from app.schema.chat_schema import (
     MessageResponse,
 )
 from app.model.chat_model import ChatCompletion, ChatMessage
+from app.mapper.chat_mapper import ChatMapper
 import uuid
 from loguru import logger
 from app.schema.conversation import ConversationResponse
@@ -16,13 +17,16 @@ from app.schema.conversation import ConversationResponse
 class ChatService:
     def __init__(self):
         self.chat_repository = ChatRepository()
+        self.chat_mapper = ChatMapper()
 
     async def handle_chat_completion(self, request: ChatCompletionRequest) -> ChatCompletionResponse:
         last_user_message = request.messages[-1].content
         response_content = f"TODO implement ai-agent response for this message: {last_user_message}"
         username = "admin"
 
-        entity = ChatCompletion(**request.model_dump())
+        # Convert request to model
+        entity = self.chat_mapper.to_model(request)
+        
         if entity.completion_id:
             entity.completion_id = str(uuid.uuid4())
             entity.created_by = username
@@ -31,28 +35,20 @@ class ChatService:
         entity.last_updated_by = username
         entity.last_updated_date = datetime.datetime.now()
 
+        # Save to database
         entity = await self.chat_repository.save(entity)
 
-        result = ChatCompletionResponse(**entity.model_dump())
-        messages = [MessageResponse(**{"role": "assistant", "content": response_content})]  # TODO: implement ai-agent response
-        result.choices = [
-            ChoiceResponse(
-                **{
-                    "index": 0,
-                    "message": messages[0],
-                    "finish_reason": "stop",
-                }
-            )
-        ]
-        return result
+        # Convert model to response
+        return self.chat_mapper.to_schema(entity)
 
     async def find(self, query: dict, page: int, limit: int, sort: dict, project: dict = None) -> List[ChatCompletionResponse]:
         logger.debug(f"BEGIN SERVICE: find for query: {query}, page: {page}, limit: {limit}, sort: {sort}, project: {project}")
         entities = await self.chat_repository.find(query, page, limit, sort, project)
-        return [ChatCompletionResponse(**entity.model_dump()) for entity in entities]
+        return self.chat_mapper.to_schema_list(entities)
 
-    async def find_by_id(self, completion_id: str, project: dict = None) -> ChatCompletion:
-        return await self.chat_repository.find_by_id(completion_id, project)
+    async def find_by_id(self, completion_id: str, project: dict = None) -> ChatCompletionResponse:
+        entity = await self.chat_repository.find_by_id(completion_id, project)
+        return self.chat_mapper.to_schema(entity) if entity else None
 
     async def find_messages(self, completion_id: str) -> List[ChatMessage]:
         return await self.chat_repository.find_messages(completion_id)

main.py

@@ -35,11 +35,11 @@ async def lifespan(app: FastAPI):
     # Startup
     logger.info("Starting up application...")
     await db_client.connect()
-    
+
     # Run initial setup if database type is embedded
     initial_setup = InitialSetup()
     await initial_setup.setup()
-    
+
     yield
 
     # Shutdown