update

backend/app/database.py

@@ -71,6 +71,46 @@ def get_db():
     finally:
         db.close()
 
+def get_direct_psycopg2_connection():
+    """Get a direct psycopg2 connection bypassing SQLAlchemy version parsing"""
+    try:
+        import psycopg2
+        from urllib.parse import urlparse, parse_qs
+        
+        # Only for PostgreSQL/CockroachDB connections
+        if not (ORIGINAL_DATABASE_URL.startswith("postgresql://") or 
+                ORIGINAL_DATABASE_URL.startswith("postgres://") or 
+                ORIGINAL_DATABASE_URL.startswith("cockroachdb://")):
+            return None
+        
+        # Parse connection string
+        url_for_parsing = ORIGINAL_DATABASE_URL.replace("cockroachdb://", "postgresql://")
+        parsed = urlparse(url_for_parsing)
+        dbname = parsed.path[1:] if parsed.path else "defaultdb"
+        user = parsed.username
+        password = parsed.password
+        host = parsed.hostname
+        port = parsed.port or 26257
+        
+        # Get sslmode from query params
+        params = parse_qs(parsed.query)
+        sslmode_list = params.get('sslmode', ['require'])
+        sslmode = sslmode_list[0] if sslmode_list else 'require'
+        
+        # Create connection
+        conn = psycopg2.connect(
+            dbname=dbname,
+            user=user,
+            password=password,
+            host=host,
+            port=port,
+            sslmode=sslmode
+        )
+        return conn
+    except Exception as e:
+        print(f"Failed to create direct psycopg2 connection: {e}")
+        return None
+
 def init_db():
     """Initialize database tables"""
     try:

backend/app/main.py

@@ -16,7 +16,7 @@ from app.schemas import (
 from app.services.canva_service import CanvaService
 from app.services.linkedin_service import LinkedInService
 from app.services.ai_service import AIService
-from app.database import init_db, get_db
+from app.database import init_db, get_db, get_direct_psycopg2_connection
 from sqlalchemy.orm import Session
 
 app = FastAPI(title="PostGen API", version="1.0.0")
@@ -205,50 +205,65 @@ async def upload_asset(
                     # Refresh might fail due to version string, but commit succeeded
                     # Query the asset back to get the ID
                     if "Could not determine version" in str(refresh_error):
-                        from sqlalchemy import text
-                        result = db.execute(
-                            text("SELECT id, created_at FROM assets WHERE name = :name AND file_path = :file_path ORDER BY id DESC LIMIT 1"),
-                            {"name": file.filename, "file_path": str(file_path)}
-                        )
-                        row = result.fetchone()
-                        if row:
-                            db_asset.id = row[0]
-                            # Set created_at if available
-                            if hasattr(db_asset, 'created_at') and row[1]:
-                                db_asset.created_at = row[1]
+                        # Use direct psycopg2 to query back the asset
+                        conn = get_direct_psycopg2_connection()
+                        if conn:
+                            try:
+                                cursor = conn.cursor()
+                                cursor.execute("""
+                                    SELECT id, created_at FROM assets 
+                                    WHERE name = %s AND file_path = %s 
+                                    ORDER BY id DESC LIMIT 1
+                                """, (file.filename, str(file_path)))
+                                row = cursor.fetchone()
+                                cursor.close()
+                                conn.close()
+                                if row:
+                                    db_asset.id = row[0]
+                                    if hasattr(db_asset, 'created_at') and row[1]:
+                                        db_asset.created_at = row[1]
+                            except Exception as psycopg2_error:
+                                print(f"Direct psycopg2 query failed: {psycopg2_error}")
+                                if conn:
+                                    conn.close()
                     else:
                         raise refresh_error
             except Exception as commit_error:
-                # If commit fails due to version string issue, try raw SQL
+                # If commit fails due to version string issue, use direct psycopg2
                 db.rollback()
                 error_str = str(commit_error)
                 if "Could not determine version" in error_str:
-                    # Try using raw SQL to insert
-                    from sqlalchemy import text
-                    try:
-                        result = db.execute(
-                            text("""
+                    # Use direct psycopg2 connection to bypass SQLAlchemy
+                    conn = get_direct_psycopg2_connection()
+                    if conn:
+                        try:
+                            cursor = conn.cursor()
+                            cursor.execute("""
                                 INSERT INTO assets (name, file_path, file_type, product_category, sub_category, size, user_id, created_at)
-                                VALUES (:name, :file_path, :file_type, :product_category, :sub_category, :size, :user_id, NOW())
+                                VALUES (%s, %s, %s, %s, %s, %s, %s, NOW())
                                 RETURNING id, created_at
-                            """),
-                            {
-                                "name": file.filename,
-                                "file_path": str(file_path),
-                                "file_type": file_type,
-                                "product_category": product_category or "ocr",
-                                "sub_category": sub_category if sub_category and sub_category != "none" else None,
-                                "size": file_size,
-                                "user_id": 1
-                            }
-                        )
-                        row = result.fetchone()
-                        if row:
-                            db_asset.id = row[0]
-                            db_asset.created_at = row[1]
-                        db.commit()
-                    except Exception as sql_error:
-                        print(f"Raw SQL insert also failed: {sql_error}")
+                            """, (
+                                file.filename,
+                                str(file_path),
+                                file_type,
+                                product_category or "ocr",
+                                sub_category if sub_category and sub_category != "none" else None,
+                                file_size,
+                                1
+                            ))
+                            row = cursor.fetchone()
+                            conn.commit()
+                            cursor.close()
+                            conn.close()
+                            if row:
+                                db_asset.id = row[0]
+                                db_asset.created_at = row[1]
+                        except Exception as psycopg2_error:
+                            print(f"Direct psycopg2 insert failed: {psycopg2_error}")
+                            if conn:
+                                conn.close()
+                            raise commit_error
+                    else:
                         raise commit_error
                 else:
                     raise commit_error
@@ -310,32 +325,51 @@ async def get_assets(
                     "created_at": asset.created_at
                 })
         except Exception as orm_error:
-            # If ORM fails due to version string issue, use raw SQL
-            print(f"ORM query warning, using raw SQL: {orm_error}")
-            try:
-                sql_query = "SELECT id, name, file_path, file_type, product_category, sub_category, size, created_at FROM assets"
-                params = {}
-                if product_category and product_category != "all":
-                    sql_query += " WHERE product_category = :product_category"
-                    params["product_category"] = product_category
-                sql_query += " ORDER BY created_at DESC"
-                
-                result = db.execute(text(sql_query), params)
-                rows = result.fetchall()
-                
-                assets = []
-                for row in rows:
-                    assets.append({
-                        "id": row[0],
-                        "name": row[1],
-                        "file_type": row[3],
-                        "product_category": row[4],
-                        "sub_category": row[5],
-                        "size": row[6],
-                        "created_at": row[7]
-                    })
-            except Exception as sql_error:
-                print(f"Raw SQL query also failed: {sql_error}")
+            # If ORM fails due to version string issue, use direct psycopg2
+            error_str = str(orm_error)
+            if "Could not determine version" in error_str:
+                # Use direct psycopg2 connection to bypass SQLAlchemy
+                conn = get_direct_psycopg2_connection()
+                if conn:
+                    try:
+                        cursor = conn.cursor()
+                        if product_category and product_category != "all":
+                            cursor.execute("""
+                                SELECT id, name, file_path, file_type, product_category, sub_category, size, created_at 
+                                FROM assets 
+                                WHERE product_category = %s 
+                                ORDER BY created_at DESC
+                            """, (product_category,))
+                        else:
+                            cursor.execute("""
+                                SELECT id, name, file_path, file_type, product_category, sub_category, size, created_at 
+                                FROM assets 
+                                ORDER BY created_at DESC
+                            """)
+                        rows = cursor.fetchall()
+                        cursor.close()
+                        conn.close()
+                        
+                        assets = []
+                        for row in rows:
+                            assets.append({
+                                "id": row[0],
+                                "name": row[1],
+                                "file_type": row[3],
+                                "product_category": row[4],
+                                "sub_category": row[5],
+                                "size": row[6],
+                                "created_at": row[7]
+                            })
+                    except Exception as psycopg2_error:
+                        print(f"Direct psycopg2 query failed: {psycopg2_error}")
+                        if conn:
+                            conn.close()
+                        assets = []
+                else:
+                    assets = []
+            else:
+                print(f"ORM query error: {orm_error}")
                 assets = []
         
         # Merge with mock data (as requested - keep dummy content)