refactor user model and schemas to consolidate name fields and remove signup schema

src/controllers/__init__.py

@@ -19,13 +19,11 @@ api_router.include_router(
     auth_router,
     prefix="/v1",
     tags=["Authentication"],
-    dependencies=[Depends(API_KEY_HEADER)],
 )
 api_router.include_router(
     conversation_api_router,
     prefix="/v1",
     tags=["Conversation"],
-    dependencies=[Depends(API_KEY_HEADER)],
 )
 websocket_router.include_router(
     conversation_websocket_router,
@@ -36,7 +34,6 @@ api_router.include_router(
     file_router,
     prefix="/v1",
     tags=["Semantic Search"],
-    dependencies=[Depends(API_KEY_HEADER)],
 )
 
 __all__ = ["api_router", "websocket_router"]

src/controllers/_auth_controller.py

@@ -1,11 +1,6 @@
 from fastapi import APIRouter, HTTPException, status, Request
 from src.services import AuthService
-from src.schemas import (
-    UserSignInSchema,
-    UserSignInResponse,
-    UserSignUpSchema,
-    UserSignUpResponse,
-)
+from src.schemas import UserSignInSchema, UserSignInResponse
 from src.config import logger
 
 
@@ -13,59 +8,19 @@ class AuthController:
     def __init__(self):
         self._auth_service = AuthService()
         self.api_router = APIRouter(prefix="/auth", tags=["Authentication"])
-        self.api_router.add_api_route(
-            methods=["POST"],
-            path="/register",
-            endpoint=self._signup,
-            response_model=UserSignUpResponse,
-        )
         self.api_router.add_api_route(
             methods=["POST"],
             path="/login",
             endpoint=self._signin,
             response_model=UserSignInResponse,
         )
-        self.api_router.add_api_route(
-            methods=["POST"],
-            path="/logout",
-            endpoint=self._signout,
-        )
-
-    async def _signup(self, user_create: UserSignUpSchema):
-        try:
-            user = await self._auth_service.sign_up(user_create)
-            return UserSignUpResponse(user_id=str(user.id))
-        except HTTPException as e:
-            raise
-        except Exception as e:
-            logger.error(f"Error during signup: {e}")
-            raise HTTPException(status_code=500, detail="Error during signup")
-
-    async def _signin(
-        self,
-        form_data: UserSignInSchema,
-        request: Request,
-    ):
-        try:
-            client_ip = request.client.host
-            token = await self._auth_service.sign_in(form_data, client_ip)
-            return UserSignInResponse(token=token)
-        except HTTPException as e:
-            raise
-        except Exception as e:
-            logger.error(f"Error during signin: {e}")
-            raise HTTPException(status_code=500, detail="Error during signin")
 
-    async def _signout(
-        self,
-        request: Request,
-    ):
+    async def _signin(self, user: UserSignInSchema):
         try:
-            token = request.headers.get("Authorization").split(" ")[1]
-            await self._auth_service.sign_out(token)
-            return status.HTTP_200_OK
+            user = await self._auth_service.sign_in(user)
+            return UserSignInResponse(user_id=str(user.user_id))
         except HTTPException as e:
             raise
         except Exception as e:
-            logger.error(f"Error during signout: {e}")
-            raise HTTPException(status_code=500, detail="Error during signout")
+            logger.error(f"Error during implicit signin: {e}")
+            raise HTTPException(status_code=500, detail="Error during implicit signin")

src/controllers/_conversation_controller.py

@@ -3,7 +3,6 @@ from fastapi import (
     APIRouter,
     HTTPException,
     WebSocket,
-    Request,
     WebSocketDisconnect,
 )
 from typing import List
@@ -28,21 +27,16 @@ class ConnectionManager:
 
     async def connect(self, websocket: WebSocket, redis_client):
         await websocket.accept()
-        token = websocket.query_params.get("token")
         conversation_id = websocket.query_params.get("conversation_id")
-        user = self.jwt.validate_jwt(token)
-
-        if not user:
-            await websocket.close(code=1008, reason="Invalid token")
-            return None
+        user_id = websocket.query_params.get("user_id")
 
         self.active_connections.append(websocket)
         await self._update_redis_status(
-            unique_id=f"{user["user_id"]}{conversation_id}",
+            unique_id=f"{user_id}{conversation_id}",
             redis_client=redis_client,
             status="active",
         )
-        return user
+        return user_id
 
     async def disconnect(
         self, websocket: WebSocket, redis_client, user_id: str, conversation_id: str
@@ -95,14 +89,11 @@ class ConversationController:
         )
         self.websocket_router.add_websocket_route("/conversations", self.conversation)
 
-    async def create_conversation(
-        self, request: Request, data: CreateConversationSchema
-    ):
+    async def create_conversation(self, data: CreateConversationSchema):
         try:
-            user_id = request.state.user["user_id"]
             async with self.service() as service:
                 return await service.create_conversation(
-                    user_id=user_id, modality=data.modality
+                    user_id=data.user_id, modality=data.modality
                 )
         except HTTPException as e:
             raise
@@ -113,14 +104,12 @@ class ConversationController:
 
     async def create_webrtc_connection(
         self,
-        request: Request,
         data: CreateWebrtcConnectionSchema,
     ):
         try:
-            user_id = request.state.user["user_id"]
             async with self.service() as service:
                 return await service.create_webrtc_connection(
-                    user_id=user_id,
+                    user_id=data.user_id,
                     conversation_id=data.conversation_id,
                     offer=data.offer.model_dump(),
                 )
@@ -134,12 +123,11 @@ class ConversationController:
             )
 
     async def conversation(self, websocket: WebSocket):
-        user = await self.websocket_connection_manager.connect(
+        user_id = await self.websocket_connection_manager.connect(
             websocket=websocket, redis_client=self.redis_client
         )
-        if not user:
+        if not user_id:
             return
-        user_id = user["user_id"]
         conversation_id = websocket.query_params.get("conversation_id")
         modality = websocket.query_params.get("modality")
         try:
@@ -172,14 +160,11 @@ class ConversationController:
                 conversation_id=conversation_id,
             )
 
-    async def create_conversation_summary(
-        self, request: Request, data: CreateConversationSummarySchema
-    ):
+    async def create_conversation_summary(self, data: CreateConversationSummarySchema):
         try:
-            user_id = request.state.user["user_id"]
             async with self.service() as service:
                 return await service.create_conversation_summary(
-                    user_id=user_id, conversation_id=data.conversation_id
+                    user_id=data.user_id, conversation_id=data.conversation_id
                 )
 
         except HTTPException as e:

src/models/_users.py

@@ -6,9 +6,7 @@ from beanie import Document, Indexed
 
 
 class User(Document):
-    first_name: str
-    last_name: str
-    hashed_password: str
+    name: str
     email: Annotated[str, Indexed(unique=True)]
     created_at: datetime = Field(default_factory=datetime.now)
     updated_at: datetime = Field(default_factory=datetime.now)

src/schemas/__init__.py

@@ -1,9 +1,7 @@
 from ._sessions import SessionCreateSchema
 from ._users import (
     UserSignInSchema,
-    UserSignUpSchema,
     UserSignInResponse,
-    UserSignUpResponse,
 )
 from ._conversations import (
     OfferSchema,
@@ -21,9 +19,7 @@ from ._files import InsertFileSchema
 __all__ = [
     "OfferSchema",
     "UserSignInSchema",
-    "UserSignUpSchema",
     "UserSignInResponse",
-    "UserSignUpResponse",
     "SessionCreateSchema",
     "CreateConversationSchema",
     "CreateConversationSummarySchema",

src/schemas/_conversations.py

@@ -8,15 +8,18 @@ class OfferSchema(BaseModel):
 
 
 class CreateConversationSchema(BaseModel):
+    user_id: str = Query(...)
     modality: str = Query(..., regex="^(text|voice)$")
 
 
 class CreateWebrtcConnectionSchema(BaseModel):
+    user_id: str = Query(...)
     conversation_id: str = Path(...)
     offer: OfferSchema = Body(...)
 
 
 class CreateConversationSummarySchema(BaseModel):
+    user_id: str = Query(...)
     conversation_id: str = Path(...)
 
 

src/schemas/_users.py

@@ -20,21 +20,10 @@ class Validators:
         return password
 
 
-class UserSignUpSchema(BaseModel):
-    first_name: str
-    last_name: str
-    email: Annotated[str, AfterValidator(Validators.validate_email)]
-    password: Annotated[str, AfterValidator(Validators.validate_password)]
-
-
 class UserSignInSchema(BaseModel):
+    name: str
     email: Annotated[str, AfterValidator(Validators.validate_email)]
-    password: Annotated[str, AfterValidator(Validators.validate_password)]
 
 
 class UserSignInResponse(BaseModel):
-    token: str
-
-
-class UserSignUpResponse(BaseModel):
     user_id: str

src/services/_auth_service.py

@@ -2,7 +2,10 @@ from fastapi import HTTPException
 from datetime import datetime, timedelta
 
 from src.utils import JWTUtil, BcryptUtil
-from src.schemas import UserSignInSchema, UserSignUpSchema, SessionCreateSchema
+from src.schemas import (
+    UserSignInSchema,
+    SessionCreateSchema,
+)
 
 from ._user_service import UserService
 from ._session_service import SessionService
@@ -14,14 +17,21 @@ class AuthService:
         self._user_service = UserService()
         self._session_service = SessionService()
 
-    async def sign_up(self, user: UserSignUpSchema):
+    async def sign_in(self, user: UserSignInSchema):
         existing_user = await self._user_service.list_users(
             filter_by={"email": user.email}
         )
-        if existing_user:
-            raise HTTPException(409, "User already exists")
+        if not existing_user:
+            user_object = await self._user_service.create_user(
+                UserSignInSchema(name=user.name, email=user.email)
+            )
+            return {
+                "user_id": str(user_object.id),
+            }
 
-        return await self._user_service.create_user(user)
+        return {
+            "user_id": str(existing_user[0].id),
+        }
 
     async def sign_in(self, user: UserSignInSchema, device_ipv4_address: str):
         existing_user = await self._user_service.list_users(

src/services/_meeting_service.py

@@ -105,8 +105,7 @@ class MeetingService:
         locale: str = "en-us",
     ):
         user_object: User = await self.user_repository.get_by_id(user_id)
-        user_first_name = user_object.first_name
-        user_last_name = user_object.last_name
+        user_name = user_object.name
         user_email = user_object.email
 
         pytz_timezone = pytz.timezone(timezone)
@@ -133,8 +132,7 @@ class MeetingService:
         }
         data = {
             "slug": salesperson_meeting_id,
-            "firstName": user_first_name,
-            "lastName": user_last_name,
+            "firstName": user_name,
             "email": user_email,
             "startTime": preferred_start_time,
             "duration": duration_ms,

src/services/_user_service.py

@@ -2,7 +2,7 @@ from typing import Dict
 
 from src.models import User
 from src.utils import BcryptUtil
-from src.schemas import UserSignUpSchema
+from src.schemas import UserSignInSchema
 from src.repositories import UserRepository
 
 
@@ -10,16 +10,8 @@ class UserService:
     def __init__(self):
         self.user_repository = UserRepository()
 
-    async def create_user(self, user: UserSignUpSchema):
-        hashed_password = BcryptUtil.hash_password(user.password)
-
-        user = User(
-            first_name=user.first_name,
-            last_name=user.last_name,
-            email=user.email,
-            hashed_password=hashed_password,
-        )
-
+    async def create_user(self, user: UserSignInSchema):
+        user = User(name=user.name, email=user.email)
         return await self.user_repository.insert_one(user)
 
     async def get_user(self, user_id):