Debug - Change DB

Dockerfile

@@ -18,8 +18,9 @@ COPY ./app /code/app
 # Make port 7860 available to the world outside this container (Gradio default)
 EXPOSE 7860
 
-# Ensure the database directory exists if using SQLite relative paths implicitly
-# RUN mkdir -p /code/app
+# Explicitly create the /data directory where the SQLite DB will live
+# Running as root by default, so permissions should be okay initially
+RUN mkdir -p /data
 
 # Command to run the application using uvicorn
 # It will run the FastAPI app instance created in app/main.py

app/database.py

@@ -1,19 +1,24 @@
+# app/database.py
 import os
 from databases import Database
 from dotenv import load_dotenv
 from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, text
+import logging # Add logging
 
 load_dotenv()
+logger = logging.getLogger(__name__) # Add logger
 
-DATABASE_URL = os.getenv("DATABASE_URL", "sqlite+aiosqlite:///./app/app.db")
+# --- CHANGE THIS LINE ---
+# Use an absolute path in a known writable directory like /data
+DATABASE_URL = os.getenv("DATABASE_URL", "sqlite+aiosqlite:////data/app.db")
+# Note the four slashes for an absolute path: sqlite+aiosqlite:////path/to/db
 
-# Use 'check_same_thread': False only for SQLite, it's generally not needed for server DBs
+# Use 'check_same_thread': False only for SQLite
 connect_args = {"check_same_thread": False} if DATABASE_URL.startswith("sqlite") else {}
 
 database = Database(DATABASE_URL, connect_args=connect_args)
 metadata = MetaData()
 
-# Define Users table using SQLAlchemy Core (needed for initial setup)
 users = Table(
     "users",
     metadata,
@@ -22,26 +27,57 @@ users = Table(
     Column("hashed_password", String, nullable=False),
 )
 
-# Create the database and table if they don't exist
-# This synchronous part runs once at startup usually
-engine = create_engine(DATABASE_URL.replace("+aiosqlite", ""), connect_args=connect_args)
+# Create the database and table if they don't exist (synchronous part)
+# Derive the synchronous URL correctly from the potentially absolute DATABASE_URL
+sync_db_url = DATABASE_URL.replace("+aiosqlite", "")
+logger.info(f"Using synchronous DB URL for initial check/create: {sync_db_url}")
+engine = create_engine(sync_db_url, connect_args=connect_args)
 
-# Check if table exists before creating
-# Using a try-except block for robustness across DB engines if needed later
+# Extract the directory path to ensure it exists
+db_file_path = sync_db_url.split("sqlite:///")[-1] # Gets /data/app.db
+if db_file_path: # Ensure we got a path
+    db_dir = os.path.dirname(db_file_path)
+    logger.info(f"Ensuring database directory exists: {db_dir}")
+    try:
+        if db_dir and not os.path.exists(db_dir):
+            os.makedirs(db_dir, exist_ok=True)
+            logger.info(f"Created database directory: {db_dir}")
+    except OSError as e:
+        logger.error(f"Error creating database directory {db_dir}: {e}")
+        # Proceed anyway, maybe permissions allow file creation but not dir listing/creation
+
+# Now try connecting and creating the table
 try:
+    logger.info("Attempting to connect with sync engine to check/create table...")
     with engine.connect() as connection:
-        connection.execute(text("SELECT 1 FROM users LIMIT 1"))
-    print("Users table already exists.")
-except Exception:
-    print("Users table not found, creating...")
-    metadata.create_all(engine)
-    print("Users table created.")
-
-# Async connect/disconnect functions for FastAPI lifespan events
+        # Try a simple query to see if the table exists
+        try:
+            connection.execute(text("SELECT 1 FROM users LIMIT 1"))
+            logger.info("Users table already exists.")
+        except Exception: # Catch specific DB exceptions if possible, e.g., sqlalchemy.exc.ProgrammingError
+            logger.info("Users table not found or error checking, attempting creation...")
+            metadata.create_all(engine) # Create tables if check fails
+            logger.info("Users table created (or creation attempted).")
+
+except Exception as e:
+    logger.exception(f"CRITICAL: Failed to connect/create database tables using sync engine: {e}")
+    # Application might fail to start properly here. Depending on requirements,
+    # you might raise the exception or just log it and hope the async part works.
+    # For now, just log it, as the async connection might still succeed later.
+
+
+# Async connect/disconnect functions
 async def connect_db():
-    await database.connect()
-    print("Database connection established.")
+    try:
+        await database.connect()
+        logger.info(f"Database connection established (async): {DATABASE_URL}")
+    except Exception as e:
+        logger.exception(f"Failed to establish async database connection: {e}")
+        raise # Reraise critical error during startup lifespan
 
 async def disconnect_db():
-    await database.disconnect()
-    print("Database connection closed.")
+    try:
+        await database.disconnect()
+        logger.info("Database connection closed (async).")
+    except Exception as e:
+        logger.exception(f"Error closing async database connection: {e}")