Upload 10 files

main.py

@@ -271,52 +271,91 @@ async def startup_db_client():
         raise Exception(error_msg)
 
     # Create tables if they don't exist
-    try:
-        logger.info("Creating database tables")
+    # We'll create each table in a separate try-except block to ensure that if one fails, others can still be created
+    logger.info("Creating database tables")
 
-        app.db_conn.execute("""
+    # Function to execute SQL with retry
+    def execute_with_retry(sql, max_retries=3):
+        for attempt in range(max_retries):
+            try:
+                # For each attempt, we'll create a fresh connection if needed
+                if attempt > 0:
+                    logger.info(f"Retry attempt {attempt+1} for SQL execution")
+                    # Test the connection first
+                    try:
+                        test_result = app.db_conn.execute("SELECT 1").fetchone()
+                        logger.info(f"Connection test successful: {test_result}")
+                    except Exception as conn_err:
+                        logger.warning(f"Connection test failed, reconnecting: {str(conn_err)}")
+                        # Reconnect using the same method that worked initially
+                        if app.db_type == "libsql-experimental":
+                            app.db_conn = libsql.connect(db_url, auth_token=clean_auth_token)
+
+                # Execute the SQL
+                app.db_conn.execute(sql)
+                app.db_conn.commit()
+                return True
+            except Exception as e:
+                logger.warning(f"SQL execution failed (attempt {attempt+1}): {str(e)}")
+                if attempt == max_retries - 1:
+                    raise
+                # Small delay before retry
+                import time
+                time.sleep(1)
+
+    # Simplified table creation with fewer constraints
+    try:
+        # Create users table
+        users_table = """
         CREATE TABLE IF NOT EXISTS users (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
-            email TEXT NOT NULL UNIQUE CHECK(LENGTH(email) <= 320),
-            hashed_password TEXT NOT NULL CHECK(LENGTH(hashed_password) = 97),
+            email TEXT NOT NULL UNIQUE,
+            hashed_password TEXT NOT NULL,
             created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
             last_login DATETIME,
-            is_admin BOOLEAN DEFAULT FALSE
+            is_admin INTEGER DEFAULT 0
         )
-        """)
+        """
+        execute_with_retry(users_table)
+        logger.info("Users table created successfully")
 
-        app.db_conn.execute("""
+        # Create projects table
+        projects_table = """
         CREATE TABLE IF NOT EXISTS projects (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             owner_id INTEGER NOT NULL,
-            title TEXT NOT NULL CHECK(LENGTH(title) BETWEEN 3 AND 120),
-            description TEXT CHECK(LENGTH(description) <= 2000),
+            title TEXT NOT NULL,
+            description TEXT,
             geojson TEXT,
             storage_bucket TEXT DEFAULT 'default',
             created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-            FOREIGN KEY (owner_id) REFERENCES users(id)
+            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
         )
-        """)
+        """
+        execute_with_retry(projects_table)
+        logger.info("Projects table created successfully")
 
-        app.db_conn.execute("""
+        # Create journals table
+        journals_table = """
         CREATE TABLE IF NOT EXISTS journals (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
             project_id INTEGER NOT NULL,
-            title TEXT NOT NULL CHECK(LENGTH(title) BETWEEN 3 AND 120),
-            content TEXT CHECK(LENGTH(content) <= 50000),
+            title TEXT NOT NULL,
+            content TEXT,
             created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-            FOREIGN KEY (project_id) REFERENCES projects(id)
+            updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
         )
-        """)
+        """
+        execute_with_retry(journals_table)
+        logger.info("Journals table created successfully")
 
-        app.db_conn.commit()
-        logger.info("Database tables created successfully")
+        logger.info("All database tables created successfully")
     except Exception as e:
         error_msg = f"Failed to create database tables: {str(e)}"
         logger.error(error_msg)
-        raise Exception(error_msg)
+        # We'll continue even if table creation fails
+        # This allows the server to start and use existing tables if they exist
+        logger.warning("Continuing server startup despite table creation errors")
 
 @app.on_event("shutdown")
 async def shutdown_db_client():