Add postgres support

api/alembic/env.py

@@ -35,7 +35,15 @@ def include_object(object, name, type_, reflected, compare_to):
 
 # Remove the sqlite+aiosqlite:// prefix and use sqlite:// for Alembic
 # Alembic needs a synchronous connection URL (uses sqlite3, not aiosqlite)
-sync_url = DATABASE_URL.replace("sqlite+aiosqlite:///", "sqlite:///")
+# For PostgreSQL, replace postgresql+asyncpg:// with postgresql://
+if DATABASE_URL.startswith("sqlite+aiosqlite:///"):
+    sync_url = DATABASE_URL.replace("sqlite+aiosqlite:///", "sqlite:///")
+elif DATABASE_URL.startswith("postgresql+asyncpg://"):
+    sync_url = DATABASE_URL.replace("postgresql+asyncpg://", "postgresql://")
+else:
+    # Fallback: use as-is if format is unexpected
+    sync_url = DATABASE_URL
+
 config.set_main_option("sqlalchemy.url", sync_url)
 
 

api/alembic/versions/a1b2c3d4e5f6_convert_uuid_columns_for_postgres.py

@@ -0,0 +1,55 @@
+"""Convert user and oauth_account UUID columns to native UUID type for PostgreSQL
+
+This migration fixes the CHAR(36) vs native UUID type mismatch that causes
+PostgreSQL to reject queries with the error:
+  "operator does not exist: character = uuid"
+
+FastAPI-users expects native UUID columns in PostgreSQL. The initial migration
+created CHAR(36) columns (an SQLite compatibility workaround). This migration
+converts those columns to the native UUID type on PostgreSQL. It is a no-op
+for SQLite, which has no native UUID type.
+
+Revision ID: a1b2c3d4e5f6
+Revises: 4937b0e0647c
+Create Date: 2026-02-28 00:00:00.000000
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision: str = "a1b2c3d4e5f6"
+down_revision: Union[str, Sequence[str], None] = "4937b0e0647c"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Convert CHAR(36) UUID columns to native UUID type on PostgreSQL."""
+    connection = op.get_bind()
+
+    if connection.dialect.name != "postgresql":
+        # SQLite has no native UUID type — nothing to do
+        return
+
+    # Convert user.id from CHAR(36) to native UUID
+    op.execute(sa.text('ALTER TABLE "user" ALTER COLUMN id TYPE uuid USING id::uuid'))
+
+    # Convert oauth_account.id and oauth_account.user_id from CHAR(36) to native UUID
+    op.execute(sa.text("ALTER TABLE oauth_account ALTER COLUMN id TYPE uuid USING id::uuid"))
+    op.execute(sa.text("ALTER TABLE oauth_account ALTER COLUMN user_id TYPE uuid USING user_id::uuid"))
+
+
+def downgrade() -> None:
+    """Revert native UUID columns back to VARCHAR(36) on PostgreSQL."""
+    connection = op.get_bind()
+
+    if connection.dialect.name != "postgresql":
+        return
+
+    op.execute(sa.text('ALTER TABLE "user" ALTER COLUMN id TYPE varchar(36) USING id::text'))
+    op.execute(sa.text("ALTER TABLE oauth_account ALTER COLUMN id TYPE varchar(36) USING id::text"))
+    op.execute(sa.text("ALTER TABLE oauth_account ALTER COLUMN user_id TYPE varchar(36) USING user_id::text"))

api/alembic/versions/c175b784119c_create_oauth_account_table.py

@@ -11,6 +11,8 @@
 from alembic import op
 import sqlalchemy as sa
 
+from transformerlab.db.migration_utils import table_exists
+
 
 # revision identifiers, used by Alembic.
 revision: str = "c175b784119c"
@@ -23,14 +25,7 @@ def upgrade() -> None:
     """Create oauth_account table."""
     connection = op.get_bind()
 
-    # Helper function to check if table exists
-    def table_exists(table_name: str) -> bool:
-        result = connection.execute(
-            sa.text("SELECT name FROM sqlite_master WHERE type='table' AND name=:name"), {"name": table_name}
-        )
-        return result.fetchone() is not None
-
-    if not table_exists("oauth_account"):
+    if not table_exists(connection, "oauth_account"):
         op.create_table(
             "oauth_account",
             sa.Column("id", sa.CHAR(length=36), nullable=False),

api/alembic/versions/c78d76a6d65c_add_team_id_to_config_table.py

@@ -23,86 +23,76 @@ def upgrade() -> None:
     """Upgrade schema."""
     connection = op.get_bind()
 
-    # Check existing columns
-    column_result = connection.execute(sa.text("PRAGMA table_info(config)"))
-    existing_columns = [row[1] for row in column_result.fetchall()]
-
-    # Get existing indexes by querying SQLite directly
-    # SQLite stores unique constraints as unique indexes
-    index_result = connection.execute(
-        sa.text("SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='config'")
-    )
-    existing_index_names = [row[0] for row in index_result.fetchall()]
-
-    # Add columns first (outside batch mode to avoid circular dependency)
-    # Only add if they don't already exist
-    if "user_id" not in existing_columns:
-        op.add_column("config", sa.Column("user_id", sa.String(), nullable=True))
-    if "team_id" not in existing_columns:
-        op.add_column("config", sa.Column("team_id", sa.String(), nullable=True))
-
-    # Handle indexes outside of batch mode to avoid type inference issues
-    # Drop existing unique index on key if it exists (to recreate as non-unique)
-    if "ix_config_key" in existing_index_names:
-        # Check if it's unique by querying the index definition
-        index_info = connection.execute(
-            sa.text("SELECT sql FROM sqlite_master WHERE type='index' AND name='ix_config_key'")
-        ).fetchone()
-        if index_info and index_info[0] and "UNIQUE" in index_info[0].upper():
-            # Drop the unique index using raw SQL to avoid batch mode issues
-            connection.execute(sa.text("DROP INDEX IF EXISTS ix_config_key"))
-            existing_index_names.remove("ix_config_key")  # Update our list
-
-    # Create new indexes (non-unique) - these can be done outside batch mode
-    if "ix_config_key" not in existing_index_names:
+    # Add columns (outside batch mode to avoid circular dependency)
+    op.add_column("config", sa.Column("user_id", sa.String(), nullable=True))
+    op.add_column("config", sa.Column("team_id", sa.String(), nullable=True))
+
+    # Drop old unique index on key if it exists, then recreate as non-unique
+    try:
+        op.drop_index("ix_config_key", table_name="config")
+    except Exception:
+        pass  # Index doesn't exist or already dropped
+
+    # Create indexes (will fail silently if they already exist in some databases)
+    try:
         op.create_index("ix_config_key", "config", ["key"], unique=False)
-    if "ix_config_user_id" not in existing_index_names:
+    except Exception:
+        pass
+
+    try:
         op.create_index("ix_config_user_id", "config", ["user_id"], unique=False)
-    if "ix_config_team_id" not in existing_index_names:
+    except Exception:
+        pass
+
+    try:
         op.create_index("ix_config_team_id", "config", ["team_id"], unique=False)
+    except Exception:
+        pass
 
-    # For SQLite, unique constraints are stored as unique indexes
-    # Create the unique constraint as a unique index using raw SQL to avoid batch mode issues
-    if "uq_config_user_team_key" not in existing_index_names:
-        connection.execute(
-            sa.text("CREATE UNIQUE INDEX IF NOT EXISTS uq_config_user_team_key ON config(user_id, team_id, key)")
-        )
+    # Create unique constraint on (user_id, team_id, key)
+    try:
+        op.create_unique_constraint("uq_config_user_team_key", "config", ["user_id", "team_id", "key"])
+    except Exception:
+        pass  # Constraint already exists
 
     # Migrate existing configs to admin user's first team
     # Note: Don't call connection.commit() - Alembic manages transactions
-    connection = op.get_bind()
+
     # Find admin user's first team
+    users_teams = sa.table("users_teams", sa.column("user_id"), sa.column("team_id"))
+    users = sa.table("user", sa.column("id"), sa.column("email"))
+
     admin_team_result = connection.execute(
-        sa.text("""
-            SELECT ut.team_id
-            FROM users_teams ut
-            JOIN user u ON ut.user_id = u.id
-            WHERE u.email = '[email protected]'
-            LIMIT 1
-        """)
+        sa.select(users_teams.c.team_id)
+        .select_from(users_teams.join(users, users_teams.c.user_id == users.c.id))
+        .where(users.c.email == "[email protected]")
+        .limit(1)
     )
     admin_team_row = admin_team_result.fetchone()
 
     if admin_team_row:
         admin_team_id = admin_team_row[0]
         # Update all existing configs (where team_id is NULL) to use admin team
+        config_table = sa.table("config", sa.column("team_id"))
         connection.execute(
-            sa.text("UPDATE config SET team_id = :team_id WHERE team_id IS NULL"), {"team_id": admin_team_id}
+            sa.update(config_table).where(config_table.c.team_id.is_(None)).values(team_id=admin_team_id)
         )
         print(f"✅ Migrated existing configs to team {admin_team_id}")
     else:
         # If no admin team found, try to get any user's first team
-        any_team_result = connection.execute(sa.text("SELECT team_id FROM users_teams LIMIT 1"))
+        any_team_result = connection.execute(sa.select(users_teams.c.team_id).limit(1))
         any_team_row = any_team_result.fetchone()
         if any_team_row:
             any_team_id = any_team_row[0]
+            config_table = sa.table("config", sa.column("team_id"))
             connection.execute(
-                sa.text("UPDATE config SET team_id = :team_id WHERE team_id IS NULL"), {"team_id": any_team_id}
+                sa.update(config_table).where(config_table.c.team_id.is_(None)).values(team_id=any_team_id)
             )
             print(f"✅ Migrated existing configs to team {any_team_id}")
         else:
             # No teams found, delete existing configs
-            deleted_count = connection.execute(sa.text("DELETE FROM config WHERE team_id IS NULL")).rowcount
+            config_table = sa.table("config", sa.column("team_id"))
+            deleted_count = connection.execute(sa.delete(config_table).where(config_table.c.team_id.is_(None))).rowcount
             print(f"⚠️  No teams found, deleted {deleted_count} config entries")
     # ### end Alembic commands ###
 
@@ -111,33 +101,31 @@ def downgrade() -> None:
     """Downgrade schema."""
     connection = op.get_bind()
 
-    # Check existing indexes
-    index_result = connection.execute(
-        sa.text("SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='config'")
-    )
-    existing_index_names = [row[0] for row in index_result.fetchall()]
-
-    # Check existing columns
-    column_result = connection.execute(sa.text("PRAGMA table_info(config)"))
-    existing_columns = [row[1] for row in column_result.fetchall()]
-
-    # Drop indexes and constraints outside of batch mode to avoid type inference issues
-    # Drop unique constraint (stored as unique index in SQLite)
-    if "uq_config_user_team_key" in existing_index_names:
-        connection.execute(sa.text("DROP INDEX IF EXISTS uq_config_user_team_key"))
+    # Drop unique constraint
+    try:
+        op.drop_constraint("uq_config_user_team_key", "config", type_="unique")
+    except Exception:
+        pass  # Constraint doesn't exist
 
     # Drop indexes
-    if "ix_config_team_id" in existing_index_names:
+    try:
         op.drop_index("ix_config_team_id", table_name="config")
-    if "ix_config_user_id" in existing_index_names:
+    except Exception:
+        pass
+
+    try:
         op.drop_index("ix_config_user_id", table_name="config")
-    if "ix_config_key" in existing_index_names:
+    except Exception:
+        pass
+
+    try:
         op.drop_index("ix_config_key", table_name="config")
+    except Exception:
+        pass
 
-    # Drop columns using raw SQL to avoid batch mode type inference issues
-    # SQLite doesn't support DROP COLUMN directly, so we recreate the table
-    if "team_id" in existing_columns or "user_id" in existing_columns:
-        # Create new table without user_id and team_id columns
+    # Drop columns - SQLite < 3.35.0 doesn't support DROP COLUMN, so recreate table
+    if connection.dialect.name == "sqlite":
+        # Recreate table without user_id and team_id columns for SQLite compatibility
         connection.execute(
             sa.text("""
                 CREATE TABLE config_new (
@@ -147,15 +135,24 @@ def downgrade() -> None:
                 )
             """)
         )
-        # Copy data from old table to new table (only id, key, value columns)
         connection.execute(sa.text("INSERT INTO config_new (id, key, value) SELECT id, key, value FROM config"))
-        # Drop old table (this also drops all indexes)
         connection.execute(sa.text("DROP TABLE config"))
-        # Rename new table to original name
         connection.execute(sa.text("ALTER TABLE config_new RENAME TO config"))
-        # Recreate the original unique index on key (it was dropped with the old table)
-        op.create_index("ix_config_key", "config", ["key"], unique=True)
     else:
-        # If we're not dropping columns, just recreate the unique index on key
+        # PostgreSQL and modern SQLite support DROP COLUMN
+        try:
+            op.drop_column("config", "team_id")
+        except Exception:
+            pass
+
+        try:
+            op.drop_column("config", "user_id")
+        except Exception:
+            pass
+
+    # Recreate the original unique index on key
+    try:
         op.create_index("ix_config_key", "config", ["key"], unique=True)
+    except Exception:
+        pass
     # ### end Alembic commands ###

api/alembic/versions/f278bbaa6f67_create_api_keys_table.py

@@ -11,6 +11,7 @@
 from alembic import op
 import sqlalchemy as sa
 
+from transformerlab.db.migration_utils import table_exists
 
 # revision identifiers, used by Alembic.
 revision: str = "f278bbaa6f67"
@@ -23,14 +24,7 @@ def upgrade() -> None:
     """Create api_keys table."""
     connection = op.get_bind()
 
-    # Helper function to check if table exists
-    def table_exists(table_name: str) -> bool:
-        result = connection.execute(
-            sa.text("SELECT name FROM sqlite_master WHERE type='table' AND name=:name"), {"name": table_name}
-        )
-        return result.fetchone() is not None
-
-    if not table_exists("api_keys"):
+    if not table_exists(connection, "api_keys"):
         op.create_table(
             "api_keys",
             sa.Column("id", sa.String(), nullable=False),
@@ -39,7 +33,7 @@ def table_exists(table_name: str) -> bool:
             sa.Column("user_id", sa.String(), nullable=False),
             sa.Column("team_id", sa.String(), nullable=True),
             sa.Column("name", sa.String(), nullable=True),
-            sa.Column("is_active", sa.Boolean(), nullable=False, server_default="1"),
+            sa.Column("is_active", sa.Boolean(), nullable=False, server_default=sa.text("true")),
             sa.Column("last_used_at", sa.DateTime(), nullable=True),
             sa.Column("expires_at", sa.DateTime(), nullable=True),
             sa.Column("created_at", sa.DateTime(), server_default=sa.text("(CURRENT_TIMESTAMP)"), nullable=False),