solace-agent-mesh 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/infrastructure/persistence/database_service.py

@@ -0,0 +1,119 @@
+import logging
+from collections.abc import Generator
+from contextlib import contextmanager
+
+from sqlalchemy import create_engine, event
+from sqlalchemy.orm import Session, sessionmaker
+
+from .models import Base
+
+
+def get_database_type(database_url: str) -> str:
+    """Get the database type from a database URL."""
+    if database_url.startswith("sqlite"):
+        return "sqlite"
+    elif database_url.startswith("postgresql"):
+        return "postgresql"
+    else:
+        return "unknown"
+
+
+class DatabaseService:
+    def __init__(self, database_url: str):
+        self.database_url = database_url
+        self.logger = logging.getLogger(__name__)
+
+        if database_url.startswith("sqlite"):
+            self._setup_sqlite_engine(database_url)
+        elif database_url.startswith("postgresql"):
+            self._setup_postgresql_engine(database_url)
+        else:
+            # Fallback for other databases
+            self._setup_generic_engine(database_url)
+
+        self.SessionLocal = sessionmaker(
+            autocommit=False, autoflush=False, bind=self.engine
+        )
+
+    def _setup_sqlite_engine(self, database_url: str):
+        """Configure SQLite-specific engine settings."""
+        self.engine = create_engine(
+            database_url,
+            echo=False,
+            connect_args={
+                "check_same_thread": False,
+            },
+        )
+
+        @event.listens_for(self.engine, "connect")
+        def set_sqlite_pragma(dbapi_connection, connection_record):
+            cursor = dbapi_connection.cursor()
+            cursor.execute("PRAGMA foreign_keys=ON")
+            cursor.close()
+
+    def _setup_postgresql_engine(self, database_url: str):
+        """Configure PostgreSQL-specific engine settings."""
+        try:
+            import psycopg2
+        except ImportError:
+            raise ImportError(
+                "PostgreSQL support requires psycopg2. Install with: "
+                "pip install 'solace-agent-mesh[postgresql]'"
+            )
+
+        self.engine = create_engine(
+            database_url,
+            pool_size=10,
+            max_overflow=20,
+            pool_timeout=30,
+            pool_recycle=3600,
+            pool_pre_ping=True,
+            echo=False,
+        )
+
+    def _setup_generic_engine(self, database_url: str):
+        """Configure generic database engine settings."""
+        self.engine = create_engine(
+            database_url,
+            pool_size=10,
+            max_overflow=20,
+            pool_timeout=30,
+            pool_recycle=3600,
+            pool_pre_ping=True,
+            echo=False,
+        )
+
+    def create_tables(self):
+        Base.metadata.create_all(bind=self.engine)
+
+    @contextmanager
+    def session_scope(self) -> Generator[Session, None, None]:
+        session = self.SessionLocal()
+        try:
+            yield session
+            session.commit()
+        except Exception as e:
+            session.rollback()
+            self.logger.error(f"Database transaction failed: {e}")
+            raise
+        finally:
+            session.close()
+
+    @contextmanager
+    def read_only_session(self) -> Generator[Session, None, None]:
+        session = self.SessionLocal()
+        try:
+            yield session
+        except Exception as e:
+            session.rollback()
+            self.logger.error(f"Database read operation failed: {e}")
+            raise
+        finally:
+            session.close()
+
+
+database_service: DatabaseService = None
+
+
+def get_database_service() -> DatabaseService:
+    return database_service

solace_agent_mesh/gateway/http_sse/infrastructure/persistence/models.py

@@ -0,0 +1,31 @@
+from sqlalchemy import Column, DateTime, ForeignKey, String, Text
+from sqlalchemy.orm import declarative_base, relationship
+from sqlalchemy.sql import func
+
+Base = declarative_base()
+
+
+class SessionModel(Base):
+    __tablename__ = "sessions"
+    id = Column(String, primary_key=True)
+    name = Column(String, nullable=True)
+    user_id = Column(String, nullable=False)
+    agent_id = Column(String, nullable=True)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+    messages = relationship(
+        "MessageModel", back_populates="session", cascade="all, delete-orphan"
+    )
+
+
+class MessageModel(Base):
+    __tablename__ = "chat_messages"
+    id = Column(String, primary_key=True)
+    session_id = Column(
+        String, ForeignKey("sessions.id", ondelete="CASCADE"), nullable=False
+    )
+    message = Column(Text, nullable=False)
+    created_at = Column(DateTime, default=func.now())
+    sender_type = Column(String(50))
+    sender_name = Column(String(255))
+    session = relationship("SessionModel", back_populates="messages")

solace_agent_mesh/gateway/http_sse/infrastructure/persistence_service.py

@@ -0,0 +1,12 @@
+from .dependency_injection.container import ApplicationContainer
+from .persistence.database_service import DatabaseService
+
+
+class PersistenceService:
+    def __init__(self, database_url: str):
+        self.db_service = DatabaseService(database_url)
+        self.container = ApplicationContainer(database_url)
+
+    @property
+    def engine(self):
+        return self.db_service.engine

solace_agent_mesh/gateway/http_sse/infrastructure/repositories/__init__.py

@@ -0,0 +1,3 @@
+from .session_repository import SessionRepository, MessageRepository
+
+__all__ = ["SessionRepository", "MessageRepository"]

solace_agent_mesh/gateway/http_sse/infrastructure/repositories/session_repository.py

@@ -0,0 +1,174 @@
+from ...domain.entities.session import Message, Session
+from ...domain.repositories.session_repository import (
+    IMessageRepository,
+    ISessionRepository,
+)
+from ...shared.enums import SenderType, SessionStatus
+from ...shared.types import PaginationInfo, SessionId, UserId
+from ..persistence.database_service import DatabaseService
+from ..persistence.models import MessageModel, SessionModel
+
+
+class SessionRepository(ISessionRepository):
+    def __init__(self, db_service: DatabaseService):
+        self.db_service = db_service
+
+    def get_by_id(self, session_id: SessionId) -> Session | None:
+        with self.db_service.read_only_session() as session:
+            model = (
+                session.query(SessionModel)
+                .filter(SessionModel.id == session_id)
+                .first()
+            )
+            return self._model_to_entity(model) if model else None
+
+    def get_by_user_id(
+        self, user_id: UserId, pagination: PaginationInfo | None = None
+    ) -> list[Session]:
+        with self.db_service.read_only_session() as session:
+            query = session.query(SessionModel).filter(SessionModel.user_id == user_id)
+
+            if pagination:
+                offset = (pagination.page - 1) * pagination.page_size
+                query = query.offset(offset).limit(pagination.page_size)
+
+            models = query.order_by(SessionModel.updated_at.desc()).all()
+            return [self._model_to_entity(model) for model in models]
+
+    def get_user_session(
+        self, session_id: SessionId, user_id: UserId
+    ) -> Session | None:
+        with self.db_service.read_only_session() as session:
+            model = (
+                session.query(SessionModel)
+                .filter(SessionModel.id == session_id, SessionModel.user_id == user_id)
+                .first()
+            )
+            return self._model_to_entity(model) if model else None
+
+    def create(self, session_entity: Session) -> Session:
+        with self.db_service.session_scope() as session:
+            model = SessionModel(
+                id=session_entity.id,
+                user_id=session_entity.user_id,
+                name=session_entity.name,
+                agent_id=session_entity.agent_id,
+                created_at=session_entity.created_at,
+                updated_at=session_entity.updated_at,
+            )
+            session.add(model)
+            session.flush()
+            session.refresh(model)
+            return self._model_to_entity(model)
+
+    def update(self, session_entity: Session) -> Session | None:
+        with self.db_service.session_scope() as session:
+            model = (
+                session.query(SessionModel)
+                .filter(
+                    SessionModel.id == session_entity.id,
+                    SessionModel.user_id == session_entity.user_id,
+                )
+                .first()
+            )
+
+            if not model:
+                return None
+
+            model.name = session_entity.name
+            model.agent_id = session_entity.agent_id
+            model.updated_at = session_entity.updated_at
+
+            session.flush()
+            session.refresh(model)
+            return self._model_to_entity(model)
+
+    def delete(self, session_id: SessionId, user_id: UserId) -> bool:
+        with self.db_service.session_scope() as session:
+            model = (
+                session.query(SessionModel)
+                .filter(SessionModel.id == session_id, SessionModel.user_id == user_id)
+                .first()
+            )
+
+            if not model:
+                return False
+
+            session.delete(model)
+            return True
+
+    def exists(self, session_id: SessionId) -> bool:
+        with self.db_service.read_only_session() as session:
+            return (
+                session.query(SessionModel)
+                .filter(SessionModel.id == session_id)
+                .first()
+                is not None
+            )
+
+    def _model_to_entity(self, model: SessionModel) -> Session:
+        return Session(
+            id=model.id,
+            user_id=model.user_id,
+            name=model.name,
+            agent_id=model.agent_id,
+            status=SessionStatus.ACTIVE,
+            created_at=model.created_at,
+            updated_at=model.updated_at,
+            last_activity=model.updated_at,
+        )
+
+
+class MessageRepository(IMessageRepository):
+    def __init__(self, db_service: DatabaseService):
+        self.db_service = db_service
+
+    def get_by_session_id(
+        self, session_id: SessionId, pagination: PaginationInfo | None = None
+    ) -> list[Message]:
+        with self.db_service.read_only_session() as session:
+            query = session.query(MessageModel).filter(
+                MessageModel.session_id == session_id
+            )
+            query = query.order_by(MessageModel.created_at.asc())
+
+            if pagination:
+                offset = (pagination.page - 1) * pagination.page_size
+                query = query.offset(offset).limit(pagination.page_size)
+
+            models = query.all()
+            return [self._model_to_entity(model) for model in models]
+
+    def create(self, message_entity: Message) -> Message:
+        with self.db_service.session_scope() as session:
+            model = MessageModel(
+                id=message_entity.id,
+                session_id=message_entity.session_id,
+                message=message_entity.message,
+                sender_type=message_entity.sender_type.value,
+                sender_name=message_entity.sender_name,
+                created_at=message_entity.created_at,
+            )
+            session.add(model)
+            session.flush()
+            session.refresh(model)
+            return self._model_to_entity(model)
+
+    def delete_by_session_id(self, session_id: SessionId) -> bool:
+        with self.db_service.session_scope() as session:
+            deleted_count = (
+                session.query(MessageModel)
+                .filter(MessageModel.session_id == session_id)
+                .delete()
+            )
+            return deleted_count > 0
+
+    def _model_to_entity(self, model: MessageModel) -> Message:
+        return Message(
+            id=model.id,
+            session_id=model.session_id,
+            message=model.message,
+            sender_type=SenderType(model.sender_type),
+            sender_name=model.sender_name,
+            created_at=model.created_at,
+        )