routerの作成

.env.example

@@ -13,3 +13,9 @@ DATABASE_URL=postgresql+asyncpg://your_db_user:your_db_password@db:5432/your_db_
 
 # SQLログ（開発時のみ true にする。本番は false のまま）
 SQL_ECHO=false
+
+# Supabase JWT検証（Supabase Dashboard > Settings > API > JWT Secret）
+SUPABASE_JWT_SECRET=your_supabase_jwt_secret
+
+# Google Places API キー
+GOOGLE_PLACES_API_KEY=your_google_places_api_key

app/config/dependency.py

@@ -0,0 +1,54 @@
+from fastapi import Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.infrastructure.database import get_session
+from app.repositories.user_repository import UserRepository
+from app.repositories.trip_repository import TripRepository
+from app.repositories.trip_member_repository import TripMemberRepository
+from app.repositories.spot_repository import SpotRepository
+from app.repositories.candidate_spot_repository import CandidateSpotRepository
+from app.repositories.candidate_reaction_repository import CandidateReactionRepository
+from app.repositories.itinerary_activity_repository import ItineraryActivityRepository
+from app.usecases.user_usecase import UserUsecase
+from app.usecases.trip_usecase import TripUsecase
+from app.usecases.trip_member_usecase import TripMemberUsecase
+from app.usecases.candidate_spot_usecase import CandidateSpotUsecase
+from app.usecases.candidate_reaction_usecase import CandidateReactionUsecase
+from app.usecases.itinerary_usecase import ItineraryUsecase
+
+
+def get_user_usecase(db: AsyncSession = Depends(get_session)) -> UserUsecase:
+    return UserUsecase(UserRepository(db))
+
+
+def get_trip_usecase(db: AsyncSession = Depends(get_session)) -> TripUsecase:
+    return TripUsecase(TripRepository(db), TripMemberRepository(db))
+
+
+def get_trip_member_usecase(db: AsyncSession = Depends(get_session)) -> TripMemberUsecase:
+    return TripMemberUsecase(TripRepository(db), TripMemberRepository(db))
+
+
+def get_candidate_spot_usecase(db: AsyncSession = Depends(get_session)) -> CandidateSpotUsecase:
+    return CandidateSpotUsecase(
+        CandidateSpotRepository(db),
+        SpotRepository(db),
+        TripMemberRepository(db),
+    )
+
+
+def get_candidate_reaction_usecase(
+    db: AsyncSession = Depends(get_session),
+) -> CandidateReactionUsecase:
+    return CandidateReactionUsecase(
+        CandidateReactionRepository(db),
+        CandidateSpotRepository(db),
+        TripMemberRepository(db),
+    )
+
+
+def get_itinerary_usecase(db: AsyncSession = Depends(get_session)) -> ItineraryUsecase:
+    return ItineraryUsecase(
+        ItineraryActivityRepository(db),
+        TripRepository(db),
+        TripMemberRepository(db),
+    )

app/config/env.py

@@ -0,0 +1,13 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8")
+
+    DATABASE_URL: str
+    SQL_ECHO: bool = False
+    SUPABASE_JWT_SECRET: str
+    GOOGLE_PLACES_API_KEY: str = ""
+
+
+settings = Settings()

app/config/jwt.py

@@ -0,0 +1,23 @@
+import uuid
+import jwt
+from fastapi import Depends
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from app.config.env import settings
+from app.exceptions.app_exceptions import UnauthorizedException
+
+_bearer = HTTPBearer()
+
+
+async def get_current_user_id(
+    credentials: HTTPAuthorizationCredentials = Depends(_bearer),
+) -> uuid.UUID:
+    try:
+        payload = jwt.decode(
+            credentials.credentials,
+            settings.SUPABASE_JWT_SECRET,
+            algorithms=["HS256"],
+            options={"verify_aud": False},
+        )
+        return uuid.UUID(payload["sub"])
+    except (jwt.InvalidTokenError, KeyError, ValueError):
+        raise UnauthorizedException()

app/infrastructure/database.py

@@ -1,20 +1,11 @@
-import os
+from typing import AsyncGenerator
 from sqlalchemy.orm import declarative_base
 from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
-from typing import AsyncGenerator
+from app.config.env import settings
 
 Base = declarative_base()
 
-# 非同期用の asyncpg を指定
-DATABASE_URL = os.getenv(
-    "DATABASE_URL",
-    "postgresql+asyncpg://myuser:mypassword@db:5432/travel_app_db",
-)
-
-engine = create_async_engine(
-    DATABASE_URL,
-    echo=os.getenv("SQL_ECHO", "false").lower() == "true",
-)
+engine = create_async_engine(settings.DATABASE_URL, echo=settings.SQL_ECHO)
 AsyncSessionLocal = async_sessionmaker(engine, expire_on_commit=False, class_=AsyncSession)
 
 

app/main.py

@@ -1,35 +1,28 @@
 from contextlib import asynccontextmanager
-from app.infrastructure.database import init_db, engine
-import app.models  # noqa: F401 — モデルを Base.metadata に登録するために必要
 from fastapi import FastAPI
 from fastapi.exceptions import RequestValidationError
+from app.infrastructure.database import init_db, engine
+import app.models  # noqa: F401
 from app.exceptions.app_exceptions import AppException
 from app.exceptions.handlers import app_exception_handler, validation_exception_handler
+from app.routers import users, trips, trip_members, candidates, reactions, itinerary
 
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    # ① 【起動時】お店を開ける前の準備（yield の前）
-    print("アプリケーションの起動処理を開始...")
-    await init_db()  # ← DBのテーブルを作成したり、接続の準備をする
-
-    yield  # ② 【営業中】ここでAPIサーバーが立ち上がり、ユーザーからのアクセスを受け付け始める！
-
-    # ③ 【終了時】サーバーを停止したときの片付け（yield の後）
-    print("シャットダウンします。DBの接続を閉じます...")
+    await init_db()
+    yield
     await engine.dispose()
 
 
 app = FastAPI(lifespan=lifespan)
+
 app.add_exception_handler(AppException, app_exception_handler)
 app.add_exception_handler(RequestValidationError, validation_exception_handler)
 
-
-@app.get("/")
-def read_root():
-    return {"Hello": "World"}
-
-
-@app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
-    return {"item_id": item_id, "q": q}
+app.include_router(users.router, prefix="/api/v1")
+app.include_router(trips.router, prefix="/api/v1")
+app.include_router(trip_members.router, prefix="/api/v1")
+app.include_router(candidates.router, prefix="/api/v1")
+app.include_router(reactions.router, prefix="/api/v1")
+app.include_router(itinerary.router, prefix="/api/v1")

app/routers/candidates.py

@@ -0,0 +1,58 @@
+import uuid
+from fastapi import APIRouter, Depends, Query, status
+from app.config.jwt import get_current_user_id
+from app.config.dependency import get_candidate_spot_usecase
+from app.usecases.candidate_spot_usecase import CandidateSpotUsecase
+from app.schemas.requests.candidate_spot import (
+    CandidateSpotCreateRequest,
+    CandidateSpotStatusUpdateRequest,
+)
+from app.schemas.responses.candidate_spot import CandidateSpotResponse, CandidateSpotListResponse
+
+router = APIRouter(prefix="/trips", tags=["candidates"])
+
+
+@router.post(
+    "/{trip_id}/candidates",
+    response_model=CandidateSpotResponse,
+    status_code=status.HTTP_201_CREATED,
+)
+async def add_candidate(
+    trip_id: uuid.UUID,
+    request: CandidateSpotCreateRequest,
+    current_user_id: uuid.UUID = Depends(get_current_user_id),
+    usecase: CandidateSpotUsecase = Depends(get_candidate_spot_usecase),
+):
+    return await usecase.add(trip_id, current_user_id, request)
+
+
+@router.get("/{trip_id}/candidates", response_model=CandidateSpotListResponse)
+async def list_candidates(
+    trip_id: uuid.UUID,
+    candidate_status: str | None = Query(default=None,alias="status"),
+    current_user_id: uuid.UUID = Depends(get_current_user_id),
+    usecase: CandidateSpotUsecase = Depends(get_candidate_spot_usecase),
+):
+    items = await usecase.get_list(trip_id, current_user_id, candidate_status)
+    return {"data": items}
+
+
+@router.patch("/{trip_id}/candidates/{candidate_id}", response_model=CandidateSpotResponse)
+async def update_candidate_status(
+    trip_id: uuid.UUID,
+    candidate_id: uuid.UUID,
+    request: CandidateSpotStatusUpdateRequest,
+    current_user_id: uuid.UUID = Depends(get_current_user_id),
+    usecase: CandidateSpotUsecase = Depends(get_candidate_spot_usecase),
+):
+    return await usecase.update_status(trip_id, candidate_id, current_user_id, request)
+
+
+@router.delete("/{trip_id}/candidates/{candidate_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_candidate(
+    trip_id: uuid.UUID,
+    candidate_id: uuid.UUID,
+    current_user_id: uuid.UUID = Depends(get_current_user_id),
+    usecase: CandidateSpotUsecase = Depends(get_candidate_spot_usecase),
+):
+    await usecase.delete(trip_id, candidate_id, current_user_id)

app/routers/itinerary.py

@@ -0,0 +1,68 @@
+import uuid
+from fastapi import APIRouter, Depends, status
+from app.config.jwt import get_current_user_id
+from app.config.dependency import get_itinerary_usecase
+from app.usecases.itinerary_usecase import ItineraryUsecase
+from app.schemas.requests.itinerary import (
+    ActivityCreateRequest,
+    ActivityUpdateRequest,
+    ActivityReorderRequest,
+)
+from app.schemas.responses.itinerary import ActivityResponse, ItineraryResponse, ReorderResponse
+
+router = APIRouter(prefix="/trips", tags=["itinerary"])
+
+
+@router.get("/{trip_id}/itinerary", response_model=ItineraryResponse)
+async def get_itinerary(
+    trip_id: uuid.UUID,
+    current_user_id: uuid.UUID = Depends(get_current_user_id),
+    usecase: ItineraryUsecase = Depends(get_itinerary_usecase),
+):
+    return await usecase.get_itinerary(trip_id, current_user_id)
+
+
+@router.post(
+    "/{trip_id}/itinerary",
+    response_model=ActivityResponse,
+    status_code=status.HTTP_201_CREATED,
+)
+async def add_activity(
+    trip_id: uuid.UUID,
+    request: ActivityCreateRequest,
+    current_user_id: uuid.UUID = Depends(get_current_user_id),
+    usecase: ItineraryUsecase = Depends(get_itinerary_usecase),
+):
+    return await usecase.add_activity(trip_id, current_user_id, request)
+
+
+@router.patch("/{trip_id}/itinerary/{activity_id}", response_model=ActivityResponse)
+async def update_activity(
+    trip_id: uuid.UUID,
+    activity_id: uuid.UUID,
+    request: ActivityUpdateRequest,
+    current_user_id: uuid.UUID = Depends(get_current_user_id),
+    usecase: ItineraryUsecase = Depends(get_itinerary_usecase),
+):
+    return await usecase.update_activity(trip_id, activity_id, current_user_id, request)
+
+
+@router.delete("/{trip_id}/itinerary/{activity_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_activity(
+    trip_id: uuid.UUID,
+    activity_id: uuid.UUID,
+    current_user_id: uuid.UUID = Depends(get_current_user_id),
+    usecase: ItineraryUsecase = Depends(get_itinerary_usecase),
+):
+    await usecase.delete_activity(trip_id, activity_id, current_user_id)
+
+
+@router.patch("/{trip_id}/itinerary/reorder", response_model=ReorderResponse)
+async def reorder_activities(
+    trip_id: uuid.UUID,
+    request: ActivityReorderRequest,
+    current_user_id: uuid.UUID = Depends(get_current_user_id),
+    usecase: ItineraryUsecase = Depends(get_itinerary_usecase),
+):
+    updated_count = await usecase.reorder(trip_id, current_user_id, request)
+    return {"updated_count": updated_count}

app/routers/reactions.py

@@ -0,0 +1,37 @@
+import uuid
+from fastapi import APIRouter, Depends, Query, status
+from app.config.jwt import get_current_user_id
+from app.config.dependency import get_candidate_reaction_usecase
+from app.usecases.candidate_reaction_usecase import CandidateReactionUsecase
+from app.schemas.requests.candidate_reaction import CandidateReactionUpsertRequest
+from app.schemas.responses.candidate_reaction import CandidateReactionResponse
+
+router = APIRouter(prefix="/trips", tags=["reactions"])
+
+
+@router.put(
+    "/{trip_id}/candidates/{candidate_id}/reactions",
+    response_model=CandidateReactionResponse,
+)
+async def upsert_reaction(
+    trip_id: uuid.UUID,
+    candidate_id: uuid.UUID,
+    request: CandidateReactionUpsertRequest,
+    current_user_id: uuid.UUID = Depends(get_current_user_id),
+    usecase: CandidateReactionUsecase = Depends(get_candidate_reaction_usecase),
+):
+    return await usecase.upsert(trip_id, candidate_id, current_user_id, request)
+
+
+@router.delete(
+    "/{trip_id}/candidates/{candidate_id}/reactions",
+    status_code=status.HTTP_204_NO_CONTENT,
+)
+async def delete_reaction(
+    trip_id: uuid.UUID,
+    candidate_id: uuid.UUID,
+    emoji_type: str = Query(),
+    current_user_id: uuid.UUID = Depends(get_current_user_id),
+    usecase: CandidateReactionUsecase = Depends(get_candidate_reaction_usecase),
+):
+    await usecase.delete(trip_id, candidate_id, current_user_id, emoji_type)

app/routers/trip_members.py

@@ -0,0 +1,40 @@
+import uuid
+from fastapi import APIRouter, Depends, status
+from app.config.jwt import get_current_user_id
+from app.config.dependency import get_trip_member_usecase
+from app.usecases.trip_member_usecase import TripMemberUsecase
+from app.schemas.requests.trip import TripJoinRequest
+from app.schemas.requests.trip_member import TripMemberRoleUpdateRequest
+from app.schemas.responses.trip_member import TripMemberResponse
+
+router = APIRouter(prefix="/trips", tags=["trip_members"])
+
+
+@router.post("/join", response_model=TripMemberResponse, status_code=status.HTTP_201_CREATED)
+async def join_trip(
+    request: TripJoinRequest,
+    current_user_id: uuid.UUID = Depends(get_current_user_id),
+    usecase: TripMemberUsecase = Depends(get_trip_member_usecase),
+):
+    return await usecase.join(request.invite_code, current_user_id)
+
+
+@router.patch("/{trip_id}/members/{user_id}", response_model=TripMemberResponse)
+async def update_member_role(
+    trip_id: uuid.UUID,
+    user_id: uuid.UUID,
+    request: TripMemberRoleUpdateRequest,
+    current_user_id: uuid.UUID = Depends(get_current_user_id),
+    usecase: TripMemberUsecase = Depends(get_trip_member_usecase),
+):
+    return await usecase.update_role(trip_id, user_id, current_user_id, request)
+
+
+@router.delete("/{trip_id}/members/{user_id}", status_code=status.HTTP_204_NO_CONTENT)
+async def remove_member(
+    trip_id: uuid.UUID,
+    user_id: uuid.UUID,
+    current_user_id: uuid.UUID = Depends(get_current_user_id),
+    usecase: TripMemberUsecase = Depends(get_trip_member_usecase),
+):
+    await usecase.remove(trip_id, user_id, current_user_id)