♻️ Trans exception from format JSONResponse to format HTTPException in user_managerment_app.py

Author: Phinease

backend/apps/user_management_app.py

@@ -24,15 +24,16 @@
 async def service_health():
     """Service health check"""
     try:
-        is_available = await check_auth_service_health()
+        await check_auth_service_health()
 
-        if is_available:
-            return JSONResponse(status_code=HTTPStatus.OK, content={"message": "Auth service is available"})
-        else:
-            return JSONResponse(status_code=HTTPStatus.SERVICE_UNAVAILABLE, content={"message": "Auth service is unavailable"})
+        return JSONResponse(status_code=HTTPStatus.OK,
+                            content={"message": "Auth service is available"})
+    except ConnectionError as e:
+        logging.error(f"Auth service health check failed: {str(e)}")
+        raise HTTPException(status_code=HTTPStatus.SERVICE_UNAVAILABLE, detail="Auth service is unavailable")
     except Exception as e:
         logging.error(f"Auth service health check failed: {str(e)}")
-        return HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail="Auth service is unavailable")
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail="Auth service is unavailable")
 
 
 @router.post("/signup")
@@ -50,63 +51,29 @@ async def signup(request: UserSignUpRequest):
         return JSONResponse(status_code=HTTPStatus.OK,
                             content={"message":success_message, "data":user_data})
     except NoInviteCodeException as e:
-        message = "Admin registration feature is not available, please contact the system administrator to configure the invite code"
-        data = {
-            "error_type": "INVITE_CODE_NOT_CONFIGURED",
-            "details": "The system has not configured the admin invite code, please contact technical support"
-        }
         logging.error(f"User registration failed by invite code: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": message, "data": data})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="INVITE_CODE_NOT_CONFIGURED")
     except IncorrectInviteCodeException as e:
-        message = "Admin invite code error, please check and re-enter"
-        data = {
-            "error_type": "INVITE_CODE_INVALID",
-            "field": "inviteCode",
-            "hint": "Please confirm that the invite code is entered correctly, case-sensitive"
-        }
         logging.error(f"User registration failed by invite code: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": message, "data": data})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="INVITE_CODE_INVALID")
     except UserRegistrationException as e:
-        message = "Registration service is temporarily unavailable, please try again later"
-        data = {
-            "error_type": "REGISTRATION_SERVICE_ERROR",
-            "details": "Authentication service response exception"
-        }
         logging.error(f"User registration failed by registration service: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": message, "data": data})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="REGISTRATION_SERVICE_ERROR")
     except AuthApiError as e:
-        message = f"Email {request.email} has already been registered"
-        data = {
-            "error_type": "EMAIL_ALREADY_EXISTS",
-            "field": "email",
-            "suggestion": "Please use a different email address or try logging in to an existing account"
-        }
         logging.error(f"User registration failed by email already exists: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.CONFLICT,
-                            content={"message": message, "data": data})
+        raise HTTPException(status_code=HTTPStatus.CONFLICT,
+                            detail="EMAIL_ALREADY_EXISTS")
     except AuthWeakPasswordError as e:
-        message = "Password strength is not enough, please set a stronger password"
-        data = {
-            "error_type": "WEAK_PASSWORD",
-            "field": "password",
-            "requirements": "Password must be at least 6 characters long, including letters, numbers, and special symbols"
-        }
         logging.error(f"User registration failed by weak password: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
-                            content={"message": message, "data": data})
+        raise HTTPException(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+                            detail="WEAK_PASSWORD")
     except Exception as e:
-        message = "Registration failed, please try again later"
-        data = {
-            "error_type": "UNKNOWN_ERROR",
-            "details": f"System error: {str(e)[:100]}",
-            "suggestion": "If the problem persists, please contact technical support"
-        }
         logging.error(f"User registration failed, unknown error: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": message, "data": data})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="UNKNOWN_ERROR")
 
 
 @router.post("/signin")
@@ -119,88 +86,88 @@ async def signin(request: UserSignInRequest):
                             content=signin_content)
     except AuthApiError as e:
         logging.error(f"User login failed: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
-                            content={"message": "Email or password error"})
+        raise HTTPException(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+                            detail="Email or password error")
     except Exception as e:
         logging.error(f"User login failed, unknown error: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": "Login failed"})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="Login failed")
 
 
 @router.post("/refresh_token")
 async def user_refresh_token(request: Request):
     """Refresh token"""
+    authorization = request.headers.get("Authorization")
+    if not authorization:
+        raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED,
+                            detail="No authorization token provided")
     try:
-        authorization = request.headers.get("Authorization")
-        if not authorization:
-            return JSONResponse(status_code=HTTPStatus.UNAUTHORIZED,
-                                content={"message": "No authorization token provided"})
         session_data = await request.json()
         refresh_token = session_data.get("refresh_token")
         if not refresh_token:
-            return JSONResponse(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
-                                content={"message": "No refresh token provided"})
+            raise ValueError("No refresh token provided")
         session_info = await refresh_user_token(authorization, refresh_token)
         return JSONResponse(status_code=HTTPStatus.OK,
                             content={"message":"Token refresh successful", "data":{"session": session_info}})
+    except ValueError as e:
+        logging.error(f"Refresh token failed: {str(e)}")
+        raise HTTPException(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+                            detail="No refresh token provided")
     except Exception as e:
         logging.error(f"Refresh token failed: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": "Refresh token failed"})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="Refresh token failed")
 
 
 @router.post("/logout")
 async def logout(request: Request):
     """User logout"""
+    authorization = request.headers.get("Authorization")
+    if not authorization:
+        raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED,
+                            detail="User not logged in")
     try:
-        authorization = request.headers.get("Authorization")
-        if not authorization:
-            return JSONResponse(status_code=HTTPStatus.UNAUTHORIZED,
-                                content={"message": "User not logged in"})
-
         client = get_authorized_client(authorization)
         client.auth.sign_out()
         return JSONResponse(status_code=HTTPStatus.OK,
                             content={"message":"Logout successful"})
 
     except Exception as e:
         logging.error(f"User logout failed: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": "Logout failed!"})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="Logout failed!")
 
 
 @router.get("/session")
 async def get_session(request: Request):
     """Get current user session"""
+    authorization = request.headers.get("Authorization")
+    if not authorization:
+        raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED,
+                            detail="User not logged in")
     try:
-        authorization = request.headers.get("Authorization")
-        if not authorization:
-            return JSONResponse(status_code=HTTPStatus.UNAUTHORIZED,
-                                content={"message": "No authorization token provided"})
-
         data = await get_session_by_authorization(authorization)
         return JSONResponse(status_code=HTTPStatus.OK,
                      content={"message": "Session is valid",
                               "data": data})
     except ValueError as e:
         logging.error(f"Get user session failed: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
-                            content={"message": "Session is invalid"})
+        raise HTTPException(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+                            detail="Session is invalid")
     except Exception as e:
         logging.error(f"error in get user session, {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": "Get user session failed"})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="Get user session failed")
 
 
 @router.get("/current_user_id")
 async def get_user_id(request: Request):
     """Get current user ID, return None if not logged in"""
+    authorization = request.headers.get("Authorization")
+    if not authorization:
+        raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED,
+                            detail="User not logged in")
     try:
-        authorization = request.headers.get("Authorization")
-        if not authorization:
-            return JSONResponse(status_code=HTTPStatus.UNAUTHORIZED,
-                                content={"message": "No authorization token provided"})
-
         # Use the unified token validation function
         is_valid, user = validate_token(authorization)
         if is_valid and user:
@@ -214,11 +181,13 @@ async def get_user_id(request: Request):
             return JSONResponse(status_code=HTTPStatus.OK,
                                 content={"message": "Successfully parsed user ID from token",
                                          "data": {"user_id": user_id}})
+        raise ValueError("User not logged in or session invalid")
 
-        # If all methods fail, return the session invalid information
-        return JSONResponse(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
-                            content={"message": "User not logged in or session invalid"})
+    except ValueError as e:
+        logging.error(f"Get user ID failed: {str(e)}")
+        raise HTTPException(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+                            detail="User not logged in or session invalid")     
     except Exception as e:
         logging.error(f"Get user ID failed: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": "Get user ID failed"})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="Get user ID failed")

backend/services/user_management_service.py

@@ -80,35 +80,27 @@ def extend_session(client: Client, refresh_token: str) -> Optional[dict]:
         return None
 
 
-async def check_auth_service_health() -> bool:
+async def check_auth_service_health():
     """
     Check the health status of the authentication service
     Return (is available, status message)
     """
-    try:
-        supabase_url = os.getenv("SUPABASE_URL")
-        supabase_key = os.getenv("SUPABASE_KEY")
-
-        health_url = f'{supabase_url}/auth/v1/health'
-        headers = {'apikey': supabase_key}
+    supabase_url = os.getenv("SUPABASE_URL")
+    supabase_key = os.getenv("SUPABASE_KEY")
 
-        async with aiohttp.ClientSession() as session:
-            async with session.get(health_url, headers=headers) as response:
-                if not response.ok:
-                    return False
+    health_url = f'{supabase_url}/auth/v1/health'
+    headers = {'apikey': supabase_key}
 
-                data = await response.json()
-                # Check if the service is available by checking if the response contains the name field and its value is "GoTrue"
-                is_available = data and data.get("name") == "GoTrue"
+    async with aiohttp.ClientSession() as session:
+        async with session.get(health_url, headers=headers) as response:
+            if not response.ok:
+                raise ConnectionError("Auth service is unavailable")
 
-                return is_available
-
-    except aiohttp.ClientError as e:
-        logging.error(f"Auth service connection failed: {str(e)}")
-        return False
-    except Exception as e:
-        logging.error(f"Auth service health check failed: {str(e)}")
-        return False
+            data = await response.json()
+            # Check if the service is available by verifying the name field equals "GoTrue"
+            if not data or data.get("name", "") != "GoTrue":
+                logging.error("Auth service is unavailable")
+                raise ConnectionError("Auth service is unavailable")
 
 
 async def signup_user(email: EmailStr,
@@ -287,11 +279,12 @@ async def get_session_by_authorization(authorization):
         user_role = "user"  # Default role
         if user.user_metadata and 'role' in user.user_metadata:
             user_role = user.user_metadata['role']
-        return {"user": {
-            "id": user.id,
-            "email": user.email,
-            "role": user_role
-        }
+        return {
+            "user": {
+                "id": user.id,
+                "email": user.email,
+                "role": user_role
+            }
         }
     else:
         raise ValueError("Session is invalid")

frontend/components/auth/registerModal.tsx

@@ -135,7 +135,7 @@ export function RegisterModal() {
 
       // process the specific error type returned by the backend (based on HTTP status code and error_type)
       const httpStatusCode = error?.code;
-      const errorType = error?.data?.error_type;
+      const errorType = error?.message;
 
       // HTTP 409 Conflict
       if (httpStatusCode === 409 || errorType === "EMAIL_ALREADY_EXISTS") {