Rationalize account names as always lowercase and add display name field (#559)

Author: petebachant

backend/app/alembic/versions/af024967630d_lowercase_account_names.py

@@ -0,0 +1,65 @@
+"""Lowercase account names and add display_name
+
+Revision ID: af024967630d
+Revises: c1f9a3e27d48
+Create Date: 2026-04-15 12:00:00.000000
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+revision = "af024967630d"
+down_revision = "c1f9a3e27d48"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    op.add_column(
+        "account",
+        sa.Column("display_name", sa.String(length=64), nullable=True),
+    )
+    conn = op.get_bind()
+    collisions = conn.execute(
+        sa.text(
+            "SELECT lower(name) AS lname, array_agg(name) AS names "
+            "FROM account GROUP BY lower(name) HAVING count(*) > 1"
+        )
+    ).fetchall()
+    if collisions:
+        raise RuntimeError(
+            "Cannot lowercase account.name: case-insensitive collisions "
+            f"exist: {collisions}. Resolve these rows before re-running."
+        )
+    # For org accounts, pull the nicely-cased display_name from the org row
+    # (account.name was already lowercased on org creation). For user accounts,
+    # the existing account.name preserves whatever casing the user signed up
+    # with.
+    conn.execute(
+        sa.text(
+            "UPDATE account SET display_name = COALESCE("
+            "(SELECT display_name FROM org WHERE org.id = account.org_id), "
+            "name) "
+            "WHERE display_name IS NULL"
+        )
+    )
+    conn.execute(sa.text("UPDATE account SET name = lower(name)"))
+    op.create_check_constraint(
+        "ck_account_name_lowercase", "account", "name = lower(name)"
+    )
+    op.drop_column("org", "display_name")
+
+
+def downgrade():
+    op.add_column(
+        "org",
+        sa.Column("display_name", sa.String(length=255), nullable=True),
+    )
+    op.execute(
+        "UPDATE org SET display_name = account.display_name "
+        "FROM account WHERE account.org_id = org.id"
+    )
+    op.alter_column("org", "display_name", nullable=False)
+    op.drop_constraint("ck_account_name_lowercase", "account", type_="check")
+    op.drop_column("account", "display_name")

backend/app/api/routes/accounts.py

@@ -51,9 +51,5 @@ def get_account(
                     role = org_membership.role_name
                     break
     account_dict["role"] = role
-    # Determine display name
-    if account.org is not None:
-        account_dict["display_name"] = account.org.display_name
-    else:
-        account_dict["display_name"] = account.name
+    account_dict["display_name"] = account.display_name or account.name
     return AccountPublic.model_validate(account_dict)

backend/app/api/routes/misc.py

@@ -119,7 +119,9 @@ def post_discount_code(
     created_for_account_id = None
     if req.created_for_account_name is not None:
         account = session.exec(
-            select(Account).where(Account.name == req.created_for_account_name)
+            select(Account).where(
+                Account.name == req.created_for_account_name.lower()
+            )
         ).first()
         if account is None:
             raise HTTPException(400, "Account does not exist")
@@ -310,12 +312,7 @@ def global_search(
     org_results = session.exec(
         select(Org)
         .join(Account, Account.org_id == Org.id)  # type: ignore
-        .where(
-            or_(
-                Account.name.ilike(pattern),  # type: ignore
-                Org.display_name.ilike(pattern),  # type: ignore
-            )
-        )
+        .where(Account.name.ilike(pattern))  # type: ignore
         .limit(limit)
     ).all()
     for o in org_results:

backend/app/api/routes/orgs.py

@@ -84,14 +84,27 @@ def get_orgs(
     search_for: str | None = None,
 ) -> OrgsResponse:
     """Get a list of orgs."""
-    query = select(Org).offset(offset).limit(limit).order_by(Org.display_name)
+    query = (
+        select(Org)
+        .join(Account, Account.org_id == Org.id)  # type: ignore
+        .offset(offset)
+        .limit(limit)
+        .order_by(Account.display_name)
+    )
     if search_for is not None:
         search_for = f"%{search_for}%"
-        query = query.where(Org.display_name.ilike(search_for))
+        query = query.where(Account.display_name.ilike(search_for))
     orgs = session.exec(query).all()
-    count_query = select(func.count()).select_from(Org)
+    count_query = (
+        select(func.count())
+        .select_from(Org)
+        .join(
+            Account,
+            Account.org_id == Org.id,  # type: ignore
+        )
+    )
     if search_for is not None:
-        count_query = count_query.where(Org.display_name.ilike(search_for))
+        count_query = count_query.where(Account.display_name.ilike(search_for))
     count = session.exec(count_query).one()
     resp = []
     for org in orgs:
@@ -176,8 +189,11 @@ def post_org(
             400, "Cannot detect display name; one must be provided"
         )
     org = Org(
-        display_name=display_name,
-        account=Account(name=org_name, github_name=req.github_name),
+        account=Account(
+            name=org_name,
+            display_name=display_name,
+            github_name=req.github_name,
+        ),
         user_memberships=[
             UserOrgMembership(user=current_user, role_id=ROLE_IDS["owner"])
         ],

backend/app/api/routes/projects/core.py

@@ -172,7 +172,7 @@ def get_projects(
     if owner_name is not None:
         where_clause = and_(
             where_clause,
-            Project.owner_account.has(Account.name == owner_name),  # type: ignore
+            Project.owner_account.has(Account.name == owner_name.lower()),  # type: ignore
         )
     if search_for is not None:
         search_for = f"%{search_for}%"
@@ -315,7 +315,7 @@ def post_project(
     # is private
     if not project_in.git_repo_exists and not project_in.is_public:
         logger.info(f"Checking private project count for {owner_name}")
-        if current_user.account.name == owner_name:
+        if current_user.account.name == owner_name.lower():
             # Count private projects for user
             account_id = current_user.account.id
             subscription = current_user.subscription

backend/app/models/core.py

@@ -19,6 +19,7 @@
 class Account(SQLModel, table=True):
     id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
     name: str = Field(min_length=2, max_length=64, unique=True)
+    display_name: str | None = Field(default=None, max_length=64)
     created: datetime = Field(
         default_factory=utcnow,
         sa_column_kwargs=dict(
@@ -241,14 +242,18 @@ class UsersPublic(SQLModel):
 
 class Org(SQLModel, table=True):
     id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
-    display_name: str = Field(min_length=2, max_length=255)
     # Relationships
     account: Account = Relationship(back_populates="org")
     user_memberships: list["UserOrgMembership"] = Relationship(
         back_populates="org"
     )
     subscription: "OrgSubscription" = Relationship(back_populates="org")
 
+    @computed_field
+    @property
+    def display_name(self) -> str:
+        return self.account.display_name or self.account.name
+
     @computed_field
     @property
     def github_name(self) -> str:
@@ -488,6 +493,11 @@ class Project(ProjectBase, table=True):
     def owner_account_name(self) -> str:
         return self.owner_account.name
 
+    @computed_field
+    @property
+    def owner_account_display_name(self) -> str:
+        return self.owner_account.display_name or self.owner_account.name
+
     @computed_field
     @property
     def owner_account_type(self) -> str:
@@ -530,6 +540,7 @@ class ProjectPublic(ProjectBase):
     id: uuid.UUID
     owner_account_id: uuid.UUID
     owner_account_name: str
+    owner_account_display_name: str
     owner_account_type: str
     current_user_access: Literal["read", "write", "admin", "owner"] | None = (
         None

backend/app/projects.py

@@ -34,6 +34,7 @@ def _yaml_load(data: bytes | str):
 from app.dvc import get_data_fpath_for_md5
 from app.git import get_ck_info_from_repo, get_zip_path_map_from_repo
 from app.models import (
+    Account,
     ContentsItem,
     Figure,
     ItemLock,

backend/app/tests/test_projects.py

@@ -78,6 +78,49 @@ def test_get_project_case_insensitive(db: Session) -> None:
     db.commit()
 
 
+def test_get_project_with_caps_in_account_name(db: Session) -> None:
+    from app import users
+    from app.models import UserCreate
+
+    suffix = uuid.uuid4().hex[:8]
+    account_name = f"CapsUser-{suffix}"
+    caps_user = users.create_user(
+        session=db,
+        user_create=UserCreate(
+            email=f"{account_name}@example.com",
+            password="CapsPassword123",
+            account_name=account_name,
+            github_username=account_name,
+        ),
+    )
+    project = Project(
+        name="caps-project",
+        title="Caps Project",
+        git_repo_url=f"https://github.com/{account_name}/caps-project",
+        owner_account_id=caps_user.account.id,
+    )
+    db.add(project)
+    db.commit()
+    try:
+        # The stored name is lowercased; display_name preserves original casing.
+        assert caps_user.account.name == account_name.lower()
+        assert caps_user.account.display_name == account_name
+        found = app.projects.get_project(
+            session=db, owner_name=account_name, project_name="caps-project"
+        )
+        assert found.owner_account.display_name == account_name
+        found_lower = app.projects.get_project(
+            session=db,
+            owner_name=account_name.lower(),
+            project_name="caps-project",
+        )
+        assert found_lower.id == found.id
+    finally:
+        db.delete(project)
+        db.delete(caps_user)
+        db.commit()
+
+
 def test_get_contents_from_repo_at_given_ref(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:

backend/app/users.py

@@ -121,14 +121,20 @@ def create_user(*, session: Session, user_create: UserCreate) -> User:
     if not account_name:
         account_name = user_create.email.split("@")[0]
     github_name = user_create.github_username or account_name
-    if account_name in INVALID_ACCOUNT_NAMES:
+    if account_name.lower() in INVALID_ACCOUNT_NAMES:
         raise HTTPException(422, "Invalid account name")
+    existing = session.exec(
+        select(Account).where(Account.name == account_name.lower())
+    ).first()
+    if existing is not None:
+        raise HTTPException(422, "Account name is already taken")
     user = User.model_validate(
         user_create,
         update={
             "hashed_password": get_password_hash(user_create.password),
             "account": Account(
-                name=account_name,
+                name=account_name.lower(),
+                display_name=account_name,
                 github_name=github_name,
             ),  # type: ignore
         },

frontend/src/client/models.ts

@@ -701,6 +701,7 @@ export type ProjectOptionalExtended = {
   id: string
   owner_account_id: string
   owner_account_name: string
+  owner_account_display_name: string
   owner_account_type: string
   current_user_access?: "read" | "write" | "admin" | "owner" | null
   calkit_info_keys?: Array<string> | null
@@ -744,6 +745,7 @@ export type ProjectPublic = {
   id: string
   owner_account_id: string
   owner_account_name: string
+  owner_account_display_name: string
   owner_account_type: string
   current_user_access?: "read" | "write" | "admin" | "owner" | null
 }