Add version groups to share routes and boss battles across games

Routes and boss battles now belong to a version_group instead of
individual games, so paired versions (e.g. Red/Blue, Gold/Silver)
share the same route structure and boss battles. Route encounters
gain a game_id column to support game-specific encounter tables
within a shared route. Includes migration, updated seeds, API
changes, and frontend type updates.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

backend/src/app/seeds/loader.py

@@ -9,27 +9,65 @@ from app.models.game import Game
 from app.models.pokemon import Pokemon
 from app.models.route import Route
 from app.models.route_encounter import RouteEncounter
+from app.models.version_group import VersionGroup
 
 
-async def upsert_games(session: AsyncSession, games: list[dict]) -> dict[str, int]:
-    """Upsert game records, return {slug: id} mapping."""
-    for game in games:
-        stmt = insert(Game).values(
-            name=game["name"],
-            slug=game["slug"],
-            generation=game["generation"],
-            region=game["region"],
-            release_year=game.get("release_year"),
-            color=game.get("color"),
+async def upsert_version_groups(
+    session: AsyncSession,
+    vg_data: dict[str, dict],
+) -> dict[str, int]:
+    """Upsert version group records, return {slug: id} mapping."""
+    for vg_slug, vg_info in vg_data.items():
+        vg_name = " / ".join(
+            g["name"].replace("Pokemon ", "")
+            for g in vg_info["games"].values()
+        )
+        stmt = insert(VersionGroup).values(
+            name=vg_name,
+            slug=vg_slug,
         ).on_conflict_do_update(
             index_elements=["slug"],
-            set_={
-                "name": game["name"],
-                "generation": game["generation"],
-                "region": game["region"],
-                "release_year": game.get("release_year"),
-                "color": game.get("color"),
-            },
+            set_={"name": vg_name},
+        )
+        await session.execute(stmt)
+
+    await session.flush()
+
+    result = await session.execute(select(VersionGroup.slug, VersionGroup.id))
+    return {row.slug: row.id for row in result}
+
+
+async def upsert_games(
+    session: AsyncSession,
+    games: list[dict],
+    slug_to_vg_id: dict[str, int] | None = None,
+) -> dict[str, int]:
+    """Upsert game records, return {slug: id} mapping."""
+    for game in games:
+        values = {
+            "name": game["name"],
+            "slug": game["slug"],
+            "generation": game["generation"],
+            "region": game["region"],
+            "release_year": game.get("release_year"),
+            "color": game.get("color"),
+        }
+        update_set = {
+            "name": game["name"],
+            "generation": game["generation"],
+            "region": game["region"],
+            "release_year": game.get("release_year"),
+            "color": game.get("color"),
+        }
+        if slug_to_vg_id is not None:
+            vg_id = slug_to_vg_id.get(game["slug"])
+            if vg_id is not None:
+                values["version_group_id"] = vg_id
+                update_set["version_group_id"] = vg_id
+
+        stmt = insert(Game).values(**values).on_conflict_do_update(
+            index_elements=["slug"],
+            set_=update_set,
         )
         await session.execute(stmt)
 
@@ -67,10 +105,10 @@ async def upsert_pokemon(session: AsyncSession, pokemon_list: list[dict]) -> dic
 
 async def upsert_routes(
     session: AsyncSession,
-    game_id: int,
+    version_group_id: int,
     routes: list[dict],
 ) -> dict[str, int]:
-    """Upsert route records for a game, return {name: id} mapping.
+    """Upsert route records for a version group, return {name: id} mapping.
 
     Handles hierarchical routes: routes with 'children' are parent routes,
     and their children get parent_route_id set accordingly.
@@ -79,11 +117,11 @@ async def upsert_routes(
     for route in routes:
         stmt = insert(Route).values(
             name=route["name"],
-            game_id=game_id,
+            version_group_id=version_group_id,
             order=route["order"],
             parent_route_id=None,  # Parent routes have no parent
         ).on_conflict_do_update(
-            constraint="uq_routes_game_name",
+            constraint="uq_routes_version_group_name",
             set_={"order": route["order"], "parent_route_id": None},
         )
         await session.execute(stmt)
@@ -92,7 +130,7 @@ async def upsert_routes(
 
     # Get mapping of parent routes
     result = await session.execute(
-        select(Route.name, Route.id).where(Route.game_id == game_id)
+        select(Route.name, Route.id).where(Route.version_group_id == version_group_id)
     )
     name_to_id = {row.name: row.id for row in result}
 
@@ -106,12 +144,12 @@ async def upsert_routes(
         for child in children:
             stmt = insert(Route).values(
                 name=child["name"],
-                game_id=game_id,
+                version_group_id=version_group_id,
                 order=child["order"],
                 parent_route_id=parent_id,
                 pinwheel_zone=child.get("pinwheel_zone"),
             ).on_conflict_do_update(
-                constraint="uq_routes_game_name",
+                constraint="uq_routes_version_group_name",
                 set_={
                     "order": child["order"],
                     "parent_route_id": parent_id,
@@ -124,7 +162,7 @@ async def upsert_routes(
 
     # Return full mapping including children
     result = await session.execute(
-        select(Route.name, Route.id).where(Route.game_id == game_id)
+        select(Route.name, Route.id).where(Route.version_group_id == version_group_id)
     )
     return {row.name: row.id for row in result}
 
@@ -134,8 +172,9 @@ async def upsert_route_encounters(
     route_id: int,
     encounters: list[dict],
     dex_to_id: dict[int, int],
+    game_id: int,
 ) -> int:
-    """Upsert encounters for a route, return count of upserted rows."""
+    """Upsert encounters for a route and game, return count of upserted rows."""
     count = 0
     for enc in encounters:
         pokemon_id = dex_to_id.get(enc["pokeapi_id"])
@@ -146,12 +185,13 @@ async def upsert_route_encounters(
         stmt = insert(RouteEncounter).values(
             route_id=route_id,
             pokemon_id=pokemon_id,
+            game_id=game_id,
             encounter_method=enc["method"],
             encounter_rate=enc["encounter_rate"],
             min_level=enc["min_level"],
             max_level=enc["max_level"],
         ).on_conflict_do_update(
-            constraint="uq_route_pokemon_method",
+            constraint="uq_route_pokemon_method_game",
             set_={
                 "encounter_rate": enc["encounter_rate"],
                 "min_level": enc["min_level"],