♻️ auth 패키지 구현체 및 DI 도입, email 패키지 분리

app/api/v1/router.py

@@ -1,14 +1,12 @@
 from fastapi import APIRouter
 
 from app.api.v1.endpoints.application import router as application_router
-from app.api.v1.endpoints.auth import router as auth_router
 from app.api.v1.endpoints.deposit import router as deposit_router
 from app.api.v1.endpoints.event import router as event_router
 from app.api.v1.endpoints.s3 import router as s3_router
 from app.api.v1.endpoints.store import router as store_router
 
 router = APIRouter()
-router.include_router(auth_router)
 router.include_router(store_router)
 router.include_router(event_router)
 router.include_router(application_router)

app/auth/dependencies.py

@@ -0,0 +1,32 @@
+from fastapi import Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.auth.repository import EmailVerificationRepository, UserRepository
+from app.auth.repository_impl import EmailVerificationRepositoryImpl, UserRepositoryImpl
+from app.auth.service import AuthService
+from app.auth.service_impl import AuthServiceImpl
+from app.db.session import get_db
+from app.email.service import EmailSender
+from app.email.service_impl import SmtpEmailSender
+
+
+def get_user_repository(db: AsyncSession = Depends(get_db)) -> UserRepository:
+    return UserRepositoryImpl(db)
+
+
+def get_email_verification_repository(
+    db: AsyncSession = Depends(get_db),
+) -> EmailVerificationRepository:
+    return EmailVerificationRepositoryImpl(db)
+
+
+def get_email_sender() -> EmailSender:
+    return SmtpEmailSender()
+
+
+def get_auth_service(
+    user_repo: UserRepository = Depends(get_user_repository),
+    ev_repo: EmailVerificationRepository = Depends(get_email_verification_repository),
+    email_sender: EmailSender = Depends(get_email_sender),
+) -> AuthService:
+    return AuthServiceImpl(user_repo, ev_repo, email_sender)

app/auth/models.py

@@ -0,0 +1,41 @@
+from datetime import datetime
+from typing import TYPE_CHECKING
+from uuid import UUID, uuid4
+
+from sqlalchemy import Boolean, DateTime, Enum, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.sql import func
+
+from app.db.base import Base
+
+if TYPE_CHECKING:
+    from app.models.deposit import Deposit
+
+
+class User(Base):
+    __tablename__ = "users"
+
+    id: Mapped[UUID] = mapped_column(primary_key=True, default=uuid4)
+    username: Mapped[str] = mapped_column(String(50))
+    email: Mapped[str] = mapped_column(String(255), unique=True, index=True)
+    password_hash: Mapped[str] = mapped_column(String)
+    role: Mapped[str] = mapped_column(Enum("OWNER", "REVIEWER", name="user_role"))
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )
+
+    deposits: Mapped[list["Deposit"]] = relationship("Deposit", back_populates="user")
+
+
+class EmailVerification(Base):
+    __tablename__ = "email_verifications"
+
+    id: Mapped[UUID] = mapped_column(primary_key=True, default=uuid4)
+    email: Mapped[str] = mapped_column(String(255), index=True)
+    code: Mapped[str] = mapped_column(String(6))
+    verification_token: Mapped[str | None] = mapped_column(String, nullable=True)
+    is_verified: Mapped[bool] = mapped_column(Boolean, default=False)
+    expires_at: Mapped[datetime] = mapped_column(DateTime(timezone=True))
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), server_default=func.now()
+    )

app/auth/repository.py

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+
+from app.auth.models import EmailVerification, User
+
+
+class UserRepository(ABC):
+    @abstractmethod
+    async def find_by_email(self, email: str) -> User | None: ...
+
+    @abstractmethod
+    async def find_by_id(self, user_id: str) -> User | None: ...
+
+    @abstractmethod
+    async def save(self, user: User) -> User: ...
+
+
+class EmailVerificationRepository(ABC):
+    @abstractmethod
+    async def save(self, verification: EmailVerification) -> None: ...
+
+    @abstractmethod
+    async def find_latest_unverified(
+        self, email: str, code: str
+    ) -> EmailVerification | None: ...
+
+    @abstractmethod
+    async def update(self, verification: EmailVerification) -> None: ...

app/auth/repository_impl.py

@@ -0,0 +1,61 @@
+from datetime import UTC, datetime
+from typing import cast
+from uuid import UUID
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.auth.models import EmailVerification, User
+from app.auth.repository import EmailVerificationRepository, UserRepository
+
+
+class UserRepositoryImpl(UserRepository):
+    def __init__(self, db: AsyncSession) -> None:
+        self.db = db
+
+    async def find_by_email(self, email: str) -> User | None:
+        return cast(
+            User | None,
+            await self.db.scalar(select(User).where(User.email == email)),
+        )
+
+    async def find_by_id(self, user_id: str) -> User | None:
+        return cast(
+            User | None,
+            await self.db.scalar(select(User).where(User.id == UUID(user_id))),
+        )
+
+    async def save(self, user: User) -> User:
+        self.db.add(user)
+        await self.db.commit()
+        await self.db.refresh(user)
+        return user
+
+
+class EmailVerificationRepositoryImpl(EmailVerificationRepository):
+    def __init__(self, db: AsyncSession) -> None:
+        self.db = db
+
+    async def save(self, verification: EmailVerification) -> None:
+        self.db.add(verification)
+        await self.db.commit()
+
+    async def find_latest_unverified(
+        self, email: str, code: str
+    ) -> EmailVerification | None:
+        return cast(
+            EmailVerification | None,
+            await self.db.scalar(
+                select(EmailVerification)
+                .where(
+                    EmailVerification.email == email,
+                    EmailVerification.code == code,
+                    EmailVerification.is_verified.is_(False),
+                    EmailVerification.expires_at > datetime.now(UTC),
+                )
+                .order_by(EmailVerification.created_at.desc())
+            ),
+        )
+
+    async def update(self, verification: EmailVerification) -> None:
+        await self.db.commit()

app/api/v1/endpoints/auth.py → app/auth/router.py

@@ -1,10 +1,8 @@
 from fastapi import APIRouter, Depends, Request, Response
-from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.api.v1.deps import require_login
-from app.core.exceptions import AUTH_001, AppException
-from app.db.session import get_db
-from app.schemas.auth import (
+from app.auth.dependencies import get_auth_service
+from app.auth.schemas import (
     AccessTokenResp,
     AuthResp,
     ChangePasswordReq,
@@ -17,43 +15,44 @@
     ResetPasswordReq,
     UserInfo,
 )
-from app.services import auth as auth_service
+from app.auth.service import AuthService
+from app.core.exceptions import AUTH_001, AppException
 
 router = APIRouter(prefix="/auth", tags=["Auth"])
 
 
 @router.post("/email", response_model=None)
 async def check_email(
     body: EmailCheckReq,
-    db: AsyncSession = Depends(get_db),
+    service: AuthService = Depends(get_auth_service),
 ) -> None:
-    await auth_service.check_email_duplicate(db, body.email)
+    await service.check_email_duplicate(body.email)
 
 
 @router.post("/email/verify", response_model=None)
 async def verify_email(
     body: EmailVerifyReq,
-    db: AsyncSession = Depends(get_db),
+    service: AuthService = Depends(get_auth_service),
 ) -> None:
-    await auth_service.send_verification_code(db, body.email)
+    await service.send_verification_code(body.email)
 
 
 @router.post("/email/validate", response_model=EmailValidateResp)
 async def validate_email(
     body: EmailValidateReq,
-    db: AsyncSession = Depends(get_db),
+    service: AuthService = Depends(get_auth_service),
 ) -> EmailValidateResp:
-    token = await auth_service.validate_verification_code(db, body.email, body.code)
+    token = await service.validate_verification_code(body.email, body.code)
     return EmailValidateResp(verificationToken=token)
 
 
 @router.post("/user", response_model=AuthResp)
 async def register(
     body: RegisterReq,
     response: Response,
-    db: AsyncSession = Depends(get_db),
+    service: AuthService = Depends(get_auth_service),
 ) -> AuthResp:
-    user, access_token, refresh_token = await auth_service.register(db, body)
+    user, access_token, refresh_token = await service.register(body)
     response.set_cookie(
         key="refresh_token",
         value=refresh_token,
@@ -67,21 +66,24 @@ async def register(
 
 
 @router.get("/token", response_model=AccessTokenResp)
-async def refresh_token(request: Request) -> AccessTokenResp:
+async def refresh_token(
+    request: Request,
+    service: AuthService = Depends(get_auth_service),
+) -> AccessTokenResp:
     token = request.cookies.get("refresh_token")
     if not token:
         raise AppException(AUTH_001)
-    access_token = auth_service.refresh_access_token(token)
+    access_token = service.refresh_access_token(token)
     return AccessTokenResp(accessToken=access_token)
 
 
 @router.post("/user/session", response_model=AuthResp)
 async def login(
     body: LoginReq,
     response: Response,
-    db: AsyncSession = Depends(get_db),
+    service: AuthService = Depends(get_auth_service),
 ) -> AuthResp:
-    user, access_token, refresh_token = await auth_service.login(db, body)
+    user, access_token, refresh_token = await service.login(body)
     response.set_cookie(
         key="refresh_token",
         value=refresh_token,
@@ -105,15 +107,15 @@ async def logout(
 @router.patch("/password", response_model=None)
 async def change_password(
     body: ChangePasswordReq,
-    db: AsyncSession = Depends(get_db),
+    service: AuthService = Depends(get_auth_service),
     user_id: str = Depends(require_login),
 ) -> None:
-    await auth_service.change_password(db, user_id, body.oldPassword, body.newPassword)
+    await service.change_password(user_id, body.oldPassword, body.newPassword)
 
 
 @router.post("/password", response_model=None)
 async def reset_password(
     body: ResetPasswordReq,
-    db: AsyncSession = Depends(get_db),
+    service: AuthService = Depends(get_auth_service),
 ) -> None:
-    await auth_service.reset_password(db, body)
+    await service.reset_password(body)

app/auth/service.py

@@ -0,0 +1,32 @@
+from abc import ABC, abstractmethod
+
+from app.auth.models import User
+from app.auth.schemas import LoginReq, RegisterReq, ResetPasswordReq
+
+
+class AuthService(ABC):
+    @abstractmethod
+    async def check_email_duplicate(self, email: str) -> None: ...
+
+    @abstractmethod
+    async def send_verification_code(self, email: str) -> None: ...
+
+    @abstractmethod
+    async def validate_verification_code(self, email: str, code: str) -> str: ...
+
+    @abstractmethod
+    async def register(self, data: RegisterReq) -> tuple[User, str, str]: ...
+
+    @abstractmethod
+    def refresh_access_token(self, refresh_token: str) -> str: ...
+
+    @abstractmethod
+    async def login(self, data: LoginReq) -> tuple[User, str, str]: ...
+
+    @abstractmethod
+    async def change_password(
+        self, user_id: str, old_password: str, new_password: str
+    ) -> None: ...
+
+    @abstractmethod
+    async def reset_password(self, data: ResetPasswordReq) -> None: ...