feat(prompt): add history tracking for prompt releases

api/app/repositories/prompt_optimizer_repository.py

@@ -4,7 +4,10 @@ from sqlalchemy.orm import Session
 
 from app.core.logging_config import get_db_logger
 from app.models.prompt_optimizer_model import (
-    PromptOptimizerSession, PromptOptimizerSessionHistory, RoleType
+    PromptOptimizerSession,
+    PromptOptimizerSessionHistory,
+    RoleType,
+    PromptHistory
 )
 
 db_logger = get_db_logger()
@@ -16,6 +19,12 @@ class PromptOptimizerSessionRepository:
     def __init__(self, db: Session):
         self.db = db
 
+    def get_session_by_id(self, session_id: uuid.UUID) -> PromptOptimizerSession | None:
+        session = self.db.query(PromptOptimizerSession).filter(
+            PromptOptimizerSession.id == session_id,
+        ).first()
+        return session
+
     def create_session(
             self,
             tenant_id: uuid.UUID,
@@ -38,12 +47,9 @@ class PromptOptimizerSessionRepository:
                 user_id=user_id,
             )
             self.db.add(session)
-            self.db.commit()
-            self.db.refresh(session)
-            db_logger.debug(f"Prompt optimization session created: ID:{session.id}")
             return session
         except Exception as e:
-            db_logger.error(f"Error creating prompt optimization session: user_id={user_id} - {str(e)}")
+            db_logger.error(f"Error creating prompt optimization session: - {str(e)}")
             raise
 
     def get_session_history(
@@ -71,10 +77,10 @@ class PromptOptimizerSessionRepository:
                 PromptOptimizerSession.id == session_id,
                 PromptOptimizerSession.user_id == user_id
             ).first()
-            
+
             if not session:
                 return []
-            
+
             history = self.db.query(PromptOptimizerSessionHistory).filter(
                 PromptOptimizerSessionHistory.session_id == session.id,
                 PromptOptimizerSessionHistory.user_id == user_id
@@ -104,11 +110,11 @@ class PromptOptimizerSessionRepository:
                 PromptOptimizerSession.user_id == user_id,
                 PromptOptimizerSession.tenant_id == tenant_id
             ).first()
-            
+
             if not session:
                 db_logger.error(f"Session {session_id} not found for user {user_id}")
                 raise ValueError(f"Session {session_id} not found for user {user_id}")
-            
+
             message = PromptOptimizerSessionHistory(
                 tenant_id=tenant_id,
                 session_id=session.id,
@@ -117,8 +123,199 @@ class PromptOptimizerSessionRepository:
                 content=content,
             )
             self.db.add(message)
-            self.db.commit()
+
             return message
         except Exception as e:
             db_logger.error(f"Error creating prompt optimization session history: session_id={session_id} - {str(e)}")
             raise
+
+    def get_first_user_message(self, session_id: uuid.UUID) -> str | None:
+        """
+        Get the first user message from a session.
+
+        Args:
+            session_id (uuid.UUID): The session ID.
+
+        Returns:
+            str | None: The content of the first user message, or None if not found.
+        """
+        try:
+            message = self.db.query(PromptOptimizerSessionHistory).filter(
+                PromptOptimizerSessionHistory.session_id == session_id,
+                PromptOptimizerSessionHistory.role == RoleType.USER.value
+            ).order_by(
+                PromptOptimizerSessionHistory.created_at.asc()
+            ).first()
+            
+            return message.content if message else None
+        except Exception as e:
+            db_logger.error(f"Error getting first user message: session_id={session_id} - {str(e)}")
+            raise
+
+
+class PromptReleaseRepository:
+    def __init__(self, db: Session):
+        self.db = db
+
+    def get_prompt_by_session_id(self, session_id: uuid.UUID) -> PromptHistory | None:
+        prompt_obj = self.db.query(PromptHistory).filter(
+            PromptHistory.session_id == session_id,
+            PromptHistory.is_delete.is_(False)
+        ).first()
+        return prompt_obj
+
+    def create_prompt_release(
+            self,
+            tenant_id: uuid.UUID,
+            title: str,
+            session_id: uuid.UUID,
+            prompt: str,
+    ) -> PromptHistory:
+        try:
+            prompt_obj = PromptHistory(
+                tenant_id=tenant_id,
+                title=title,
+                session_id=session_id,
+                prompt=prompt,
+            )
+            self.db.add(prompt_obj)
+            return prompt_obj
+        except Exception as e:
+            db_logger.error(f"Error creating prompt release: session_id={session_id} - {str(e)}")
+            raise
+
+    def soft_delete_prompt(self, prompt_obj: PromptHistory) -> None:
+        """
+        Soft delete a prompt release by setting is_delete flag to True.
+
+        Args:
+            prompt_obj (PromptHistory): The prompt release object to delete.
+        """
+        try:
+            prompt_obj.is_delete = True
+            db_logger.debug(f"Soft deleted prompt release: id={prompt_obj.id}, session_id={prompt_obj.session_id}")
+        except Exception as e:
+            db_logger.error(f"Error soft deleting prompt release: id={prompt_obj.id} - {str(e)}")
+            raise
+
+    def get_prompt_by_id(self, prompt_id: uuid.UUID) -> PromptHistory | None:
+        """
+        Get a prompt release by its ID.
+
+        Args:
+            prompt_id (uuid.UUID): The prompt release ID.
+
+        Returns:
+            PromptHistory | None: The prompt release object or None if not found.
+        """
+        try:
+            prompt_obj = self.db.query(PromptHistory).filter(
+                PromptHistory.id == prompt_id
+            ).first()
+            return prompt_obj
+        except Exception as e:
+            db_logger.error(f"Error getting prompt release by id: id={prompt_id} - {str(e)}")
+            raise
+
+    def count_prompts(self, tenant_id: uuid.UUID) -> int:
+        """
+        Count total number of non-deleted prompts for a tenant.
+
+        Args:
+            tenant_id (uuid.UUID): The tenant ID.
+
+        Returns:
+            int: Total count of prompts.
+        """
+        try:
+            count = self.db.query(PromptHistory).filter(
+                PromptHistory.tenant_id == tenant_id,
+                PromptHistory.is_delete.is_(False)
+            ).count()
+            return count
+        except Exception as e:
+            db_logger.error(f"Error counting prompts: tenant_id={tenant_id} - {str(e)}")
+            raise
+
+    def get_prompts_paginated(
+            self,
+            tenant_id: uuid.UUID,
+            offset: int,
+            limit: int
+    ) -> list[PromptHistory]:
+        """
+        Get paginated list of prompt releases for a tenant.
+
+        Args:
+            tenant_id (uuid.UUID): The tenant ID.
+            offset (int): Number of records to skip.
+            limit (int): Maximum number of records to return.
+
+        Returns:
+            list[PromptHistory]: List of prompt releases.
+        """
+        try:
+            prompts = self.db.query(PromptHistory).filter(
+                PromptHistory.tenant_id == tenant_id,
+                PromptHistory.is_delete.is_(False)
+            ).order_by(
+                PromptHistory.created_at.desc()
+            ).offset(offset).limit(limit).all()
+            return prompts
+        except Exception as e:
+            db_logger.error(f"Error getting paginated prompts: tenant_id={tenant_id} - {str(e)}")
+            raise
+
+    def count_prompts_by_keyword(self, tenant_id: uuid.UUID, keyword: str) -> int:
+        """
+        Count total number of non-deleted prompts matching keyword for a tenant.
+
+        Args:
+            tenant_id (uuid.UUID): The tenant ID.
+            keyword (str): Search keyword for title.
+
+        Returns:
+            int: Total count of matching prompts.
+        """
+        try:
+            count = self.db.query(PromptHistory).filter(
+                PromptHistory.tenant_id == tenant_id,
+                PromptHistory.is_delete.is_(False),
+                PromptHistory.title.ilike(f"%{keyword}%")
+            ).count()
+            return count
+        except Exception as e:
+            db_logger.error(f"Error counting prompts by keyword: tenant_id={tenant_id}, keyword={keyword} - {str(e)}")
+            raise
+
+    def search_prompts_paginated(
+            self,
+            tenant_id: uuid.UUID,
+            keyword: str,
+            offset: int,
+            limit: int
+    ) -> list[PromptHistory]:
+        """
+        Search prompt releases by keyword in title with pagination.
+
+        Args:
+            tenant_id (uuid.UUID): The tenant ID.
+            keyword (str): Search keyword for title.
+            offset (int): Number of records to skip.
+            limit (int): Maximum number of records to return.
+
+        Returns:
+            list[PromptHistory]: List of matching prompt releases.
+        """
+        try:
+            prompts = self.db.query(PromptHistory).filter(
+                PromptHistory.tenant_id == tenant_id,
+                PromptHistory.is_delete.is_(False),
+                PromptHistory.title.ilike(f"%{keyword}%")
+            ).order_by(
+                PromptHistory.created_at.desc()
+            ).offset(offset).limit(limit).all()
+            return prompts
+        except Exception as e:
+            db_logger.error(f"Error searching prompts: tenant_id={tenant_id}, keyword={keyword} - {str(e)}")
+            raise