✨ 더미 데이터 생성 로직 추가 및 불필요한 Success Response 래핑 제거

app/api/v1/endpoints/application.py

@@ -8,62 +8,54 @@
     ApplicationListResp,
     ReviewSubmissionReq,
 )
-from app.schemas.common import SuccessResponse
 from app.services import application as application_service
 
 router = APIRouter(tags=["Application"])
 
 
-@router.post("/applications", response_model=SuccessResponse[None])
+@router.post("/applications", response_model=None)
 async def create_application(
     body: ApplicationCreateReq,
     db: AsyncSession = Depends(get_db),
     reviewer_id: str = Depends(require_login),
-) -> SuccessResponse[None]:
+) -> None:
     await application_service.create_application(db, reviewer_id, body)
-    return SuccessResponse(data=None)
 
 
-@router.get("/application", response_model=SuccessResponse[ApplicationListResp])
+@router.get("/application", response_model=ApplicationListResp)
 async def get_my_applications(
-    page: int = Query(default=1, ge=1),
+    page: int = Query(default=0, ge=0),
     size: int = Query(default=20, ge=1),
     db: AsyncSession = Depends(get_db),
     reviewer_id: str = Depends(require_login),
-) -> SuccessResponse[ApplicationListResp]:
+) -> ApplicationListResp:
     applications, total = await application_service.list_my_applications(
         db, reviewer_id, page, size
     )
     total_pages = max(1, (total + size - 1) // size)
-    return SuccessResponse(
-        data=ApplicationListResp(
-            applications=applications,
-            totalCount=total,
-            currentPage=page,
-            totalPages=total_pages,
-            hasNext=page < total_pages,
-        )
+    return ApplicationListResp(
+        applications=applications,
+        totalCount=total,
+        currentPage=page,
+        totalPages=total_pages,
+        hasNext=(page + 1) < total_pages,
     )
 
 
-@router.delete("/application/{applicationId}", response_model=SuccessResponse[None])
+@router.delete("/application/{applicationId}", response_model=None)
 async def cancel_application(
     applicationId: str,
     db: AsyncSession = Depends(get_db),
     user_id: str = Depends(require_login),
-) -> SuccessResponse[None]:
+) -> None:
     await application_service.cancel_application(db, applicationId, user_id)
-    return SuccessResponse(data=None)
 
 
-@router.post(
-    "/application/{applicationId}/submission", response_model=SuccessResponse[None]
-)
+@router.post("/application/{applicationId}/submission", response_model=None)
 async def submit_review(
     applicationId: str,
     body: ReviewSubmissionReq,
     db: AsyncSession = Depends(get_db),
     user_id: str = Depends(require_login),
-) -> SuccessResponse[None]:
+) -> None:
     await application_service.submit_review(db, applicationId, user_id, body)
-    return SuccessResponse(data=None)

app/api/v1/endpoints/auth.py

@@ -17,113 +17,103 @@
     ResetPasswordReq,
     UserInfo,
 )
-from app.schemas.common import SuccessResponse
 from app.services import auth as auth_service
 
 router = APIRouter(prefix="/auth", tags=["Auth"])
 
 
-@router.post("/email", response_model=SuccessResponse[None])
+@router.post("/email", response_model=None)
 async def check_email(
     body: EmailCheckReq,
     db: AsyncSession = Depends(get_db),
-) -> SuccessResponse[None]:
+) -> None:
     await auth_service.check_email_duplicate(db, body.email)
-    return SuccessResponse(data=None)
 
 
-@router.post("/email/verify", response_model=SuccessResponse[None])
+@router.post("/email/verify", response_model=None)
 async def verify_email(
     body: EmailVerifyReq,
     db: AsyncSession = Depends(get_db),
-) -> SuccessResponse[None]:
+) -> None:
     await auth_service.send_verification_code(db, body.email)
-    return SuccessResponse(data=None)
 
 
-@router.post("/email/validate", response_model=SuccessResponse[EmailValidateResp])
+@router.post("/email/validate", response_model=EmailValidateResp)
 async def validate_email(
     body: EmailValidateReq,
     db: AsyncSession = Depends(get_db),
-) -> SuccessResponse[EmailValidateResp]:
+) -> EmailValidateResp:
     token = await auth_service.validate_verification_code(db, body.email, body.code)
-    return SuccessResponse(data=EmailValidateResp(verificationToken=token))
+    return EmailValidateResp(verificationToken=token)
 
 
-@router.post("/user", response_model=SuccessResponse[AuthResp])
+@router.post("/user", response_model=AuthResp)
 async def register(
     body: RegisterReq,
     response: Response,
     db: AsyncSession = Depends(get_db),
-) -> SuccessResponse[AuthResp]:
+) -> AuthResp:
     user, access_token, refresh_token = await auth_service.register(db, body)
     response.set_cookie(
         key="refresh_token",
         value=refresh_token,
         httponly=True,
         samesite="lax",
     )
-    return SuccessResponse(
-        data=AuthResp(
-            user=UserInfo(id=str(user.id), userRole=user.role),
-            token=access_token,
-        )
+    return AuthResp(
+        user=UserInfo(id=str(user.id), userRole=user.role),
+        token=access_token,
     )
 
 
-@router.get("/token", response_model=SuccessResponse[AccessTokenResp])
-async def refresh_token(request: Request) -> SuccessResponse[AccessTokenResp]:
+@router.get("/token", response_model=AccessTokenResp)
+async def refresh_token(request: Request) -> AccessTokenResp:
     token = request.cookies.get("refresh_token")
     if not token:
         raise AppException(AUTH_001)
     access_token = auth_service.refresh_access_token(token)
-    return SuccessResponse(data=AccessTokenResp(accessToken=access_token))
+    return AccessTokenResp(accessToken=access_token)
 
 
-@router.post("/user/session", response_model=SuccessResponse[AuthResp])
+@router.post("/user/session", response_model=AuthResp)
 async def login(
     body: LoginReq,
     response: Response,
     db: AsyncSession = Depends(get_db),
-) -> SuccessResponse[AuthResp]:
+) -> AuthResp:
     user, access_token, refresh_token = await auth_service.login(db, body)
     response.set_cookie(
         key="refresh_token",
         value=refresh_token,
         httponly=True,
         samesite="lax",
     )
-    return SuccessResponse(
-        data=AuthResp(
-            user=UserInfo(id=str(user.id), userRole=user.role),
-            token=access_token,
-        )
+    return AuthResp(
+        user=UserInfo(id=str(user.id), userRole=user.role),
+        token=access_token,
     )
 
 
-@router.delete("/user/session", response_model=SuccessResponse[None])
+@router.delete("/user/session", response_model=None)
 async def logout(
     response: Response,
     _user_id: str = Depends(require_login),
-) -> SuccessResponse[None]:
+) -> None:
     response.delete_cookie(key="refresh_token", httponly=True, samesite="lax")
-    return SuccessResponse(data=None)
 
 
-@router.patch("/password", response_model=SuccessResponse[None])
+@router.patch("/password", response_model=None)
 async def change_password(
     body: ChangePasswordReq,
     db: AsyncSession = Depends(get_db),
     user_id: str = Depends(require_login),
-) -> SuccessResponse[None]:
+) -> None:
     await auth_service.change_password(db, user_id, body.oldPassword, body.newPassword)
-    return SuccessResponse(data=None)
 
 
-@router.post("/password", response_model=SuccessResponse[None])
+@router.post("/password", response_model=None)
 async def reset_password(
     body: ResetPasswordReq,
     db: AsyncSession = Depends(get_db),
-) -> SuccessResponse[None]:
+) -> None:
     await auth_service.reset_password(db, body)
-    return SuccessResponse(data=None)

app/api/v1/endpoints/deposit.py

@@ -3,18 +3,16 @@
 
 from app.api.v1.deps import require_login
 from app.db.session import get_db
-from app.schemas.common import SuccessResponse
 from app.schemas.deposit import DepositReq, DepositResp
 from app.services import deposit as deposit_service
 
 router = APIRouter(prefix="/deposit", tags=["Deposit"])
 
 
-@router.post("", response_model=SuccessResponse[DepositResp])
+@router.post("", response_model=DepositResp)
 async def create_deposit(
     body: DepositReq,
     db: AsyncSession = Depends(get_db),
     user_id: str = Depends(require_login),
-) -> SuccessResponse[DepositResp]:
-    result = await deposit_service.create_deposit(db, user_id, body)
-    return SuccessResponse(data=result)
+) -> DepositResp:
+    return await deposit_service.create_deposit(db, user_id, body)

app/api/v1/endpoints/event.py

@@ -3,7 +3,6 @@
 
 from app.api.v1.deps import require_login
 from app.db.session import get_db
-from app.schemas.common import SuccessResponse
 from app.schemas.event import (
     EventApplicationsResp,
     EventCreateReq,
@@ -15,94 +14,83 @@
 router = APIRouter(prefix="/event", tags=["Event"])
 
 
-@router.get("/owner", response_model=SuccessResponse[EventListResp])
+@router.get("/owner", response_model=EventListResp)
 async def get_owner_events(
     db: AsyncSession = Depends(get_db),
     owner_id: str = Depends(require_login),
-) -> SuccessResponse[EventListResp]:
+) -> EventListResp:
     events = await event_service.list_owner_events(db, owner_id)
-    return SuccessResponse(
-        data=EventListResp(
-            events=[
-                EventResp(
-                    id=str(e.id),
-                    title=e.title,
-                    condition=e.condition,
-                    reward=e.reward,
-                    isActive=e.is_active,
-                )
-                for e in events
-            ]
-        )
+    return EventListResp(
+        events=[
+            EventResp(
+                id=str(e.id),
+                title=e.title,
+                condition=e.condition,
+                reward=e.reward,
+                isActive=e.is_active,
+            )
+            for e in events
+        ]
     )
 
 
-@router.get("/{eventId}", response_model=SuccessResponse[EventResp])
+@router.get("/{eventId}", response_model=EventResp)
 async def get_event(
     eventId: str,
     db: AsyncSession = Depends(get_db),
-) -> SuccessResponse[EventResp]:
+) -> EventResp:
     event = await event_service.get_event_or_404(db, eventId)
-    return SuccessResponse(
-        data=EventResp(
-            id=str(event.id),
-            title=event.title,
-            condition=event.condition,
-            reward=event.reward,
-            isActive=event.is_active,
-        )
+    return EventResp(
+        id=str(event.id),
+        title=event.title,
+        condition=event.condition,
+        reward=event.reward,
+        isActive=event.is_active,
     )
 
 
-@router.get(
-    "/{eventId}/applications", response_model=SuccessResponse[EventApplicationsResp]
-)
+@router.get("/{eventId}/applications", response_model=EventApplicationsResp)
 async def get_event_applications(
     eventId: str,
     status: str | None = Query(default=None),
-    page: int = Query(default=1, ge=1),
+    page: int = Query(default=0, ge=0),
     size: int = Query(default=20, ge=1),
     db: AsyncSession = Depends(get_db),
     owner_id: str = Depends(require_login),
-) -> SuccessResponse[EventApplicationsResp]:
+) -> EventApplicationsResp:
     applications, total = await event_service.list_event_applications(
         db, eventId, owner_id, status, page, size
     )
     total_pages = max(1, (total + size - 1) // size)
-    return SuccessResponse(
-        data=EventApplicationsResp(
-            applications=applications,
-            totalCount=total,
-            currentPage=page,
-            totalPages=total_pages,
-            hasNext=page < total_pages,
-        )
+    return EventApplicationsResp(
+        applications=applications,
+        totalCount=total,
+        currentPage=page,
+        totalPages=total_pages,
+        hasNext=(page + 1) < total_pages,
     )
 
 
-@router.delete("/{eventId}", response_model=SuccessResponse[None])
+@router.delete("/{eventId}", response_model=None)
 async def delete_event(
     eventId: str,
     db: AsyncSession = Depends(get_db),
     owner_id: str = Depends(require_login),
-) -> SuccessResponse[None]:
+) -> None:
     await event_service.delete_event(db, eventId, owner_id)
-    return SuccessResponse(data=None)
 
 
-@router.post("", response_model=SuccessResponse[EventResp])
+@router.post("", response_model=EventResp)
 async def create_event(
     body: EventCreateReq,
     db: AsyncSession = Depends(get_db),
     owner_id: str = Depends(require_login),
-) -> SuccessResponse[EventResp]:
+) -> EventResp:
     event = await event_service.create_event(db, owner_id, body)
-    return SuccessResponse(
-        data=EventResp(
-            id=str(event.id),
-            title=event.title,
-            condition=event.condition,
-            reward=event.reward,
-            isActive=event.is_active,
-        )
+    return EventResp(
+        id=str(event.id),
+        title=event.title,
+        condition=event.condition,
+        reward=event.reward,
+        isActive=event.is_active,
     )