Update services/auth.py

services/auth.py

@@ -1,9 +1,12 @@
+# services/auth.py
+
 from passlib.context import CryptContext
 from sqlmodel import Session, select
 from typing import Optional
 
+# Import User directly to avoid potential circularity with models.__init__ if not careful
 from models.user import User, UserCreate
-from models.db import get_session_context # Using context manager for direct use
+from models.db import get_session_context
 from services.logger import app_logger
 
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
@@ -19,28 +22,78 @@ def get_user(db: Session, username: str) -> Optional[User]:
     user = db.exec(statement).first()
     return user
 
-# In services/auth.py
 def create_user_in_db(user_data: UserCreate) -> Optional[User]:
     hashed_password = get_password_hash(user_data.password)
+    
+    # Create the Python object
     db_user = User(
         username=user_data.username,
         hashed_password=hashed_password,
         email=user_data.email,
-        full_name=user_data.full_name
-        # The 'chat_sessions' attribute is an empty list by default here, not yet loaded from DB
+        full_name=user_data.full_name,
+        chat_sessions=[] # Initialize relationships if they are expected to be non-None
     )
+    
+    created_user_id: Optional[int] = None
+
     try:
-        with get_session_context() as db: # Session starts here
-            existing_user = get_user(db, user_data.username)
-            if existing_user:
+        with get_session_context() as db:
+            # Check if user already exists
+            existing_user_check = db.exec(select(User).where(User.username == user_data.username)).first()
+            if existing_user_check:
                 app_logger.warning(f"User {user_data.username} already exists.")
                 return None
             
             db.add(db_user)
-            # db.commit() # Commit is handled by context manager
-            db.refresh(db_user) # This makes sure all attributes are up-to-date from DB *within this session*
-        # Session closes here. db_user is now "detached".
-        return db_user # Returning the detached db_user object
+            db.commit()  # Commit to save the user and generate ID
+            db.refresh(db_user) # Refresh to get all attributes, especially ID
+            created_user_id = db_user.id # Store the ID
+            
+            # Explicitly load the username to be safe, though it should be loaded.
+            # This is more of a "just in case" step.
+            _ = db_user.username 
+            _ = db_user.email # if you plan to use it immediately after
+            
+        # After session closes, db_user is detached.
+        # If we need to return the full User object, and it might be used in a way
+        # that requires re-attaching or accessing lazy-loaded fields, this can be an issue.
+        # For simple display like username, it should be fine.
+        # The error suggests something is trying to "refresh" it.
+
+        # To be absolutely safe for the immediate use case (displaying username),
+        # we can fetch a "clean" version of the user by ID in a new, short-lived session,
+        # though this is usually overkill for just displaying a username.
+        # This ensures the returned object is "fresh" but also detached.
+        if created_user_id is not None:
+            with get_session_context() as db:
+                # Re-fetch the user to ensure it's a clean, detached object
+                # with its basic attributes loaded.
+                user_to_return = db.get(User, created_user_id)
+                if user_to_return:
+                    # Access attributes needed immediately to ensure they are loaded
+                    # before the session closes again.
+                    _ = user_to_return.username
+                    _ = user_to_return.email
+                    return user_to_return # This user object is now detached.
+        return None # Should not happen if creation was successful
+
     except Exception as e:
         app_logger.error(f"Error creating user {user_data.username}: {e}")
-        return None
+        return None
+
+def authenticate_user(username: str, password: str) -> Optional[User]:
+    with get_session_context() as db:
+        user = get_user(db, username)
+        if not user:
+            return None
+        if not verify_password(password, user.hashed_password):
+            return None
+        # Before returning, ensure any attributes needed by the caller are loaded
+        # if they might be lazy-loaded and the user object will be used after this session.
+        # For st.session_state.authenticated_user, this is important.
+        _ = user.id
+        _ = user.username
+        _ = user.email # etc.
+        # For relationships, you might need to configure eager loading (e.g. selectinload)
+        # or accept that they will be lazy-loaded (requiring a session) or not accessible.
+        return user