Let unread hydration respect an existing annotation

hydrate_total_unread_counts() now fills only games that do not already
carry total_unread_message_count. filter_can_join() annotates zero, so
joinable listings skip the unread query without the view re-parsing
can_join, and the joinable_only flag and lists_joinable_games() go.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016sj2eM1KW37VqohqwKViPh

Author: claude

.claude/rules/backend/models.md

@@ -57,7 +57,7 @@ A QuerySet method must earn its place by encapsulating something a caller would
 
 **Never select a "latest row per parent" with a global subquery inside a prefetch.** A `DISTINCT ON (game_id)` subquery in a `Prefetch` queryset is not correlated to the prefetched parents, so it scans every game's phases on every request. Prefetch the parent's children on the queryset, then derive the latest ones in Python once the page is known and hydrate their relations with `prefetch_related_objects()` — `GameManager.hydrate_list_phases()` is the pattern, called from the view's `paginate_queryset()`. Give the non-target rows an empty cache (`queryset.none()` issues no query) so touching them stays free.
 
-**Keep per-row correlated annotations off a paginated list queryset.** The base queryset is what filtering, ordering and the pagination `COUNT` run over, so a correlated subquery on it (per-user unread counts, for example) runs in the `COUNT` too, and a grouped ordering can run it once per joined row. Compute the value in one set-based query over the page's ids once the page is known, and attach it to every instance, zero included, so the serializer never falls back to a per-row query. `GameManager.hydrate_total_unread_counts()` is the pattern, called from `GameListView.paginate_queryset()` beside the phase hydration. Skip the query entirely when the filter already guarantees the answer, as `can_join=true` does for unread counts.
+**Keep per-row correlated annotations off a paginated list queryset.** The base queryset is what filtering, ordering and the pagination `COUNT` run over, so a correlated subquery on it (per-user unread counts, for example) runs in the `COUNT` too, and a grouped ordering can run it once per joined row. Compute the value in one set-based query over the page's ids once the page is known, and attach it to every instance, zero included, so the serializer never falls back to a per-row query. `GameManager.hydrate_total_unread_counts()` is the pattern, called from `GameListView.paginate_queryset()` beside the phase hydration. Hydration fills only instances that do not already carry the value, so a filter that guarantees the answer annotates it on the queryset and the query is skipped: `filter_can_join()` annotates zero with `with_zero_unread_counts()`. Do not re-parse filter params in the view to decide.
 
 Add an index to a live table with `AddIndexConcurrently` in a migration that sets `atomic = False`, so the deploy does not block writes while it builds.
 

service/game/models.py

@@ -236,17 +236,20 @@ def hydrate_list_phases(self, games):
             phases, current_phases, "supply_centers", SupplyCenter.objects.select_related("nation", "province")
         )
 
-    def hydrate_total_unread_counts(self, games, user, joinable_only=False):
+    def hydrate_total_unread_counts(self, games, user):
+        games_without_counts = [
+            game for game in games if not hasattr(game, "total_unread_message_count")
+        ]
         counts = {}
-        if games and user.is_authenticated and not joinable_only:
+        if games_without_counts and user.is_authenticated:
             counts = dict(
                 ChannelMessage.objects.unread_by(user)
-                .filter(channel__game__in=[game.id for game in games])
+                .filter(channel__game__in=[game.id for game in games_without_counts])
                 .order_by()
                 .values_list("channel__game")
                 .annotate(count=Count("id", distinct=True))
             )
-        for game in games:
+        for game in games_without_counts:
             game.total_unread_message_count = counts.get(game.id, 0)
 
     def hydrate_retrieve_phases(self, games):

service/game/views.py

@@ -69,17 +69,9 @@ def get_queryset(self):
     def paginate_queryset(self, queryset):
         page = super().paginate_queryset(queryset)
         Game.objects.hydrate_list_phases(page)
-        Game.objects.hydrate_total_unread_counts(
-            page,
-            self.request.user,
-            joinable_only=self.lists_joinable_games(),
-        )
+        Game.objects.hydrate_total_unread_counts(page, self.request.user)
         return page
 
-    def lists_joinable_games(self):
-        form = self.filterset_class(self.request.query_params, request=self.request).form
-        return form.is_valid() and form.cleaned_data["can_join"] is True
-
 
 class GameCreateView(generics.CreateAPIView):
     permission_classes = [permissions.IsAuthenticated]