Upload 10 files

main.py

@@ -1,9 +1,40 @@
 import os
+import sys
+import logging
 from fastapi import FastAPI, HTTPException, Depends
 from fastapi.middleware.cors import CORSMiddleware
 import uvicorn
 from dotenv import load_dotenv
-import libsql_experimental as libsql
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler(sys.stdout)]
+)
+logger = logging.getLogger("auth-server")
+
+# Import database libraries
+try:
+    # First try the recommended libsql-experimental package
+    import libsql_experimental as libsql
+    logger.info("Successfully imported libsql-experimental package")
+    HAS_LIBSQL = True
+    LIBSQL_TYPE = "experimental"
+except ImportError:
+    try:
+        # Then try the libsql-client package as fallback
+        import libsql_client
+        logger.info("Successfully imported libsql-client package")
+        HAS_LIBSQL = True
+        LIBSQL_TYPE = "client"
+    except ImportError:
+        logger.error("Failed to import any libsql package. Please install libsql-experimental==0.0.49")
+        logger.error("Falling back to HTTP API method for database access")
+        # We'll use requests for HTTP API fallback
+        import requests
+        HAS_LIBSQL = False
+        LIBSQL_TYPE = "http"
 
 # Load environment variables
 load_dotenv()
@@ -48,25 +79,201 @@ async def startup_db_client():
 
     if not db_url or not auth_token:
         error_msg = "Missing Turso credentials. TURSO_DATABASE_URL and TURSO_AUTH_TOKEN must be set."
-        print(error_msg)
+        logger.error(error_msg)
         raise Exception(error_msg)
 
-    try:
-        # Use the URL with embedded auth token
-        print(f"Connecting to Turso database at: {db_url}")
-        # Format the URL to include the auth token
-        if "?" in db_url:
-            connection_url = f"{db_url}&authToken={auth_token.strip()}"
-        else:
-            connection_url = f"{db_url}?authToken={auth_token.strip()}"
+    # Clean the auth token to remove any problematic characters
+    clean_auth_token = auth_token.strip()
+
+    logger.info(f"Connecting to database at URL: {db_url}")
+    logger.info(f"Using libsql type: {LIBSQL_TYPE}")
+
+    # Initialize database connection
+    connected = False
+
+    # Method 1: Try with libsql-experimental
+    if HAS_LIBSQL and LIBSQL_TYPE == "experimental":
+        try:
+            logger.info("Connecting with libsql-experimental")
+
+            # Try multiple connection methods
+
+            # Method 1a: Try with auth_token parameter (works with version 0.0.49)
+            try:
+                logger.info("Trying connection with auth_token parameter")
+                app.db_conn = libsql.connect(db_url, auth_token=clean_auth_token)
+
+                # Test connection
+                result = app.db_conn.execute("SELECT 1").fetchone()
+                logger.info(f"Connection successful with auth_token parameter: {result}")
+                connected = True
+                app.db_type = "libsql-experimental"
+            except Exception as e:
+                logger.warning(f"Connection with auth_token parameter failed: {str(e)}")
+
+            # Method 1b: Try with auth token in URL (works with other versions)
+            if not connected:
+                try:
+                    logger.info("Trying connection with auth token in URL")
+
+                    # Format the URL to include the auth token
+                    if "?" in db_url:
+                        connection_url = f"{db_url}&authToken={clean_auth_token}"
+                    else:
+                        connection_url = f"{db_url}?authToken={clean_auth_token}"
+
+                    logger.info(f"Using connection URL: {connection_url}")
+
+                    # Use the direct URL connection method with auth token in URL
+                    app.db_conn = libsql.connect(connection_url)
+
+                    # Test connection
+                    result = app.db_conn.execute("SELECT 1").fetchone()
+                    logger.info(f"Connection successful with auth token in URL: {result}")
+                    connected = True
+                    app.db_type = "libsql-experimental"
+                except Exception as e:
+                    logger.error(f"Connection with auth token in URL failed: {str(e)}")
+        except Exception as e:
+            logger.error(f"All libsql-experimental connection methods failed: {str(e)}")
+
+    # Method 2: Try with libsql-client
+    if not connected and HAS_LIBSQL and LIBSQL_TYPE == "client":
+        try:
+            logger.info("Connecting with libsql-client")
+
+            # Convert URL from libsql:// to https://
+            if db_url.startswith("libsql://"):
+                http_url = db_url.replace("libsql://", "https://")
+            else:
+                http_url = db_url
+
+            logger.info(f"Using URL: {http_url}")
+
+            # Connect using the client
+            app.db_conn = libsql_client.create_client_sync(
+                url=http_url,
+                auth_token=clean_auth_token
+            )
+
+            # Test connection
+            result = app.db_conn.execute("SELECT 1").rows()
+            logger.info(f"Connection test successful: {result}")
+            connected = True
+            app.db_type = "libsql-client"
+        except Exception as e:
+            logger.error(f"libsql-client connection failed: {str(e)}")
+
+    # Method 3: Fallback to HTTP API
+    if not connected:
+        try:
+            logger.info("Falling back to HTTP API method")
+
+            # Convert URL from libsql:// to https://
+            if db_url.startswith("libsql://"):
+                http_url = db_url.replace("libsql://", "https://")
+            else:
+                http_url = db_url
 
-        app.db_conn = libsql.connect(connection_url)
+            logger.info(f"Using HTTP URL: {http_url}")
 
-        # Test connection
-        result = app.db_conn.execute("SELECT 1").fetchone()
-        print(f"Connection test successful: {result}")
+            # Create a simple HTTP API client class
+            class TursoHttpClient:
+                def __init__(self, url, auth_token):
+                    self.url = url
+                    self.auth_token = auth_token
+                    self.headers = {
+                        "Authorization": f"Bearer {auth_token}",
+                        "Content-Type": "application/json"
+                    }
+
+                def execute(self, query, params=None):
+                    # Format the request according to the v2/pipeline specification
+                    requests_data = []
+
+                    # Prepare the statement
+                    stmt = {"sql": query}
+
+                    # Add parameters if provided
+                    if params:
+                        # Convert parameters to the expected format
+                        args = []
+                        for param in params:
+                            if param is None:
+                                args.append({"type": "null", "value": None})
+                            elif isinstance(param, int):
+                                args.append({"type": "integer", "value": str(param)})
+                            elif isinstance(param, float):
+                                args.append({"type": "float", "value": str(param)})
+                            else:
+                                args.append({"type": "text", "value": str(param)})
+
+                        stmt["args"] = args
+
+                    requests_data.append({"type": "execute", "stmt": stmt})
+
+                    # Always close the connection at the end
+                    requests_data.append({"type": "close"})
+
+                    # Prepare the final request payload
+                    data = {"requests": requests_data}
+
+                    # Use the v2/pipeline endpoint
+                    pipeline_url = f"{self.url}/v2/pipeline"
+                    response = requests.post(pipeline_url, headers=self.headers, json=data)
+                    response.raise_for_status()
+                    result = response.json()
+
+                    # Process the response
+                    if "results" in result and len(result["results"]) > 0:
+                        # Return a cursor-like object
+                        return TursoHttpCursor(result["results"][0])
+
+                    return TursoHttpCursor(None)
+
+                def commit(self):
+                    # HTTP API is stateless, no need to commit
+                    pass
+
+                def close(self):
+                    # HTTP API is stateless, no need to close
+                    pass
+
+            # Create a cursor-like class for HTTP API
+            class TursoHttpCursor:
+                def __init__(self, result):
+                    self.result = result
+
+                def fetchone(self):
+                    if self.result and "rows" in self.result and len(self.result["rows"]) > 0:
+                        return self.result["rows"][0]["values"]
+                    return None
+
+                def fetchall(self):
+                    if self.result and "rows" in self.result:
+                        return [row["values"] for row in self.result["rows"]]
+                    return []
+
+            # Create the HTTP API client
+            app.db_conn = TursoHttpClient(http_url, clean_auth_token)
+
+            # Test connection
+            result = app.db_conn.execute("SELECT 1").fetchone()
+            logger.info(f"HTTP API connection test successful: {result}")
+            connected = True
+            app.db_type = "http-api"
+        except Exception as e:
+            logger.error(f"HTTP API connection failed: {str(e)}")
+
+    if not connected:
+        error_msg = "All database connection methods failed. Please check your credentials and try again."
+        logger.error(error_msg)
+        raise Exception(error_msg)
+
+    # Create tables if they don't exist
+    try:
+        logger.info("Creating database tables")
 
-        # Create tables if they don't exist
         app.db_conn.execute("""
         CREATE TABLE IF NOT EXISTS users (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -105,20 +312,36 @@ async def startup_db_client():
         """)
 
         app.db_conn.commit()
-        print("Database tables created successfully")
-
+        logger.info("Database tables created successfully")
     except Exception as e:
-        error_msg = f"Failed to connect to Turso database: {str(e)}"
-        print(error_msg)
+        error_msg = f"Failed to create database tables: {str(e)}"
+        logger.error(error_msg)
         raise Exception(error_msg)
 
 @app.on_event("shutdown")
 async def shutdown_db_client():
+    logger.info("Shutting down database connection")
     try:
-        app.db_conn.close()
-        print("Database connection closed successfully")
+        # Close connection based on the type
+        if hasattr(app, 'db_type'):
+            if app.db_type == "libsql-experimental":
+                try:
+                    app.db_conn.close()
+                    logger.info("libsql-experimental connection closed successfully")
+                except Exception as e:
+                    logger.warning(f"Error closing libsql-experimental connection: {str(e)}")
+            elif app.db_type == "libsql-client":
+                # libsql-client doesn't have a close method
+                logger.info("No close method needed for libsql-client")
+            elif app.db_type == "http-api":
+                # HTTP API is stateless, no need to close
+                logger.info("No close method needed for HTTP API")
+            else:
+                logger.warning(f"Unknown database type: {app.db_type}")
+        else:
+            logger.warning("No database connection to close")
     except Exception as e:
-        print(f"Error closing database connection: {str(e)}")
+        logger.error(f"Error closing database connection: {str(e)}")
 
 # Root endpoint
 @app.get("/")

requirements.txt

@@ -5,6 +5,9 @@ python-jose==3.3.0
 passlib==1.7.4
 pydantic==2.4.2
 httpx==0.25.0
-libsql-experimental==0.0.6
+# Use version 0.0.49 of libsql-experimental which supports the auth_token parameter
+libsql-experimental==0.0.49
+# For HTTP API fallback
+requests==2.31.0
 python-multipart==0.0.6
 email-validator==2.0.0