Upload 12 files

app/api/routes/auth_router.py

@@ -138,7 +138,7 @@ async def get_current_user(request: Request, token: str = Depends(oauth2_scheme)
 
 # Routes
 @router.post("/register", response_model=UserResponse)
-async def register(request: Request, user: UserCreate):
+async def register(user: UserCreate):
     # Generate a unique identifier for this registration attempt
     registration_id = f"reg_{int(time.time())}"
     logger.info(f"[{registration_id}] Starting registration for email: {user.email}")
@@ -259,44 +259,66 @@ async def register(request: Request, user: UserCreate):
         # Step 4: Retrieve the full user record
         logger.info(f"[{registration_id}] Retrieving user record")
 
-        new_user = db_http.get_record_by_id("users", user_id, operation_id=registration_id)
+        # Create a default user object with what we know
+        default_user = {
+            "id": user_id or 0,
+            "email": user.email,
+            "is_admin": False,
+            "created_at": datetime.now().isoformat()
+        }
 
-        if not new_user:
+        # Try to get the full user record
+        try:
+            if user_id:
+                new_user = db_http.get_record_by_id("users", user_id, operation_id=registration_id)
+
+                if new_user:
+                    logger.info(f"[{registration_id}] Found user by ID: {user_id}")
+                    return {
+                        "id": new_user.get("id", user_id),
+                        "email": new_user.get("email", user.email),
+                        "is_admin": bool(new_user.get("is_admin", 0)),
+                        "created_at": str(new_user.get("created_at", datetime.now().isoformat()))
+                    }
+
+            # If we couldn't get by ID or user_id is None, try by email
             logger.warning(f"[{registration_id}] User not found after insert, trying by email")
 
-            # Try to get by email as fallback
-            users = db_http.select_records(
-                "users",
-                condition="email = ?",
-                condition_params=[{"type": "text", "value": user.email}],
-                limit=1,
-                operation_id=registration_id
-            )
+            try:
+                # Try to get by email as fallback
+                users = db_http.select_records(
+                    "users",
+                    condition="email = ?",
+                    condition_params=[{"type": "text", "value": user.email}],
+                    limit=1,
+                    operation_id=f"{registration_id}_email_lookup"
+                )
 
-            if users:
-                new_user = users[0]
-                user_id = new_user.get("id")
-                logger.info(f"[{registration_id}] Found user by email with ID: {user_id}")
-            else:
-                logger.error(f"[{registration_id}] User not found by email either")
+                if users and len(users) > 0:
+                    new_user = users[0]
+                    user_id = new_user.get("id")
+                    logger.info(f"[{registration_id}] Found user by email with ID: {user_id}")
+                    return {
+                        "id": new_user.get("id", user_id or 0),
+                        "email": new_user.get("email", user.email),
+                        "is_admin": bool(new_user.get("is_admin", 0)),
+                        "created_at": str(new_user.get("created_at", datetime.now().isoformat()))
+                    }
+                else:
+                    logger.warning(f"[{registration_id}] User not found by email either")
+            except Exception as e:
+                logger.error(f"[{registration_id}] Error finding user by email: {str(e)}")
+
+            # If all else fails, return the default user object
+            logger.info(f"[{registration_id}] Returning default user object")
+            return default_user
 
-                # Return minimal response with what we know
-                return {
-                    "id": user_id or 0,
-                    "email": user.email,
-                    "is_admin": False,
-                    "created_at": datetime.now().isoformat()
-                }
+        except Exception as e:
+            logger.error(f"[{registration_id}] Error retrieving user record: {str(e)}")
+            # Return minimal response with what we know
+            return default_user
 
-        # Step 5: Construct the response
-        logger.info(f"[{registration_id}] Registration successful for user ID: {user_id}")
 
-        return {
-            "id": new_user.get("id", user_id),
-            "email": new_user.get("email", user.email),
-            "is_admin": bool(new_user.get("is_admin", 0)),
-            "created_at": str(new_user.get("created_at", datetime.now().isoformat()))
-        }
 
     except Exception as e:
         logger.error(f"[{registration_id}] Registration failed: {str(e)}")

app/utils/db_http.py

@@ -178,16 +178,34 @@ def insert_record(table: str, data: Dict[str, Any], operation_id: str = None) ->
                 return None
 
         # Try to get the last inserted ID with a separate query
-        id_result = execute_query("SELECT last_insert_rowid()", operation_id=f"{operation_id}_get_id")
-
-        last_id = None
-        if "results" in id_result and len(id_result["results"]) > 0:
-            if id_result["results"][0]["type"] == "ok":
-                rows = id_result["results"][0]["response"]["result"]["rows"]
-                if rows and len(rows) > 0:
-                    last_id = int(rows[0][0]["value"])
-                    logger.info(f"[{operation_id}] Record inserted with ID: {last_id}")
-                    return last_id
+        try:
+            id_result = execute_query("SELECT last_insert_rowid()", operation_id=f"{operation_id}_get_id")
+
+            last_id = None
+            if "results" in id_result and len(id_result["results"]) > 0:
+                if id_result["results"][0]["type"] == "ok":
+                    response = id_result["results"][0]["response"]
+                    if "result" in response and "rows" in response["result"] and len(response["result"]["rows"]) > 0:
+                        row = response["result"]["rows"][0]
+
+                        # Get the value safely
+                        if len(row) > 0:
+                            cell = row[0]
+                            if isinstance(cell, dict) and "value" in cell:
+                                try:
+                                    last_id = int(cell["value"])
+                                    logger.info(f"[{operation_id}] Record inserted with ID: {last_id}")
+                                    return last_id
+                                except (ValueError, TypeError) as e:
+                                    logger.warning(f"[{operation_id}] Error converting ID to integer: {str(e)}")
+                                    # Try to return the value as is
+                                    return cell["value"]
+                            else:
+                                logger.warning(f"[{operation_id}] Unexpected cell format: {cell}")
+                        else:
+                            logger.warning(f"[{operation_id}] Empty row in last_insert_rowid result")
+        except Exception as e:
+            logger.error(f"[{operation_id}] Error getting last insert ID: {str(e)}")
 
         # If we can't get the ID, try to find it by other means
         logger.warning(f"[{operation_id}] Insert succeeded but couldn't get ID")
@@ -357,23 +375,37 @@ def select_records(table: str, columns: List[str] = None, condition: str = None,
                 for row in rows:
                     record = {}
                     for i, col in enumerate(cols):
-                        col_name = col["name"]
-                        value = row[i]["value"]
-
-                        # Convert value based on type
                         try:
-                            if row[i]["type"] == "integer":
-                                value = int(value)
-                            elif row[i]["type"] == "float":
-                                value = float(value)
-                            elif row[i]["type"] == "null":
+                            # Get column name safely
+                            col_name = col.get("name", f"column_{i}")
+
+                            # Get cell data safely
+                            cell = row[i] if i < len(row) else {}
+
+                            # Get value and type safely
+                            value = cell.get("value") if isinstance(cell, dict) else cell
+                            cell_type = cell.get("type") if isinstance(cell, dict) else None
+
+                            # Convert value based on type
+                            if cell_type == "integer" and value is not None:
+                                try:
+                                    value = int(value)
+                                except (ValueError, TypeError):
+                                    value = 0
+                            elif cell_type == "float" and value is not None:
+                                try:
+                                    value = float(value)
+                                except (ValueError, TypeError):
+                                    value = 0.0
+                            elif cell_type == "null":
                                 value = None
 
+                            # Store the value
                             record[col_name] = value
-                        except (KeyError, TypeError, ValueError) as e:
-                            # Handle missing or invalid values
-                            logger.warning(f"Error converting value for column {col_name}: {str(e)}")
-                            record[col_name] = None
+                        except Exception as e:
+                            # Handle any errors
+                            logger.warning(f"[{operation_id}] Error processing column {i}: {str(e)}")
+                            record[f"column_{i}"] = None
 
                     records.append(record)
 
@@ -434,21 +466,36 @@ def get_record_by_id(table: str, id: int, columns: List[str] = None, operation_i
                     record = {}
                     for i, col in enumerate(cols):
                         try:
-                            col_name = col["name"]
-                            value = row[i]["value"]
+                            # Get column name safely
+                            col_name = col.get("name", f"column_{i}")
+
+                            # Get cell data safely
+                            cell = row[i] if i < len(row) else {}
+
+                            # Get value and type safely
+                            value = cell.get("value") if isinstance(cell, dict) else cell
+                            cell_type = cell.get("type") if isinstance(cell, dict) else None
 
                             # Convert value based on type
-                            if row[i]["type"] == "integer":
-                                value = int(value)
-                            elif row[i]["type"] == "float":
-                                value = float(value)
-                            elif row[i]["type"] == "null":
+                            if cell_type == "integer" and value is not None:
+                                try:
+                                    value = int(value)
+                                except (ValueError, TypeError):
+                                    value = 0
+                            elif cell_type == "float" and value is not None:
+                                try:
+                                    value = float(value)
+                                except (ValueError, TypeError):
+                                    value = 0.0
+                            elif cell_type == "null":
                                 value = None
 
+                            # Store the value
                             record[col_name] = value
-                        except (KeyError, TypeError, ValueError) as e:
-                            logger.warning(f"[{operation_id}] Error converting value for column {col['name'] if 'name' in col else i}: {str(e)}")
-                            continue
+                        except Exception as e:
+                            # Handle any errors
+                            logger.warning(f"[{operation_id}] Error processing column {i}: {str(e)}")
+                            record[f"column_{i}"] = None
 
                     logger.info(f"[{operation_id}] Found record by ID {id} using fallback: {record}")
                     return record
@@ -496,9 +543,29 @@ def count_records(table: str, condition: str = None, condition_params: List[Dict
             # Extract the count
             response = result["results"][0]["response"]
             if "result" in response and "rows" in response["result"] and response["result"]["rows"]:
-                count = int(response["result"]["rows"][0][0]["value"])
-                logger.info(f"[{operation_id}] Counted {count} records")
-                return count
+                try:
+                    row = response["result"]["rows"][0]
+
+                    # Get the value safely
+                    if len(row) > 0:
+                        cell = row[0]
+                        if isinstance(cell, dict) and "value" in cell:
+                            try:
+                                count = int(cell["value"])
+                                logger.info(f"[{operation_id}] Counted {count} records")
+                                return count
+                            except (ValueError, TypeError) as e:
+                                logger.warning(f"[{operation_id}] Error converting count to integer: {str(e)}")
+                                return 0
+                        else:
+                            logger.warning(f"[{operation_id}] Unexpected cell format in count: {cell}")
+                            return 0
+                    else:
+                        logger.warning(f"[{operation_id}] Empty row in count result")
+                        return 0
+                except Exception as e:
+                    logger.error(f"[{operation_id}] Error extracting count: {str(e)}")
+                    return 0
 
         logger.warning(f"[{operation_id}] Count failed")
         return 0

main.py

@@ -202,253 +202,99 @@ async def startup_db_client():
             hashed_password = pwd_context.hash(super_user_password)
             logger.info(f"[{operation_id}] Password hashed successfully")
 
-            # Extract the database URL and auth token
-            db_url = os.getenv("TURSO_DATABASE_URL", "")
-            auth_token = os.getenv("TURSO_AUTH_TOKEN", "")
-
-            # Convert URL from libsql:// to https://
-            if db_url.startswith("libsql://"):
-                http_url = db_url.replace("libsql://", "https://")
-            else:
-                http_url = db_url
-
-            # Ensure the URL doesn't have a trailing slash
-            http_url = http_url.rstrip('/')
-
-            # Set up headers for the HTTP request
-            headers = {
-                "Authorization": f"Bearer {auth_token}",
-                "Content-Type": "application/json"
-            }
-
-            logger.info(f"[{operation_id}] Using HTTP URL: {http_url}")
+            # First, make sure the users table exists
+            logger.info(f"[{operation_id}] Creating users table if it doesn't exist")
+            db_http.create_table_if_not_exists(
+                "users",
+                """
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                email TEXT NOT NULL UNIQUE,
+                hashed_password TEXT NOT NULL,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                last_login DATETIME,
+                is_admin INTEGER DEFAULT 0
+                """,
+                operation_id=f"{operation_id}_create_table"
+            )
 
-            # First, check if the user already exists
+            # Check if the super user already exists
             logger.info(f"[{operation_id}] Checking if super user already exists")
+            users = db_http.select_records(
+                "users",
+                condition="email = ?",
+                condition_params=[{"type": "text", "value": super_user_email}],
+                limit=1,
+                operation_id=f"{operation_id}_check"
+            )
 
-            check_query = {
-                "requests": [
-                    {
-                        "type": "execute",
-                        "stmt": {
-                            "sql": "SELECT COUNT(*) FROM users WHERE email = ?",
-                            "args": [
-                                {"type": "text", "value": super_user_email}
-                            ]
-                        }
-                    },
-                    {"type": "close"}
-                ]
-            }
-
-            # Send the request to check if user exists
-            check_response = requests.post(f"{http_url}/v2/pipeline", headers=headers, json=check_query)
-            check_response.raise_for_status()
-            check_result = check_response.json()
-
-            logger.info(f"[{operation_id}] Check response: {check_result}")
-
-            # Parse the result to see if user exists
-            user_exists = False
-            if "results" in check_result and len(check_result["results"]) > 0:
-                result = check_result["results"][0]
-                if "rows" in result and len(result["rows"]) > 0:
-                    count = result["rows"][0]["values"][0]
-                    user_exists = count > 0
+            if users and len(users) > 0:
+                # User exists, check if they're an admin
+                user = users[0]
+                user_id = user.get("id")
+                is_admin = bool(user.get("is_admin", 0))
 
-            if user_exists:
-                logger.info(f"[{operation_id}] Super user already exists according to HTTP API")
+                logger.info(f"[{operation_id}] Super user already exists with ID: {user_id}, is_admin: {is_admin}")
 
-                # Check if the user is an admin
-                admin_query = {
-                    "requests": [
-                        {
-                            "type": "execute",
-                            "stmt": {
-                                "sql": "SELECT id, is_admin FROM users WHERE email = ?",
-                                "args": [
-                                    {"type": "text", "value": super_user_email}
-                                ]
-                            }
-                        },
-                        {"type": "close"}
-                    ]
-                }
+                # If user exists but is not admin, make them admin
+                if not is_admin:
+                    logger.info(f"[{operation_id}] Updating user to have admin privileges")
+
+                    update_result = db_http.update_record(
+                        "users",
+                        {"is_admin": 1},
+                        "id = ?",
+                        [{"type": "integer", "value": str(user_id)}],
+                        operation_id=f"{operation_id}_update"
+                    )
 
-                # Send the request to check if user is admin
-                admin_response = requests.post(f"{http_url}/v2/pipeline", headers=headers, json=admin_query)
-                admin_response.raise_for_status()
-                admin_result = admin_response.json()
-
-                logger.info(f"[{operation_id}] Admin check response: {admin_result}")
-
-                # Parse the result to see if user is admin
-                is_admin = False
-                user_id = None
-                if "results" in admin_result and len(admin_result["results"]) > 0:
-                    result = admin_result["results"][0]
-                    if "rows" in result and len(result["rows"]) > 0:
-                        user_id = result["rows"][0]["values"][0]
-                        is_admin = result["rows"][0]["values"][1] == 1
-
-                if user_id:
-                    logger.info(f"[{operation_id}] Found user with ID: {user_id}, is_admin: {is_admin}")
-
-                    # If user exists but is not admin, make them admin
-                    if not is_admin:
-                        logger.info(f"[{operation_id}] Updating user to have admin privileges")
-
-                        update_query = {
-                            "requests": [
-                                {
-                                    "type": "execute",
-                                    "stmt": {
-                                        "sql": "UPDATE users SET is_admin = 1 WHERE id = ?",
-                                        "args": [
-                                            {"type": "integer", "value": str(user_id)}
-                                        ]
-                                    }
-                                },
-                                {"type": "close"}
-                            ]
-                        }
-
-                        # Send the request to update the user
-                        update_response = requests.post(f"{http_url}/v2/pipeline", headers=headers, json=update_query)
-                        update_response.raise_for_status()
+                    if update_result:
                         logger.info(f"[{operation_id}] User updated to admin successfully")
+                    else:
+                        logger.warning(f"[{operation_id}] Failed to update user to admin")
 
                 return
 
             # User doesn't exist, create it
             logger.info(f"[{operation_id}] Super user does not exist, creating now")
 
-            # First, make sure the table exists
-            create_table_query = {
-                "requests": [
-                    {
-                        "type": "execute",
-                        "stmt": {
-                            "sql": """
-                            CREATE TABLE IF NOT EXISTS users (
-                                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                                email TEXT NOT NULL UNIQUE,
-                                hashed_password TEXT NOT NULL,
-                                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-                                last_login DATETIME,
-                                is_admin INTEGER DEFAULT 0
-                            )
-                            """
-                        }
-                    },
-                    {"type": "close"}
-                ]
-            }
-
-            # Send the request to create the table
-            create_table_response = requests.post(f"{http_url}/v2/pipeline", headers=headers, json=create_table_query)
-            create_table_response.raise_for_status()
-            logger.info(f"[{operation_id}] Table creation response: {create_table_response.status_code}")
-
             # Insert the super user
-            insert_query = {
-                "requests": [
-                    {
-                        "type": "execute",
-                        "stmt": {
-                            "sql": "INSERT INTO users (email, hashed_password, is_admin) VALUES (?, ?, 1)",
-                            "args": [
-                                {"type": "text", "value": super_user_email},
-                                {"type": "text", "value": hashed_password}
-                            ]
-                        }
-                    },
-                    {
-                        "type": "execute",
-                        "stmt": {"sql": "SELECT last_insert_rowid()"}
-                    },
-                    {"type": "close"}
-                ]
+            user_data = {
+                "email": super_user_email,
+                "hashed_password": hashed_password,
+                "is_admin": 1
             }
 
-            # Send the request to insert the user
-            insert_response = requests.post(f"{http_url}/v2/pipeline", headers=headers, json=insert_query)
-            insert_response.raise_for_status()
-            insert_result = insert_response.json()
-
-            logger.info(f"[{operation_id}] Insert response: {insert_result}")
+            user_id = db_http.insert_record("users", user_data, operation_id=f"{operation_id}_insert")
 
-            # Try to get the last inserted ID
-            last_id = None
-            if "results" in insert_result and len(insert_result["results"]) > 1:
-                result = insert_result["results"][1]
-                if "rows" in result and len(result["rows"]) > 0:
-                    last_id = result["rows"][0]["values"][0]
-                    logger.info(f"[{operation_id}] Last inserted ID: {last_id}")
-
-            # Verify the user was created
-            verify_query = {
-                "requests": [
-                    {
-                        "type": "execute",
-                        "stmt": {
-                            "sql": "SELECT * FROM users WHERE email = ?",
-                            "args": [
-                                {"type": "text", "value": super_user_email}
-                            ]
-                        }
-                    },
-                    {"type": "close"}
-                ]
-            }
+            if user_id:
+                logger.info(f"[{operation_id}] Super user created successfully with ID: {user_id}")
 
-            # Send the request to verify the user
-            verify_response = requests.post(f"{http_url}/v2/pipeline", headers=headers, json=verify_query)
-            verify_response.raise_for_status()
-            verify_result = verify_response.json()
-
-            logger.info(f"[{operation_id}] Verify response: {verify_result}")
-
-            # Check if the user was found
-            user_found = False
-            user_id = None
-            if "results" in verify_result and len(verify_result["results"]) > 0:
-                result = verify_result["results"][0]
-                if "rows" in result and len(result["rows"]) > 0:
-                    user_found = True
-                    user_id = result["rows"][0]["values"][0]
-                    logger.info(f"[{operation_id}] User found with ID: {user_id}")
-
-            if user_found:
-                logger.info(f"[{operation_id}] Super user created successfully")
-            else:
-                # List all users for diagnostic purposes
-                list_query = {
-                    "requests": [
-                        {
-                            "type": "execute",
-                            "stmt": {"sql": "SELECT id, email FROM users"}
-                        },
-                        {"type": "close"}
-                    ]
-                }
+                # Verify the user was created
+                new_user = db_http.get_record_by_id("users", user_id, operation_id=f"{operation_id}_verify")
 
-                # Send the request to list all users
-                list_response = requests.post(f"{http_url}/v2/pipeline", headers=headers, json=list_query)
-                list_response.raise_for_status()
-                list_result = list_response.json()
+                if new_user:
+                    logger.info(f"[{operation_id}] Super user verified with ID: {user_id}")
+                    return
+                else:
+                    logger.warning(f"[{operation_id}] Super user not found by ID after creation")
 
-                logger.info(f"[{operation_id}] List response: {list_result}")
+                    # Try to find by email
+                    users = db_http.select_records(
+                        "users",
+                        condition="email = ?",
+                        condition_params=[{"type": "text", "value": super_user_email}],
+                        limit=1,
+                        operation_id=f"{operation_id}_verify_email"
+                    )
 
-                # Extract the list of users
-                all_users = []
-                if "results" in list_result and len(list_result["results"]) > 0:
-                    result = list_result["results"][0]
-                    if "rows" in result:
-                        for row in result["rows"]:
-                            all_users.append(row["values"])
+                    if users and len(users) > 0:
+                        logger.info(f"[{operation_id}] Super user found by email after creation")
+                        return
 
-                logger.warning(f"[{operation_id}] Super user was not found after creation. All users: {all_users}")
+            # If we get here, we couldn't verify the user was created
+            # List all users for diagnostic purposes
+            all_users = db_http.select_records("users", operation_id=f"{operation_id}_list_all")
+            logger.warning(f"[{operation_id}] Super user was not found after creation. All users: {all_users}")
 
         except Exception as e:
             logger.error(f"[{operation_id}] Error creating super user with HTTP API: {str(e)}")