Merge pull request #51 from pattern-tech/fix/routes

Fix/routes

Author: yasinfakhar

api/src/auth/routers/auth_router.py

@@ -1,90 +1,158 @@
+from pydantic import BaseModel
 from sqlalchemy.orm import Session
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, HTTPException, status
+
 from src.auth.utils.bcrypt_helper import generate_access_token
 from src.auth.services.auth_service import (
     AuthService,
     LoginInput,
     RegisterInput,
     VerifyInput
 )
-
+from src.util.execptions import *
 from src.db.sql_alchemy import Database
-from src.util.response import global_response
+from src.util.response import global_response, GlobalResponse, ExceptionResponse
 
 router = APIRouter(prefix="/auth")
 database = Database()
 
 auth = AuthService()
 
+# Create a module-level dependency
+get_db_dependency = Depends(database.get_db)
+
+
+class AuthOutput(BaseModel):
+    access_token: str
+
 
 @router.post(
     "/register",
+    response_model=GlobalResponse[AuthOutput, dict],
     summary="User Registration",
     description="Register a new user with email and password.",
-    deprecated=True
+    deprecated=True,
+    responses={
+        409: {
+            "model": ExceptionResponse,
+            "description": "User or Email already exists"
+        },
+        400: {
+            "model": ExceptionResponse,
+            "description": "Bad request"
+        },
+    }
 )
-def register(input: RegisterInput, db: Session = Depends(database.get_db)):
+def register(input: RegisterInput, db: Session = get_db_dependency):
     """
     Register a new user.
 
     - **email**: User's email address
     - **password**: User's password
     """
-    user = auth.register(input, db)
-
-    payload = {"id": str(user.id)}
-    token = generate_access_token(data=payload)
-    return global_response(
-        {
-            "access_token": token,
-        }
-    )
+    try:
+        user = auth.register(input, db)
+
+        payload = {"id": str(user.id)}
+        token = generate_access_token(data=payload)
+        return global_response(
+            {
+                "access_token": token,
+            }
+        )
+    except AlreadyExistsError as e:
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT, detail=str(e))
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
 
 
 @router.post(
     "/login",
+    response_model=GlobalResponse[AuthOutput, dict],
     summary="User Login",
     description="Authenticate a user with email and password.",
     deprecated=True,
+    responses={
+        404: {
+            "model": ExceptionResponse,
+            "description": "User not found"
+        },
+        401: {
+            "model": ExceptionResponse,
+            "description": "Incorrect password"
+        },
+        400: {
+            "model": ExceptionResponse,
+            "description": "Bad request"
+        },
+    }
 )
-def login(input: LoginInput, db: Session = Depends(database.get_db)):
+def login(input: LoginInput, db: Session = get_db_dependency):
     """
     Login a user and return an access token.
 
     - **email**: User's email address
     - **password**: User's password
     """
-    user = auth.authenticate_user(input.email.lower(), input.password, db)
-
-    payload = {"id": str(user.id)}
-    token = generate_access_token(data=payload)
-    return global_response(
-        {
-            "access_token": token,
-        }
-    )
+    try:
+        user = auth.authenticate_user(input.email.lower(), input.password, db)
+
+        payload = {"id": str(user.id)}
+        token = generate_access_token(data=payload)
+        return global_response(
+            {
+                "access_token": token,
+            }
+        )
+    except NotFoundError as e:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=str(e))
+    except InvalidPasswordError:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Incorrect password")
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
 
 
 @router.post(
     "/verify",
+    response_model=GlobalResponse[AuthOutput, dict],
     summary="Verify a Signature",
     description="Verify a signature according to SIWE spec",
+    responses={
+        400: {
+            "model": ExceptionResponse,
+            "description": "Bad request including invalid message or signature"
+        },
+    }
 )
-def verify(input: VerifyInput, db: Session = Depends(database.get_db)):
+def verify(input: VerifyInput, db: Session = get_db_dependency):
     """
     Verify a signature according to SIWE spec and return an access token
 
     - **message**: A SIWE message
     - **signature**: User's signature for the message
     """
-
-    user = auth.verify_signature(
-        input.message, input.signature, db)
-
-    payload = {"id": str(user.id)}
-    token = generate_access_token(data=payload)
-    return global_response(
-        {
-            "access_token": token,
-        }
-    )
+    try:
+        user = auth.verify_signature(
+            input.message, input.signature, db)
+
+        payload = {"id": str(user.id)}
+        token = generate_access_token(data=payload)
+        return global_response(
+            {
+                "access_token": token,
+            }
+        )
+    except InvalidMessageError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+    except InvalidSignatureError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))

api/src/auth/services/auth_service.py

@@ -4,6 +4,7 @@
 from sqlalchemy.orm import Session
 from pydantic import BaseModel, Field, EmailStr
 
+from src.util.execptions import *
 from src.db.models import UserModel
 from src.db.sql_alchemy import Database
 from src.share.base_types import WalletAddress
@@ -80,15 +81,14 @@ def register(self, input: RegisterInput, db: Session) -> str:
         existing_user = db.query(UserModel).filter_by(
             wallet_address=input.wallet_address).first()
         if existing_user:
-            raise HTTPException(status_code=400, detail="User already exists")
+            raise AlreadyExistsError("User already exists")
 
         # # Create a new user record
         if input.email and input.password:
             existing_user = db.query(UserModel).filter_by(
                 email=input.email.lower()).first()
             if existing_user:
-                raise HTTPException(
-                    status_code=400, detail="This email is already exists")
+                raise AlreadyExistsError("This email is already exists")
 
         if input.password:
             input.password = hash_password(input.password)
@@ -117,13 +117,11 @@ def authenticate_user(self, email: str, password: str, db: Session):
         user = db.query(UserModel).filter_by(email=email).first()
 
         if not user:
-            raise HTTPException(
-                status_code=401, detail="Incorrect email or password")
+            raise NotFoundError("User not found with this email")
 
         # Verify the provided password matches the stored hash
         if not verify_password(password, user.password):
-            raise HTTPException(
-                status_code=401, detail="Incorrect email or password")
+            raise InvalidPasswordError("Incorrect email or password")
 
         return user
 
@@ -146,11 +144,10 @@ def verify_signature(self, message: str, signature: str, db: Session):
             siwe_message.verify(signature)
         except ValueError:
             # ValueError is raised if message is invalid according to SIWE
-            raise HTTPException(
-                status_code=400, detail="The provided message is not a valid SIWE message")
+            raise InvalidMessageError(
+                "The provided message is not a valid SIWE message")
         except:
-            raise HTTPException(
-                status_code=401, detail="Signature is not valid")
+            raise InvalidSignatureError("Signature is not valid")
 
         # check if not exist create new user
         user = self.user_service.get_user_by_wallet_address(

api/src/auth/utils/bcrypt_helper.py

@@ -1,9 +1,10 @@
+import os
 import bcrypt
-from fastapi import HTTPException
+
 from jose import JWTError, jwt
-from passlib.context import CryptContext
-import os
 from dotenv import load_dotenv
+from passlib.context import CryptContext
+from src.util.execptions import JWTDecodeError
 
 load_dotenv()
 
@@ -74,4 +75,4 @@ def decode_access_token(token: str) -> dict:
         else:
             raise JWTError("Required fields not found in token")
     except JWTError:
-        raise HTTPException(status_code=401, detail="Invalid or expired token")
+        raise JWTDecodeError("Invalid or expired token")

api/src/auth/utils/get_token.py

@@ -1,8 +1,10 @@
-from fastapi import Depends, HTTPException, Request
-from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from src.util.execptions import JWTDecodeError
+from fastapi import Depends, HTTPException, Request, status
 from src.auth.utils.bcrypt_helper import decode_access_token
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 
 security = HTTPBearer()
+get_credentials = Depends(security)
 
 
 def get_jwt_token(request: Request):
@@ -30,26 +32,33 @@ def get_jwt_token(request: Request):
 
 
 def authenticate_user(
-    request: Request, authorization: HTTPAuthorizationCredentials = Depends(security)
+    request: Request,
+    authorization: HTTPAuthorizationCredentials = get_credentials
 ):
     """
     Authenticate the user by decoding the JWT token and extracting the user ID.
 
     Parameters:
         request (Request): The incoming HTTP request object.
-        authorization (HTTPAuthorizationCredentials): The bearer token credentials,
-                                                      automatically provided by FastAPI dependency injection.
+        authorization (HTTPAuthorizationCredentials): The bearer token
+        credentials, automatically provided by FastAPI dependency injection.
 
     Returns:
         str: The user ID extracted from the decoded JWT token.
 
     Raises:
-        HTTPException: If the token is missing or invalid.
+        HTTPException: If the token is missing, invalid, or malformed.
     """
     token: str = ""
     if authorization:
         token = authorization.credentials
     else:
         token = get_jwt_token(request)
-    decode_token = decode_access_token(token)
-    return decode_token["user_id"]
+    try:
+        decode_token = decode_access_token(token)
+        return decode_token["user_id"]
+    except JWTDecodeError as e:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED,detail=str(e))
+    except Exception as e:
+        # Handle any other unexpected errors with a 400 Bad Request
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))

api/src/conversation/repositories/conversation_repository.py

@@ -3,9 +3,9 @@
 from sqlalchemy.orm import Session
 
 from src.db.models import Conversation
+from src.util.execptions import NotFoundError
 from src.share.base_repository import BaseRepository
 
-
 class ConversationRepository(BaseRepository[Conversation]):
     """
     Repository class for handling CRUD operations on the Conversation model.
@@ -76,7 +76,7 @@ def update(self, db_session: Session, id: UUID, conversation_data: dict, user_id
         """
         conversation = self.get_by_id(db_session, id, user_id)
         if not conversation:
-            raise Exception("Conversation not found")
+            raise NotFoundError("Conversation not found")
         for key, value in conversation_data.items():
             setattr(conversation, key, value)
         db_session.commit()
@@ -97,7 +97,7 @@ def delete(self, db_session: Session, id: UUID, user_id: UUID) -> None:
         """
         conversation = self.get_by_id(db_session, id, user_id)
         if not conversation:
-            raise Exception("Conversation not found")
+            raise NotFoundError("Conversation not found")
 
         db_session.delete(conversation)
         db_session.commit()