Merge pull request #22 from getmarkus/cm-branch-20

getmarkus · web-flow · commit 4b687f31de9d · 2025-02-06T14:16:04.000-05:00
feat: implement application factory and update dependencies
diff --git a/.trunk/configs/.yamllint.yaml b/.trunk/configs/.yamllint.yaml
@@ -0,0 +1,7 @@
+rules:
+  quoted-strings:
+    required: only-when-needed
+    extra-allowed: ["{|}"]
+  key-duplicates: {}
+  octal-values:
+    forbid-implicit-octal: true
diff --git a/.trunk/trunk.yaml b/.trunk/trunk.yaml
@@ -2,12 +2,12 @@
 # To learn more about the format of this file, see https://docs.trunk.io/reference/trunk-yaml
 version: 0.1
 cli:
-  version: 1.22.9
+  version: 1.22.10
 # Trunk provides extensibility via plugins. (https://docs.trunk.io/plugins)
 plugins:
   sources:
     - id: trunk
-      ref: v1.6.6
+      ref: v1.6.7
       uri: https://github.com/trunk-io/plugins
 # Many linters and tools depend on runtimes - configure them here. (https://docs.trunk.io/runtimes)
 runtimes:
@@ -20,11 +20,16 @@ lint:
     - git-diff-check
     - bandit
   enabled:
-    - black@24.10.0
-    - checkov@3.2.357
-    - isort@5.13.2
-    - markdownlint@0.43.0
+    - osv-scanner@1.9.2
+    - yamllint@1.35.1
+    - black@25.1.0
+    - checkov@3.2.367
+    - isort@6.0.0
+    - markdownlint@0.44.0
     - prettier@3.4.2
-    - ruff@0.9.3
+    - ruff@0.9.4
     - taplo@0.9.3
-    - trufflehog@3.88.2
+    - trufflehog@3.88.5
+actions:
+  enabled:
+    - trunk-upgrade-available
diff --git a/app/__init__.py b/app/__init__.py
@@ -0,0 +1 @@
+
diff --git a/app/core/factory.py b/app/core/factory.py
@@ -0,0 +1,51 @@
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+
+from app.interface_adapters import api_router
+from app.interface_adapters.containers import Container
+from app.interface_adapters.exceptions import AppException
+from app.interface_adapters.middleware.error_handler import app_exception_handler
+from app.resource_adapters.persistence.sqlmodel.database import get_engine
+from config import settings
+
+
+def create_container():
+    container = Container()
+    container.wire(packages=["app"])
+    return container
+
+
+def create_app(lifespan_handler=None) -> FastAPI:
+    if lifespan_handler is None:
+
+        @asynccontextmanager
+        async def default_lifespan(app: FastAPI):
+            # Initialize container and wire dependencies
+            container = create_container()
+
+            # Initialize database if using SQLModel
+            get_engine()
+
+            app.state.running = True
+
+            yield
+
+            app.state.running = False
+            container.unwire()
+
+        lifespan_handler = default_lifespan
+
+    app = FastAPI(
+        lifespan=lifespan_handler,
+        title=settings.project_name,
+        openapi_url="/v1/openapi.json",
+    )
+
+    # Register global exception handler
+    app.add_exception_handler(AppException, app_exception_handler)
+
+    # Register routes
+    app.include_router(api_router, prefix="/v1")
+
+    return app
diff --git a/app/core/ports/__init__.py b/app/core/ports/__init__.py
@@ -0,0 +1 @@
+
diff --git a/app/core/ports/repositories/__init__.py b/app/core/ports/repositories/__init__.py
@@ -0,0 +1 @@
+
diff --git a/app/core/usecases/__init__.py b/app/core/usecases/__init__.py
@@ -0,0 +1 @@
+
diff --git a/app/domain/user.py b/app/domain/user.py
@@ -19,7 +19,7 @@ class UserEvent(BaseEvent):
     timestamp: datetime
 
 
-class User(AggregateRoot[BaseCommand, BaseEvent]):
+class User(AggregateRoot):
     email: EmailStr
     is_active: bool = False
     full_name: str
diff --git a/app/interface_adapters/containers.py b/app/interface_adapters/containers.py
@@ -0,0 +1,25 @@
+from dependency_injector import containers, providers
+from sqlmodel import Session
+
+from app.resource_adapters.persistence.in_memory.issues import InMemoryIssueRepository
+from app.resource_adapters.persistence.sqlmodel.database import get_engine
+from app.resource_adapters.persistence.sqlmodel.issues import SQLModelIssueRepository
+from config import settings
+
+
+class Container(containers.DeclarativeContainer):
+    wiring_config = containers.WiringConfiguration(packages=["app"])
+
+    # Database
+    db_engine = providers.Singleton(get_engine)
+    db_session = providers.Factory(Session, bind=db_engine)
+
+    # Repositories
+    issue_repository = providers.Factory(
+        (
+            SQLModelIssueRepository
+            if settings.execution_mode == "sqlmodel"
+            else InMemoryIssueRepository
+        ),
+        session=db_session if settings.execution_mode == "sqlmodel" else None,
+    )
diff --git a/app/interface_adapters/endpoints/__init__.py b/app/interface_adapters/endpoints/__init__.py
@@ -0,0 +1 @@
+
diff --git a/app/interface_adapters/endpoints/issues.py b/app/interface_adapters/endpoints/issues.py
@@ -1,40 +1,26 @@
 from typing import Annotated
 
+from dependency_injector.wiring import inject
 from fastapi import APIRouter, Depends
 from loguru import logger
-from sqlmodel import Session
 
 from app.core.ports.repositories.issues import IssueRepository
 from app.core.usecases.analyze_issue import AnalyzeIssue
 from app.domain.issue import Issue
-from app.interface_adapters.exceptions import UnsupportedOperationException
-from app.resource_adapters.persistence.in_memory.issues import InMemoryIssueRepository
-from app.resource_adapters.persistence.sqlmodel.database import get_db
-from app.resource_adapters.persistence.sqlmodel.issues import SQLModelIssueRepository
-from config import settings
+from app.interface_adapters.containers import Container
 
 router = APIRouter()
 
 
-# https://fastapi.tiangolo.com/tutorial/dependencies/
-def configure_repository(
-    session: Annotated[Session, Depends(get_db)]
-) -> IssueRepository:
-    execution_mode = settings.execution_mode
-    if execution_mode == "in-memory":
-        return InMemoryIssueRepository()
-    elif execution_mode == "sqlmodel":
-        return SQLModelIssueRepository(session)
-    else:
-        raise UnsupportedOperationException(
-            message="Unsupported repository configuration",
-            detail=f"Execution mode '{execution_mode}' is not supported",
-        )
+def get_repository() -> IssueRepository:
+    return Container.issue_repository()
 
 
 @router.post("/issues/{issue_number}/analyze", response_model=Issue)
+@inject
 def analyze_issue(
-    issue_number: int, repo: Annotated[IssueRepository, Depends(configure_repository)]
+    issue_number: int,
+    repo: Annotated[IssueRepository, Depends(get_repository)],
 ) -> Issue:
     logger.info(f"analyzing issue: {issue_number}")
     use_case = AnalyzeIssue(issue_number=issue_number, repo=repo)
diff --git a/app/interface_adapters/middleware/__init__.py b/app/interface_adapters/middleware/__init__.py
@@ -0,0 +1 @@
+
diff --git a/app/resource_adapters/__init__.py b/app/resource_adapters/__init__.py
diff --git a/app/resource_adapters/persistence/__init__.py b/app/resource_adapters/persistence/__init__.py
@@ -0,0 +1 @@
+
diff --git a/app/resource_adapters/persistence/in_memory/__init__.py b/app/resource_adapters/persistence/in_memory/__init__.py
@@ -0,0 +1 @@
+
diff --git a/app/resource_adapters/persistence/sqlmodel/__init__.py b/app/resource_adapters/persistence/sqlmodel/__init__.py
@@ -0,0 +1 @@
+
diff --git a/app/resource_adapters/persistence/sqlmodel/database.py b/app/resource_adapters/persistence/sqlmodel/database.py
@@ -28,14 +28,13 @@ def get_engine(database_url: str | None = None) -> Engine:
 
     # Configure engine based on database type
     engine_args = {"echo": True}
-    
+
     # Add SQLite-specific settings for in-memory database
     if database_url == "sqlite://":
-        engine_args.update({
-            "connect_args": {"check_same_thread": False},
-            "poolclass": StaticPool
-        })
-    
+        engine_args.update(
+            {"connect_args": {"check_same_thread": False}, "poolclass": StaticPool}
+        )
+
     _engine = create_engine(database_url, **engine_args)
 
     # Enable WAL mode if configured
diff --git a/app/tests/__init__.py b/app/tests/__init__.py
@@ -0,0 +1 @@
+
diff --git a/app/tests/conftest.py b/app/tests/conftest.py
@@ -1,15 +1,26 @@
+from contextlib import asynccontextmanager
+
 import pytest
+from fastapi import FastAPI
 from fastapi.testclient import TestClient
 from sqlmodel import Session, delete
 
+from app.core.factory import create_app
 from app.resource_adapters.persistence.sqlmodel.database import get_engine
 from app.resource_adapters.persistence.sqlmodel.issues import Issue
-from main import app
+
+
+@asynccontextmanager
+async def test_lifespan(app: FastAPI):
+    yield
+
+
+# Create test app using the factory with test lifespan
+app = create_app(lifespan_handler=test_lifespan)
 
 
 @pytest.fixture(name="session", autouse=True)
 def session_fixture():
-
     with Session(get_engine()) as session:
         yield session
         statement = delete(Issue)
@@ -19,6 +30,5 @@ def session_fixture():
 
 @pytest.fixture(name="client")
 def client_fixture():
-
     with TestClient(app) as client:
         yield client
diff --git a/app/tests/domain/__init__.py b/app/tests/domain/__init__.py
@@ -0,0 +1 @@
+
diff --git a/main.py b/main.py
@@ -1,18 +1,13 @@
 import datetime
 import uuid
-from contextlib import asynccontextmanager
 from typing import Any, Dict, Optional
 
-from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from loguru import logger
 from pydantic import BaseModel, Field
 
-from app.interface_adapters import api_router
-from app.interface_adapters.exceptions import AppException
-from app.interface_adapters.middleware.error_handler import app_exception_handler
-from app.resource_adapters.persistence.sqlmodel.database import get_engine
+from app.core.factory import create_app
 from config import settings
 
 # https://brandur.org/logfmt
@@ -28,23 +23,6 @@ def isRunning() -> bool:
     return running
 
 
-# https://fastapi.tiangolo.com/advanced/events/
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-
-    # Initialize database if using SQLModel
-    get_engine()
-
-    app.state.running = True
-    logger.info("Lifespan started")
-    isRunning()
-
-    yield
-
-    app.state.running = False
-    logger.info("Lifespan stopped")
-
-
 def is_configured() -> bool:
     logger.info(f"configured: {settings.env_smoke_test == 'configured'}")
     return settings.env_smoke_test == "configured"
@@ -104,14 +82,7 @@ def create_health_response(is_healthy: bool, check_name: str) -> JSONResponse:
     )
 
 
-app = FastAPI(
-    lifespan=lifespan,
-    title=settings.project_name,  # Use settings directly
-    openapi_url="/v1/openapi.json",
-)
-
-# Register global exception handler
-app.add_exception_handler(AppException, app_exception_handler)
+app = create_app()
 
 # middleware options
 # https://levelup.gitconnected.com/17-useful-middlewares-for-fastapi-that-you-should-know-about-951c2b0869c7
@@ -129,6 +100,8 @@ def create_health_response(is_healthy: bool, check_name: str) -> JSONResponse:
 # Route security, ip address and user agent - TrustedHostMiddleware
 # gzip compression - GZipMiddleware
 # ssl enforcement - HTTPSRedirectMiddleware
+# request state
+# request IDs
 
 
 @app.middleware("http")
@@ -222,9 +195,6 @@ async def smoke_check() -> JSONResponse:
     return create_health_response(is_configured(), "configuration")
 
 
-# add feature routers here
-app.include_router(api_router, prefix="/v1")
-
 # if unit test for health check is desired
 # https://fastapi.tiangolo.com/advanced/testing-events/
 # https://github.com/Kludex/fastapi-health/blob/main/tests/test_endpoint.py
diff --git a/pyproject.toml b/pyproject.toml
@@ -6,6 +6,7 @@ authors = [{ name = "Chris Markus", email = "chris@christophermarkus.com" }]
 requires-python = "~=3.12"
 readme = "README.md"
 dependencies = [
+  "dependency-injector>=4.45.0",
   "dynaconf>=3.2.7",
   "fastapi[standard]>=0.115.6",
   "httpx>=0.28.1",
diff --git a/uv.lock b/uv.lock
