Merge pull request #8 from getmarkus/cm-branch-7

feat: add SQLAlchemy dependency and improve logging messages

Author: getmarkus

.trunk/trunk.yaml

@@ -17,11 +17,11 @@ runtimes:
 # This is the section where you manage your linters. (https://docs.trunk.io/check/configuration)
 lint:
   disabled:
+    - git-diff-check
     - bandit
   enabled:
     - [email protected]
     - [email protected]
-    - git-diff-check
     - [email protected]
     - [email protected]
     - [email protected]

config.py

@@ -1,7 +1,7 @@
+import tomllib
 from functools import lru_cache
 from typing import List
 
-import tomllib
 from pydantic import AnyHttpUrl
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
@@ -16,6 +16,7 @@ class Settings(BaseSettings):
     execution_mode: str = ""
     env_smoke_test: str = ""
     project_name: str = ""
+    database_url: str = "sqlite:///./issues.db"
     # BACKEND_CORS_ORIGINS is a JSON-formatted list of origins
     # e.g: '["http://localhost", "http://localhost:4200", "http://localhost:3000", \
     # "http://localhost:8080", "http://local.dockertoolbox.tiangolo.com"]'

main.py

@@ -34,6 +34,12 @@ async def lifespan(app: FastAPI):
     global running
     running = True
     logger.info("Lifespan started")
+
+    # Initialize database if using SQLModel
+    if Settings.get_settings().execution_mode == "sqlmodel":
+        from src.resource_adapters.persistence.sqlmodel.database import init_db
+        init_db()
+
     yield
     running = False
     logger.info("Lifespan stopped")

pyproject.toml

@@ -6,12 +6,12 @@ authors = [{ name = "Chris Markus", email = "[email protected]" }]
 requires-python = "~=3.12"
 readme = "README.md"
 dependencies = [
-   "fastapi[standard]>=0.115.6",
-   "httpx>=0.28.1",
-   "loguru>=0.7.3",
-   "pydantic>=2.10.5",
-   "pydantic-settings>=2.7.1",
-   "pytest>=8.3.4",
+  "fastapi[standard]>=0.115.6",
+  "httpx>=0.28.1",
+  "loguru>=0.7.3",
+  "pydantic>=2.10.5",
+  "pydantic-settings>=2.7.1",
+  "sqlmodel>=0.0.22",
 ]
 
 [tool.uv]
@@ -22,4 +22,9 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [dependency-groups]
-dev = []
+dev = ["pytest>=8.3.4", "pytest-asyncio>=0.23.5", "pytest-anyio>=0.1.0"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+anyio_backend = "asyncio"
+asyncio_default_fixture_loop_scope = "function"

src/domain/aggregate_root.py

@@ -2,24 +2,23 @@
 from datetime import datetime
 from typing import Protocol
 
-from pydantic import BaseModel
+from sqlmodel import SQLModel
 
 
 class BaseCommand(Protocol):
     command_id: str
     timestamp: datetime
 
     # might need specification pattern here
-    def validate(self) -> bool:
-        ...
+    def validate(self) -> bool: ...
 
 
 class BaseEvent(Protocol):
     event_id: str
     timestamp: datetime
 
 
-class AggregateRoot(BaseModel, abc.ABC):
+class AggregateRoot(SQLModel, abc.ABC):
     version: int = 0
 
     # or handle()

src/domain/issue.py

@@ -4,6 +4,8 @@
 from types import MappingProxyType
 from typing import Any, Final, Optional
 
+from sqlmodel import Field
+
 from src.domain.aggregate_root import AggregateRoot, BaseCommand, BaseEvent
 
 # https://docs.github.com/en/rest/using-the-rest-api/github-event-types?apiVersion=2022-11-28#issuesevent
@@ -15,6 +17,7 @@
 
 ### Enums ###
 
+
 class IssueTransitionState(Enum):
     COMPLETED = "COMPLETED"
     NOT_PLANNED = "NOT_PLANNED"
@@ -180,8 +183,8 @@ def __init__(
 
 
 ### Entitites ###
-class Issue(AggregateRoot):
-    issue_number: int
+class Issue(AggregateRoot, table=True):
+    issue_number: int = Field(primary_key=True)
     issue_state: IssueState = IssueState.OPEN
 
     def process(self, command: BaseCommand) -> list[BaseEvent]:

src/interface_adapters/endpoints/issues.py

@@ -1,44 +1,66 @@
 from typing import Annotated
+
 from fastapi import APIRouter, Depends
 from loguru import logger
 
-from src.app.usecases.analyze_issue import AnalyzeIssue
 from config import Settings
+from src.app.ports.repositories.issues import IssueRepository
+from src.app.repository import UnitOfWork as BaseUnitOfWork
+from src.app.usecases.analyze_issue import AnalyzeIssue
 from src.domain.issue import Issue
 from src.interface_adapters.exceptions import UnsupportedOperationException
 from src.resource_adapters.persistence.in_memory.issues import InMemoryIssueRepository
-from src.resource_adapters.persistence.in_memory.unit_of_work import UnitOfWork
+from src.resource_adapters.persistence.in_memory.unit_of_work import (
+    UnitOfWork as InMemoryUnitOfWork,
+)
+from src.resource_adapters.persistence.sqlmodel.issues import SQLModelIssueRepository
+from src.resource_adapters.persistence.sqlmodel.unit_of_work import SQLModelUnitOfWork
 
 router = APIRouter()
 
 
 # https://fastapi.tiangolo.com/tutorial/dependencies/
-async def configure_unit_of_work() -> UnitOfWork:
-    if Settings.get_settings().execution_mode == "in-memory":
-        return UnitOfWork()
+async def configure_unit_of_work() -> BaseUnitOfWork:
+    execution_mode = Settings.get_settings().execution_mode
+    if execution_mode == "in-memory":
+        return InMemoryUnitOfWork()
+    elif execution_mode == "sqlmodel":
+        return SQLModelUnitOfWork(database_url=Settings.get_settings().database_url)
     else:
         raise UnsupportedOperationException(
             message="Unsupported unit of work configuration",
-            detail="Only in-memory unit of work is currently supported"
+            detail=f"Execution mode '{execution_mode}' is not supported",
         )
 
 
-async def configure_repository() -> InMemoryIssueRepository:
-    if Settings.get_settings().execution_mode == "in-memory":
+async def configure_repository() -> IssueRepository:
+    execution_mode = Settings.get_settings().execution_mode
+    if execution_mode == "in-memory":
         return InMemoryIssueRepository()
+    elif execution_mode == "sqlmodel":
+        # For SQLModel, the repository is managed by the UnitOfWork
+        # This is just a placeholder that will be replaced
+        return SQLModelIssueRepository(None)  # type: ignore
     else:
         raise UnsupportedOperationException(
             message="Unsupported repository configuration",
-            detail="Only in-memory repository is currently supported"
+            detail=f"Execution mode '{execution_mode}' is not supported",
         )
 
 
 @router.post("/issues/{issue_number}/analyze", response_model=Issue)
 async def analyze_issue(
     issue_number: int,
-    unit_of_work: Annotated[UnitOfWork, Depends(configure_unit_of_work)],
-    repo: Annotated[InMemoryIssueRepository, Depends(configure_repository)],
+    unit_of_work: Annotated[BaseUnitOfWork, Depends(configure_unit_of_work)],
+    repo: Annotated[IssueRepository, Depends(configure_repository)],
 ) -> Issue:
     logger.info(f"analyzing issue: {issue_number}")
-    use_case = AnalyzeIssue(issue_number=issue_number, repo=repo, unit_of_work=unit_of_work)
+
+    # For SQLModel, we need to use the repository from the unit of work
+    if isinstance(unit_of_work, SQLModelUnitOfWork):
+        repo = unit_of_work.issues
+
+    use_case = AnalyzeIssue(
+        issue_number=issue_number, repo=repo, unit_of_work=unit_of_work
+    )
     return await use_case.analyze()

src/resource_adapters/persistence/in_memory/unit_of_work.py

@@ -16,7 +16,7 @@ def rollback(self) -> None:
         self.committed = False
 
     def __enter__(self) -> "UnitOfWork":
-        logger.info(f"enter uow")
+        logger.info("enter uow")
         return self
 
     def __exit__(
@@ -26,8 +26,8 @@ def __exit__(
         exc_tb: TracebackType,
     ) -> None:
         if exc_type:
-            logger.info(f"exit rollback uow")
+            logger.info("exit rollback uow")
             self.rollback()
         else:
-            logger.info(f"exit commit uow")
+            logger.info("exit commit uow")
             self.commit()

src/resource_adapters/persistence/sqlmodel/__init__.py

@@ -0,0 +1,4 @@
+from src.resource_adapters.persistence.sqlmodel.issues import SQLModelIssueRepository
+from src.resource_adapters.persistence.sqlmodel.unit_of_work import SQLModelUnitOfWork
+
+__all__ = ["SQLModelIssueRepository", "SQLModelUnitOfWork"]

src/resource_adapters/persistence/sqlmodel/database.py

@@ -0,0 +1,32 @@
+from loguru import logger
+from sqlmodel import SQLModel, create_engine
+
+from config import Settings
+from src.domain.issue import Issue  # noqa: F401
+
+_engine = None
+
+
+def get_engine(database_url: str | None = None):
+    """Get or create SQLModel engine instance."""
+    global _engine
+
+    if _engine is not None:
+        return _engine
+
+    if database_url is None:
+        database_url = Settings.get_settings().database_url
+        if not database_url:
+            database_url = "sqlite:///./issues.db"
+            logger.warning(f"No database URL configured, using default: {database_url}")
+
+    _engine = create_engine(database_url,connect_args={"check_same_thread": False}, echo=True)
+    return _engine
+
+
+def init_db() -> None:
+    """Initialize the database by creating all tables."""
+    engine = get_engine()
+    logger.info("Creating database tables...")
+    SQLModel.metadata.create_all(engine)
+    logger.info("Database tables created successfully")