feat: ディレクトリ構成の見直し

.gitignore

@@ -14,6 +14,7 @@ dist/
 build/
 .pytest_cache/
 .mypy_cache/
+.ruff_cache
 .coverage
 htmlcov/
 

backend/app/core/exceptions.py

@@ -15,7 +15,7 @@ def __init__(self, job_id: str, proposal_index: int) -> None:
         super().__init__(f"Proposal not found: job={job_id}, index={proposal_index}")
 
 
-class K8sServiceError(Exception):
+class K8sClientError(Exception):
     """Raised when a Kubernetes operation fails."""
 
 

backend/app/core/middleware.py

@@ -10,7 +10,7 @@
     ArtifactNotFoundError,
     InvalidJobStateError,
     JobNotFoundError,
-    K8sServiceError,
+    K8sClientError,
     ProposalNotFoundError,
 )
 
@@ -32,7 +32,7 @@ async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -
             return JSONResponse(status_code=404, content={"detail": str(e)})
         except InvalidJobStateError as e:
             return JSONResponse(status_code=400, content={"detail": str(e)})
-        except K8sServiceError as e:
+        except K8sClientError as e:
             logger.error("K8s service error: %s", e)
             return JSONResponse(
                 status_code=503,

backend/app/di/container.py

@@ -2,15 +2,15 @@
 
 from sqlalchemy.orm import Session
 
+from app.infra.log_stream_client import LogStreamClient
 from app.repository.database import SessionLocal
 from app.repository.setting_repository import SettingRepository
-from app.service.log_stream_service import LogStreamService
 
 
 class DIContainer:
     """依存性注入コンテナ"""
 
-    _log_stream_service: LogStreamService | None = None
+    _log_stream_client: LogStreamClient | None = None
 
     @staticmethod
     def get_db() -> Generator[Session]:
@@ -26,7 +26,7 @@ def get_setting_repository(db: Session) -> SettingRepository:
         return SettingRepository(db)
 
     @classmethod
-    def get_log_stream_service(cls) -> LogStreamService:
-        if cls._log_stream_service is None:
-            cls._log_stream_service = LogStreamService()
-        return cls._log_stream_service
+    def get_log_stream_client(cls) -> LogStreamClient:
+        if cls._log_stream_client is None:
+            cls._log_stream_client = LogStreamClient()
+        return cls._log_stream_client

backend/app/di/dependencies.py

@@ -4,9 +4,9 @@
 from sqlalchemy.orm import Session
 
 from app.di.container import DIContainer
+from app.infra.log_stream_client import LogStreamClient
+from app.infra.s3_client import S3Client
 from app.repository.setting_repository import SettingRepository
-from app.service.log_stream_service import LogStreamService
-from app.service.s3_service import S3Service
 
 
 def get_db() -> Generator[Session]:
@@ -18,9 +18,9 @@ def get_setting_repository(db: Session = Depends(get_db)) -> SettingRepository:
     return DIContainer.get_setting_repository(db)
 
 
-def get_s3_service() -> S3Service:
-    return S3Service()
+def get_s3_client() -> S3Client:
+    return S3Client()
 
 
-def get_log_stream_service() -> LogStreamService:
-    return DIContainer.get_log_stream_service()
+def get_log_stream_client() -> LogStreamClient:
+    return DIContainer.get_log_stream_client()

backend/app/infra/__init__.py

@@ -0,0 +1,3 @@
+from .k8s_client import K8sClient
+
+__all__ = ["K8sClient"]

backend/app/service/k8s_service.py → backend/app/infra/k8s_client.py

@@ -10,8 +10,8 @@
 logger = logging.getLogger(__name__)
 
 
-class K8sService:
-    """Kubernetes Job management service."""
+class K8sClient:
+    """Kubernetes Job management client."""
 
     def __init__(self) -> None:
         settings = get_settings()

backend/app/service/log_stream_service.py → backend/app/infra/log_stream_client.py

@@ -4,7 +4,7 @@
 from collections.abc import AsyncIterator
 from dataclasses import dataclass, field
 
-from app.service.k8s_service import K8sService
+from app.infra.k8s_client import K8sClient
 
 logger = logging.getLogger(__name__)
 
@@ -38,7 +38,7 @@ def parse_log_line(line: str) -> dict | None:
     return None
 
 
-class LogStreamService:
+class LogStreamClient:
     """Manages log streaming for sessions. Singleton per backend process."""
 
     def __init__(self) -> None:
@@ -83,7 +83,7 @@ async def stream_session_logs(
             since_seconds: If set, only stream logs newer than this many seconds.
                            Used on reconnect to avoid replaying old logs.
         """
-        k8s = K8sService()
+        k8s = K8sClient()
         queue: asyncio.Queue[dict | None] = asyncio.Queue()
         tracked_jobs: set[str] = set()
         tasks: list[asyncio.Task[None]] = []

backend/app/service/s3_service.py → backend/app/infra/s3_client.py

@@ -11,7 +11,7 @@
 logger = logging.getLogger(__name__)
 
 
-class S3Service:
+class S3Client:
     """S3-compatible artifact storage (works with AWS S3 and MinIO)."""
 
     def __init__(self) -> None:

backend/app/repository/__init__.py

@@ -15,6 +15,12 @@
 from .database import SessionLocal
 from .iteration_repository import IterationRepository
 from .proposal_repository import ProposalRepository
+from .protocols import (
+    IterationRepositoryProtocol,
+    ProposalRepositoryProtocol,
+    SessionRepositoryProtocol,
+    SettingRepositoryProtocol,
+)
 from .session_repository import SessionRepository
 from .setting_repository import SettingRepository
 
@@ -24,4 +30,8 @@
     "IterationRepository",
     "ProposalRepository",
     "SettingRepository",
+    "SessionRepositoryProtocol",
+    "IterationRepositoryProtocol",
+    "ProposalRepositoryProtocol",
+    "SettingRepositoryProtocol",
 ]

backend/app/repository/mock/__init__.py

@@ -0,0 +1,9 @@
+from .mock_iteration_repository import MockIterationRepository
+from .mock_proposal_repository import MockProposalRepository
+from .mock_session_repository import MockSessionRepository
+
+__all__ = [
+    "MockSessionRepository",
+    "MockIterationRepository",
+    "MockProposalRepository",
+]

backend/app/repository/mock/mock_iteration_repository.py

@@ -0,0 +1,56 @@
+from uuid import UUID
+
+from app.model.session import Iteration, IterationStatus
+
+
+class MockIterationRepository:
+    def __init__(self) -> None:
+        self._store: dict[UUID, Iteration] = {}
+
+    def create(self, iteration: Iteration) -> Iteration:
+        self._store[iteration.id] = iteration
+        return iteration
+
+    def get_by_id(self, iteration_id: UUID) -> Iteration | None:
+        return self._store.get(iteration_id)
+
+    def get_by_session_and_index(self, session_id: UUID, iteration_index: int) -> Iteration | None:
+        for it in self._store.values():
+            if it.session_id == session_id and it.iteration_index == iteration_index:
+                return it
+        return None
+
+    def get_latest_for_session(self, session_id: UUID) -> Iteration | None:
+        iters = [it for it in self._store.values() if it.session_id == session_id]
+        if not iters:
+            return None
+        return max(iters, key=lambda it: it.iteration_index)
+
+    def get_all_for_session(self, session_id: UUID) -> list[Iteration]:
+        return sorted(
+            [it for it in self._store.values() if it.session_id == session_id],
+            key=lambda it: it.iteration_index,
+        )
+
+    def update_status_optimistic(
+        self,
+        iteration_id: UUID,
+        expected_version: int,
+        status: IterationStatus,
+        **kwargs: object,
+    ) -> Iteration | None:
+        iteration = self._store.get(iteration_id)
+        if not iteration or iteration.version != expected_version:
+            return None
+        iteration.status = status
+        iteration.version += 1
+        for k, v in kwargs.items():
+            if hasattr(iteration, k):
+                setattr(iteration, k, v)
+        return iteration
+
+    def update_selected_proposal(self, iteration_id: UUID, proposal_index: int) -> Iteration | None:
+        iteration = self._store.get(iteration_id)
+        if iteration:
+            iteration.selected_proposal_index = proposal_index
+        return iteration

backend/app/repository/mock/mock_proposal_repository.py

@@ -0,0 +1,49 @@
+from uuid import UUID
+
+from app.model.session import Proposal, ProposalStatus
+
+
+class MockProposalRepository:
+    def __init__(self) -> None:
+        self._store: dict[UUID, Proposal] = {}
+
+    def create(self, proposal: Proposal) -> Proposal:
+        self._store[proposal.id] = proposal
+        return proposal
+
+    def get_by_id(self, proposal_id: UUID) -> Proposal | None:
+        return self._store.get(proposal_id)
+
+    def get_by_iteration_and_index(
+        self, iteration_id: UUID, proposal_index: int
+    ) -> Proposal | None:
+        for p in self._store.values():
+            if p.iteration_id == iteration_id and p.proposal_index == proposal_index:
+                return p
+        return None
+
+    def get_all_by_status(self, status: ProposalStatus) -> list[Proposal]:
+        return [p for p in self._store.values() if p.status == status]
+
+    def get_all_for_iteration(self, iteration_id: UUID) -> list[Proposal]:
+        return sorted(
+            [p for p in self._store.values() if p.iteration_id == iteration_id],
+            key=lambda p: p.proposal_index,
+        )
+
+    def update_status_optimistic(
+        self,
+        proposal_id: UUID,
+        expected_version: int,
+        status: ProposalStatus,
+        **kwargs: object,
+    ) -> Proposal | None:
+        proposal = self._store.get(proposal_id)
+        if not proposal or proposal.version != expected_version:
+            return None
+        proposal.status = status
+        proposal.version += 1
+        for k, v in kwargs.items():
+            if hasattr(proposal, k):
+                setattr(proposal, k, v)
+        return proposal

backend/app/repository/mock/mock_session_repository.py

@@ -0,0 +1,24 @@
+from uuid import UUID
+
+from app.model.session import Session, SessionStatus
+
+
+class MockSessionRepository:
+    def __init__(self) -> None:
+        self._store: dict[UUID, Session] = {}
+
+    def create(self, session: Session) -> Session:
+        self._store[session.id] = session
+        return session
+
+    def get_by_id(self, session_id: UUID) -> Session | None:
+        return self._store.get(session_id)
+
+    def update_status(self, session_id: UUID, status: SessionStatus) -> Session | None:
+        session = self._store.get(session_id)
+        if session:
+            session.status = status
+        return session
+
+    def list_all(self) -> list[Session]:
+        return list(self._store.values())

backend/app/repository/protocols.py

@@ -0,0 +1,63 @@
+from typing import Protocol
+from uuid import UUID
+
+from app.model.session import (
+    Iteration,
+    IterationStatus,
+    Proposal,
+    ProposalStatus,
+    Session,
+    SessionStatus,
+    Setting,
+)
+
+
+class SessionRepositoryProtocol(Protocol):
+    def create(self, session: Session) -> Session: ...
+    def get_by_id(self, session_id: UUID) -> Session | None: ...
+    def update_status(self, session_id: UUID, status: SessionStatus) -> Session | None: ...
+    def list_all(self) -> list[Session]: ...
+
+
+class IterationRepositoryProtocol(Protocol):
+    def create(self, iteration: Iteration) -> Iteration: ...
+    def get_by_id(self, iteration_id: UUID) -> Iteration | None: ...
+    def get_by_session_and_index(
+        self, session_id: UUID, iteration_index: int
+    ) -> Iteration | None: ...
+    def get_latest_for_session(self, session_id: UUID) -> Iteration | None: ...
+    def get_all_for_session(self, session_id: UUID) -> list[Iteration]: ...
+    def update_status_optimistic(
+        self,
+        iteration_id: UUID,
+        expected_version: int,
+        status: IterationStatus,
+        **kwargs: object,
+    ) -> Iteration | None: ...
+    def update_selected_proposal(
+        self, iteration_id: UUID, proposal_index: int
+    ) -> Iteration | None: ...
+
+
+class ProposalRepositoryProtocol(Protocol):
+    def create(self, proposal: Proposal) -> Proposal: ...
+    def get_by_id(self, proposal_id: UUID) -> Proposal | None: ...
+    def get_by_iteration_and_index(
+        self, iteration_id: UUID, proposal_index: int
+    ) -> Proposal | None: ...
+    def get_all_by_status(self, status: ProposalStatus) -> list[Proposal]: ...
+    def get_all_for_iteration(self, iteration_id: UUID) -> list[Proposal]: ...
+    def update_status_optimistic(
+        self,
+        proposal_id: UUID,
+        expected_version: int,
+        status: ProposalStatus,
+        **kwargs: object,
+    ) -> Proposal | None: ...
+
+
+class SettingRepositoryProtocol(Protocol):
+    def get_by_key(self, key: str) -> Setting | None: ...
+    def upsert(self, key: str, value: str) -> Setting: ...
+    def list_all(self) -> list[Setting]: ...
+    def delete(self, key: str) -> bool: ...