auth

api/app_builder/dependencies.py

@@ -1,22 +1,23 @@
 from fastapi import FastAPI
-from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker
+from sqlalchemy.ext.asyncio import (AsyncEngine, AsyncSession,
+                                    async_sessionmaker)
 
 from api.application.abstractions.uow import UnitOfWork
 from api.application.protocols.date_time import DateTimeProvider
+from api.application.protocols.jwt import JwtTokenProcessor
 from api.application.protocols.password_hasher import PasswordHasher
+from api.application.usecase.auth.auth_user import LoginUser
 from api.application.usecase.auth.create_user import CreateUser
 from api.domain.user.repository import UserRepository
-from api.infrastructure.dependencies.adapters import (
-    create_engine,
-    create_session_maker,
-    new_session,
-    new_unit_of_work,
-)
+from api.infrastructure.dependencies.adapters import (create_engine,
+                                                      create_session_maker,
+                                                      new_session,
+                                                      new_unit_of_work)
 from api.infrastructure.dependencies.configs import app_settings
-from api.infrastructure.dependencies.protocols import (
-    get_date_time_provider,
-    get_password_hasher,
-)
+from api.infrastructure.dependencies.protocols import (get_date_time_provider,
+                                                       get_jwt_token_processor,
+                                                       get_password_hasher,
+                                                       get_user_login)
 from api.infrastructure.dependencies.repositories import get_user_repository
 from api.infrastructure.dependencies.usecases import provide_create_user
 from api.infrastructure.settings import Settings
@@ -34,6 +35,9 @@ def init_dependencies(app: FastAPI) -> None:
     app.dependency_overrides[DateTimeProvider] = get_date_time_provider
     app.dependency_overrides[PasswordHasher] = get_password_hasher
 
+    app.dependency_overrides[JwtTokenProcessor] = get_jwt_token_processor
+    app.dependency_overrides[LoginUser] = get_user_login
+
     app.dependency_overrides[UserRepository] = get_user_repository
 
     app.dependency_overrides[CreateUser] = provide_create_user

api/application/usecase/auth/auth_user.py

@@ -15,12 +15,16 @@ class LoginUser:
         self.hasher = password_hasher
 
     async def __call__(self, request: LoginRequest) -> AuthenticationResponse:
+        print("__call__ request", request)
         user = await self.user_repository.get_user(filter={"email": request.email})
+        print("__call__ user from repo", user)
         error = UserInvalidCredentialsError("Email or password is incorrect")
         if user is None:
+            print("user is none in LoginUser __call__")
             raise error
 
         if not self.hasher.verify_password(request.password, user.hashed_password):
+            print("wrong pass in LoginUser __call__")
             raise error
 
         return AuthenticationResponse(

api/infrastructure/dependencies/protocols.py

@@ -1,7 +1,17 @@
+from typing import Annotated
+
+from fastapi import Depends
+
 from api.application.protocols.date_time import DateTimeProvider
+from api.application.protocols.jwt import JwtTokenProcessor
 from api.application.protocols.password_hasher import PasswordHasher
+from api.application.usecase.auth.auth_user import LoginUser
+from api.domain.user.repository import UserRepository
+from api.infrastructure.auth.jwt_processor import JoseJwtTokenProcessor
 from api.infrastructure.date_time import SystemDateTimeProvider, Timezone
+from api.infrastructure.dependencies.stub import Stub
 from api.infrastructure.security.password_hasher import Pbkdf2PasswordHasher
+from api.infrastructure.settings import Settings
 
 
 def get_password_hasher() -> PasswordHasher:
@@ -10,3 +20,19 @@ def get_password_hasher() -> PasswordHasher:
 
 def get_date_time_provider() -> DateTimeProvider:
     return SystemDateTimeProvider(Timezone.UTC)
+
+
+def get_jwt_token_processor(
+    settings: Annotated[Settings, Depends(Stub(Settings))],
+    date_time_provider: Annotated[DateTimeProvider, Depends(Stub(DateTimeProvider))],
+) -> JwtTokenProcessor:
+    return JoseJwtTokenProcessor(
+        jwt_options=settings.jwt, date_time_provider=date_time_provider
+    )
+
+
+def get_user_login(
+    user_repository: Annotated[UserRepository, Depends(Stub(UserRepository))],
+    password_hasher: Annotated[PasswordHasher, Depends(Stub(PasswordHasher))],
+) -> LoginUser:
+    return LoginUser(user_repository=user_repository, password_hasher=password_hasher)

api/infrastructure/persistence/repositories/user_repository.py

@@ -2,6 +2,7 @@ from sqlalchemy import text
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from api.domain.user import User, UserRepository
+from api.domain.user.model import UserEmail, UserFirstName, UserId
 
 
 class SqlAlchemyUserRepository(UserRepository):
@@ -25,7 +26,17 @@ class SqlAlchemyUserRepository(UserRepository):
         )
 
     async def get_user(self, filter: dict) -> User | None:
-        pass
+        stmt = text("""SELECT * FROM users WHERE email = :val""")
+        result = await self.session.execute(stmt, {"val": filter["email"]})
+        if not result:
+            return None
+        result = result.mappings().one()
+        return User(
+            id=UserId(result.id),
+            name=UserFirstName(result.name),
+            email=UserEmail(result.email),
+            hashed_password=result.hashed_password,
+        )
 
     async def get_users(self) -> list[User]:
         return []