인프런 커뮤니티 질문&답변

안녕하세요. 좋은 강의 감사합니다.

강의를 기반으로 제 방식대로 서버를 구성하다가 알 수 없는 에러에 빠졌습니다.

서버는 정상 구동은 되고, postman으로 root url인 localhost:8000/ 에 request를 날리면 정상적으로 결과값을 반환 받는데
localhost:8000/api/recommend?userId=1 만 호출하면 바로 에러메세지 없이 500만 응답으로 받고 있습니다.

print(1) 도 서버 로그에 찍히지 않고 서버 로그는 아예 나오질 않네요.localhost:8000/ 에서도 동일하게 서버 로그는 찍히지 않습니다

우선 의도는 BaseRepository 클래스를 만들어서 find_by_id 같은 중복 코드를 하나로 관리해보려고 했습니다.

의존성 주입 부분은 지피티의 도움을 받아서 위치를 조정했습니다.

도저히 어디서 문제가 난건지 알 수 없어서 도움 요청 드립니다 ㅜㅜ

# main.py
from typing import Dict

from dotenv import load_dotenv
from fastapi import FastAPI

from src.app.app import create_app


load_dotenv()

app: FastAPI = create_app()

@app.get("/")
async def health_check_handler() -> Dict[str, str]:
    return {"statusMsg": "good"}

# app.py
from contextlib import asynccontextmanager
from typing import AsyncGenerator

import anyio
from fastapi import FastAPI

from src.app.endpoints.recommend import router

@asynccontextmanager
async def lifespan(app: FastAPI) -> AsyncGenerator:
    limiter = anyio.to_thread.current_default_thread_limiter()
    limiter.total_tokens = 200
    yield

def create_app() -> FastAPI:
    app = FastAPI(lifespan=lifespan)
    app.include_router(router, prefix="/api")
    # 다른 설정들(예: 미들웨어, 이벤트 핸들러 등)을 추가할 수 있습니다.
    return app

# connection.py
import os
import urllib

from typing import AsyncGenerator

from dotenv import load_dotenv
from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker, create_async_engine

load_dotenv()

DB_USERNAME: str = os.getenv("DB_USERNAME", "root")
DB_PASSWORD: str = os.getenv("DB_PASSWORD", "root")
DB_HOST: str = os.getenv("DB_HOST", "127.0.0.1")
DB_NAME: str = os.getenv("DB_NAME", "")
DB_PORT: str = os.getenv("DB_PORT", "3306")
DB_ECHO: bool = os.getenv("DB_ECHO", "true").lower() == "true"

if not DB_NAME:
    raise ValueError("DB_NAME 환경변수가 설정되지 않았습니다.")

# 비밀번호 특수문자 허용
encoded_password = urllib.parse.quote_plus(DB_PASSWORD)

DATABASE_URL: str = f"mysql+asyncmy://{DB_USERNAME}:{encoded_password}@{DB_HOST}:{DB_PORT}/{DB_NAME}"

engine: AsyncEngine = create_async_engine(
    DATABASE_URL,
    echo=DB_ECHO,
    pool_size=10,
    max_overflow=0,
    pool_timeout=30, # second
    pool_recycle=60,  # second
    pool_pre_ping=True,
)
SessionFactory = async_sessionmaker(autocommit=False, autoflush=False, bind=engine)

async def get_db() -> AsyncGenerator[AsyncSession, None]:
    session = SessionFactory()
    try:
        yield session
    finally:
        await session.close()

# user_route.py
from typing import Dict

from fastapi import APIRouter, Depends, status

from src.app.dependency.query_param_denpendency import snake_case_query
from src.core.common_type import V
from src.core.exception.not_found_exceptions import UserNotFoundExceiption
from src.db.connection import get_db
from src.entity.user import UserEntity
from src.repository.user import UserRepository, get_user_repository
from src.dto.response.user_response import UserResponse


router = APIRouter(prefix="/recommend")

@router.get(path="", status_code=status.HTTP_200_OK, response_model=UserResponse)
async def get_recommend_schedule(
    params: Dict[str, V]=Depends(snake_case_query),
    user_repo: UserRepository=Depends(get_user_repository)
):
    print(1)
    user_id: int = int(params.get("user_id", None))

    user: UserEntity | None = await user_repo.get_user_by_id(user_id)

    if not user:
        raise UserNotFoundExceiption()
    user = UserResponse.model_validate(user)

    return user

# base_repository.py
from typing import Type

from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from src.core.common_type import E


class BaseRepository:
    def __init__(self, db: AsyncSession):
        self.db = db

    async def get_entity_by_id(self, model: Type[E], entity_id: int) -> E | None:
        print(2)
        entity: E | None = await self.db.execute(select(model).where(model.id==entity_id))

        return entity.scalars().first()

# user_repo.py
from fastapi import Depends
from sqlalchemy.ext.asyncio import AsyncSession

from src.db.connection import get_db
from src.entity.user import UserEntity
from src.repository.base_repository import BaseRepository


def get_user_repository(db: AsyncSession = Depends(get_db)) -> "UserRepository":
    return UserRepository(db)

class UserRepository(BaseRepository):

    async def get_user_by_id(self, user_id: int) -> UserEntity | None:
        print(3)
        return await self.get_entity_by_id(UserEntity, user_id)

# user_response.py
from datetime import datetime
from typing import Optional

from pydantic import BaseModel


class UserResponse(BaseModel):
    id: int
    name: str
    nickname: str
    email: str
    phone: str
    join_date: datetime
    updated_at: Optional[datetime] = None
    deleted_at: Optional[datetime] = None
    class Config:
        from_attributes = True

도대체 어디서 문제가 생긴걸까요...