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

refactor: change async methods to synchronous in repositories

Author: getmarkus

.gitignore

@@ -192,7 +192,13 @@ Temporary Items
 .apdisk
 
 ### macOS Patch ###
+# End of https://www.toptal.com/developers/gitignore/api/macos
 # iCloud generated files
 *.icloud
 
-# End of https://www.toptal.com/developers/gitignore/api/macos
+# SQLite database files
+*.db
+*.sqlite
+*.sqlite3
+*.sqlite-journal
+*.sqlite3-journal

config.py

@@ -17,6 +17,7 @@ class Settings(BaseSettings):
     env_smoke_test: str = ""
     project_name: str = ""
     database_url: str = "sqlite:///./issues.db"
+    migrate_database: bool = True
     # 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

@@ -14,6 +14,7 @@
 from src.interface_adapters import api_router
 from src.interface_adapters.exceptions import AppException
 from src.interface_adapters.middleware.error_handler import app_exception_handler
+from src.resource_adapters.persistence.sqlmodel.database import init_db
 
 # https://brandur.org/logfmt
 # https://github.com/Delgan/loguru
@@ -36,8 +37,7 @@ async def lifespan(app: FastAPI):
     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
+    if Settings.get_settings().execution_mode == "sqlmodel" and not Settings.get_settings().migrate_database:
         init_db()
 
     yield

src/app/ports/repositories/issues.py

@@ -3,26 +3,26 @@
 
 class IssueRepository(Protocol):
     # or get
-    async def get_by_id(self, id: int) -> Issue:
+    def get_by_id(self, id: int) -> Issue:
         ...
 
     # or get_all
-    async def list(self) -> Iterable[Issue]:
+    def list(self) -> Iterable[Issue]:
         # return []
         ...
 
-    async def list_with_predicate(self, predicate: Callable[[Issue], bool]) -> Iterable[Issue]:
+    def list_with_predicate(self, predicate: Callable[[Issue], bool]) -> Iterable[Issue]:
         # for item in self.list():
         #    if predicate(item):
         #        yield item
         # return filter(predicate, self.list())
         ...
 
-    async def add(self, entity: Issue) -> None:
+    def add(self, entity: Issue) -> None:
         ...
 
-    async def update(self, entity: Issue) -> None:
+    def update(self, entity: Issue) -> None:
         ...
 
-    async def remove(self, entity: Issue) -> None:
+    def remove(self, entity: Issue) -> None:
         ...

src/app/repository.py

@@ -14,8 +14,8 @@ def __enter__(self) -> "UnitOfWork":
 
     def __exit__(
         self,
-        exc_type: type[BaseException],
-        exc_val: BaseException,
-        exc_tb: TracebackType,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         ...

src/app/usecases/analyze_issue.py

@@ -1,21 +1,13 @@
-from abc import abstractmethod
 from typing import Protocol
 
 from loguru import logger
 
 from src.app.ports.repositories.issues import IssueRepository
-from src.app.repository import UnitOfWork
 from src.domain.issue import Issue
 from src.interface_adapters.exceptions import NotFoundException
 
 
-class AnalyzeIssueProtocol(Protocol):
-    @abstractmethod
-    async def analyze(self) -> Issue:
-        raise NotImplementedError
-
-
-class AnalyzeIssue(AnalyzeIssueProtocol):
+class AnalyzeIssue(Protocol):
     # or could be a DTO as a inner class
     # or could be a empty/minimal Issue object
     issue_number: int = 0
@@ -24,18 +16,16 @@ def __init__(
         self,
         issue_number: int,
         repo: IssueRepository,
-        unit_of_work: UnitOfWork,
     ) -> None:
         self.issue_number = issue_number
         self.repo = repo
-        self.unit_of_work = unit_of_work
 
-    async def analyze(self) -> Issue:
+    def analyze(self) -> Issue:
         logger.info(f"analyzing issue: {self.issue_number}")
-        issue = await self.repo.get_by_id(self.issue_number)
+        issue = self.repo.get_by_id(self.issue_number)
         if issue.issue_number == 0:
             raise NotFoundException(
                 message="Issue not found",
-                detail=f"Issue with number {self.issue_number} does not exist"
+                detail=f"Issue with number {self.issue_number} does not exist",
             )
         return issue

src/interface_adapters/endpoints/issues.py

@@ -2,45 +2,30 @@
 
 from fastapi import APIRouter, Depends
 from loguru import logger
+from sqlmodel import Session
 
 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 as InMemoryUnitOfWork,
-)
+from src.resource_adapters.persistence.sqlmodel.database import get_db
 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() -> 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=f"Execution mode '{execution_mode}' is not supported",
-        )
-
-
-async def configure_repository() -> IssueRepository:
+def configure_repository(
+    session: Annotated[Session, Depends(get_db)]
+    #session: SessionDep,
+) -> 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
+        return SQLModelIssueRepository(session)
     else:
         raise UnsupportedOperationException(
             message="Unsupported repository configuration",
@@ -49,18 +34,10 @@ async def configure_repository() -> IssueRepository:
 
 
 @router.post("/issues/{issue_number}/analyze", response_model=Issue)
-async def analyze_issue(
+def analyze_issue(
     issue_number: int,
-    unit_of_work: Annotated[BaseUnitOfWork, Depends(configure_unit_of_work)],
-    repo: Annotated[IssueRepository, Depends(configure_repository)],
+    repo: Annotated[IssueRepository, Depends(configure_repository)]
 ) -> Issue:
     logger.info(f"analyzing issue: {issue_number}")
-
-    # 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()
+    use_case = AnalyzeIssue(issue_number=issue_number, repo=repo)
+    return use_case.analyze()

src/interface_adapters/middleware/error_handler.py

@@ -5,7 +5,7 @@
 from src.interface_adapters.exceptions import AppException
 
 
-async def app_exception_handler(request: Request, exc: Exception) -> JSONResponse:
+def app_exception_handler(request: Request, exc: Exception) -> JSONResponse:
     if isinstance(exc, AppException):
         logger.error(f"Request to {request.url} failed: {exc.message}")
         if exc.detail:

src/resource_adapters/persistence/in_memory/issues.py

@@ -4,15 +4,16 @@
 
 from src.app.ports.repositories.issues import IssueRepository
 from src.domain.issue import Issue
+from src.resource_adapters.persistence.in_memory.unit_of_work import InMemoryUnitOfWork
 
 
-class InMemoryIssueRepository(IssueRepository):
+class InMemoryIssueRepository(InMemoryUnitOfWork, IssueRepository):
     def __init__(self) -> None:
         self.issues: List[Issue] = []
         # self.issues: dict[int, Issue] = {}
         # self.data = {}
 
-    async def get_by_id(self, id: int) -> Issue:
+    def get_by_id(self, id: int) -> Issue:
         logger.info(f"getting issue by id: {id}")
         for issue in self.issues:
             if issue.issue_number == id:
@@ -22,7 +23,7 @@ async def get_by_id(self, id: int) -> Issue:
         # copy.deepcopy(self.issues[id])
         # return self.data.get(key)
 
-    async def list(self) -> List[Issue]:
+    def list(self) -> List[Issue]:
         return self.issues
         # return self.issues.values()
 
@@ -33,13 +34,11 @@ def name_starts_with_a(user: User) -> bool:
     users_with_a = user_repo.list_with_predicate(name_starts_with_a)
     """
 
-    async def list_with_predicate(
-        self, predicate: Callable[[Issue], bool]
-    ) -> List[Issue]:
+    def list_with_predicate(self, predicate: Callable[[Issue], bool]) -> List[Issue]:
         return [issue for issue in self.issues if predicate(issue)]
         # return filter(predicate, self.issues.values())
 
-    async def add(self, entity: Issue) -> None:
+    def add(self, entity: Issue) -> None:
         logger.info(f"adding issue: {entity.issue_number}")
         self.issues.append(entity)
         # self.issues[entity.number] = entity
@@ -48,15 +47,15 @@ async def add(self, entity: Issue) -> None:
         # self.data[key] = value
         # return True
 
-    async def update(self, entity: Issue) -> None:
+    def update(self, entity: Issue) -> None:
         logger.info(f"updating issue: {entity}")
         for i, issue in enumerate(self.issues):
             if issue.issue_number == entity.issue_number:
                 self.issues[i] = entity
                 break
         # self.issues[entity.issue_number] = entity
 
-    async def remove(self, entity: Issue) -> None:
+    def remove(self, entity: Issue) -> None:
         logger.info(f"removing issue: {entity}")
         self.issues = [i for i in self.issues if i.issue_number != entity.issue_number]
         # if entity in self.issues:

src/resource_adapters/persistence/in_memory/unit_of_work.py

@@ -5,7 +5,7 @@
 from src.app.repository import UnitOfWork
 
 
-class UnitOfWork(UnitOfWork):
+class InMemoryUnitOfWork(UnitOfWork):
     def __init__(self) -> None:
         self.committed = False
 
@@ -15,15 +15,15 @@ def commit(self) -> None:
     def rollback(self) -> None:
         self.committed = False
 
-    def __enter__(self) -> "UnitOfWork":
+    def __enter__(self) -> "InMemoryUnitOfWork":
         logger.info("enter uow")
         return self
 
     def __exit__(
         self,
-        exc_type: type[BaseException],
-        exc_val: BaseException,
-        exc_tb: TracebackType,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         if exc_type:
             logger.info("exit rollback uow")