Add GetDashboardV2 RPC to aggregate dashboard content

The dashboard fires ~6 separate RPCs on load (reminders, surfing/hosting
host requests, my events, community events, community discussions). Add a
single GetDashboardV2 RPC on a new Dashboard service that returns all of
them in one call, removing the per-request round-trip and interceptor
overhead.

The query logic for each section is extracted into module-level functions
(get_reminders, list_host_requests, list_my_events,
list_my_communities_discussions) that both the existing RPCs and the new
aggregator share, so there's no duplicated query/visibility logic.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: aapeliv

app/backend/src/couchers/server.py

@@ -21,6 +21,7 @@
     bugs_pb2_grpc,
     communities_pb2_grpc,
     conversations_pb2_grpc,
+    dashboard_pb2_grpc,
     discussions_pb2_grpc,
     donations_pb2_grpc,
     editor_pb2_grpc,
@@ -53,6 +54,7 @@
 from couchers.servicers.bugs import Bugs
 from couchers.servicers.communities import Communities
 from couchers.servicers.conversations import Conversations
+from couchers.servicers.dashboard import Dashboard
 from couchers.servicers.discussions import Discussions
 from couchers.servicers.donations import Donations, Stripe
 from couchers.servicers.editor import Editor
@@ -108,6 +110,7 @@ def create_main_server(port: int, start_resource_sampler: bool = False) -> grpc.
     bugs_pb2_grpc.add_BugsServicer_to_server(Bugs(), server)
     communities_pb2_grpc.add_CommunitiesServicer_to_server(Communities(), server)
     conversations_pb2_grpc.add_ConversationsServicer_to_server(Conversations(), server)
+    dashboard_pb2_grpc.add_DashboardServicer_to_server(Dashboard(), server)
     discussions_pb2_grpc.add_DiscussionsServicer_to_server(Discussions(), server)
     donations_pb2_grpc.add_DonationsServicer_to_server(Donations(), server)
     editor_pb2_grpc.add_EditorServicer_to_server(Editor(), server)

app/backend/src/couchers/servicers/account.py

@@ -159,6 +159,76 @@ def _volunteer_info_to_pb(volunteer: Volunteer, username: str) -> account_pb2.Ge
     )
 
 
+def get_reminders(context: CouchersContext, session: Session) -> account_pb2.GetRemindersRes:
+    user = session.execute(select(User).where(User.id == context.user_id)).scalar_one()
+
+    # responding to reqs comes first in desc order of when they were received
+    host_has_sent_message = select(1).where(
+        Message.conversation_id == HostRequest.conversation_id, Message.author_id == HostRequest.recipient_user_id
+    )
+    query = select(HostRequest.conversation_id, LiteUser).join(LiteUser, LiteUser.id == HostRequest.initiator_user_id)
+    query = where_users_column_visible(query, context, HostRequest.initiator_user_id)
+    query = where_moderated_content_visible(query, context, HostRequest, is_list_operation=True)
+    pending_host_requests = session.execute(
+        query.where(HostRequest.recipient_user_id == context.user_id)
+        .where(HostRequest.status == HostRequestStatus.pending)
+        .where(HostRequest.start_time > func.now())
+        .where(~exists(host_has_sent_message))
+        .order_by(HostRequest.conversation_id.asc())
+    ).all()
+    reminders = [
+        account_pb2.Reminder(
+            respond_to_host_request_reminder=account_pb2.RespondToHostRequestReminder(
+                host_request_id=host_request_id,
+                surfer_user=lite_user_to_pb(session, lite_user, context),
+            )
+        )
+        for host_request_id, lite_user in pending_host_requests
+    ]
+
+    # surfer needs to confirm accepted requests
+    confirm_query = select(HostRequest.conversation_id, LiteUser).join(
+        LiteUser, LiteUser.id == HostRequest.recipient_user_id
+    )
+    confirm_query = where_users_column_visible(confirm_query, context, HostRequest.recipient_user_id)
+    confirm_query = where_moderated_content_visible(confirm_query, context, HostRequest, is_list_operation=True)
+    accepted_host_requests = session.execute(
+        confirm_query.where(HostRequest.initiator_user_id == context.user_id)
+        .where(HostRequest.status == HostRequestStatus.accepted)
+        .where(HostRequest.end_time > func.now())
+        .order_by(HostRequest.end_time.asc())
+    ).all()
+    reminders += [
+        account_pb2.Reminder(
+            confirm_host_request_reminder=account_pb2.ConfirmHostRequestReminder(
+                host_request_id=host_request_id,
+                host_user=lite_user_to_pb(session, lite_user, context),
+            )
+        )
+        for host_request_id, lite_user in accepted_host_requests
+    ]
+
+    # references come second, in order of deadline, desc
+    reminders += [
+        account_pb2.Reminder(
+            write_reference_reminder=account_pb2.WriteReferenceReminder(
+                host_request_id=host_request_id,
+                reference_type=reftype2api[reference_type],
+                other_user=lite_user_to_pb(session, lite_user, context),
+            )
+        )
+        for host_request_id, reference_type, _, lite_user in get_pending_references_to_write(session, context)
+    ]
+
+    if not has_completed_profile(session, user):
+        reminders.append(account_pb2.Reminder(complete_profile_reminder=account_pb2.CompleteProfileReminder()))
+
+    if user.hosting_status in (HostingStatus.can_host, HostingStatus.maybe) and not user.has_completed_my_home:
+        reminders.append(account_pb2.Reminder(complete_my_home_reminder=account_pb2.CompleteMyHomeReminder()))
+
+    return account_pb2.GetRemindersRes(reminders=reminders)
+
+
 class Account(account_pb2_grpc.AccountServicer):
     def GetAccountInfo(
         self, request: empty_pb2.Empty, context: CouchersContext, session: Session
@@ -747,75 +817,7 @@ def ListInviteCodes(
     def GetReminders(
         self, request: empty_pb2.Empty, context: CouchersContext, session: Session
     ) -> account_pb2.GetRemindersRes:
-        user = session.execute(select(User).where(User.id == context.user_id)).scalar_one()
-
-        # responding to reqs comes first in desc order of when they were received
-        host_has_sent_message = select(1).where(
-            Message.conversation_id == HostRequest.conversation_id, Message.author_id == HostRequest.recipient_user_id
-        )
-        query = select(HostRequest.conversation_id, LiteUser).join(
-            LiteUser, LiteUser.id == HostRequest.initiator_user_id
-        )
-        query = where_users_column_visible(query, context, HostRequest.initiator_user_id)
-        query = where_moderated_content_visible(query, context, HostRequest, is_list_operation=True)
-        pending_host_requests = session.execute(
-            query.where(HostRequest.recipient_user_id == context.user_id)
-            .where(HostRequest.status == HostRequestStatus.pending)
-            .where(HostRequest.start_time > func.now())
-            .where(~exists(host_has_sent_message))
-            .order_by(HostRequest.conversation_id.asc())
-        ).all()
-        reminders = [
-            account_pb2.Reminder(
-                respond_to_host_request_reminder=account_pb2.RespondToHostRequestReminder(
-                    host_request_id=host_request_id,
-                    surfer_user=lite_user_to_pb(session, lite_user, context),
-                )
-            )
-            for host_request_id, lite_user in pending_host_requests
-        ]
-
-        # surfer needs to confirm accepted requests
-        confirm_query = select(HostRequest.conversation_id, LiteUser).join(
-            LiteUser, LiteUser.id == HostRequest.recipient_user_id
-        )
-        confirm_query = where_users_column_visible(confirm_query, context, HostRequest.recipient_user_id)
-        confirm_query = where_moderated_content_visible(confirm_query, context, HostRequest, is_list_operation=True)
-        accepted_host_requests = session.execute(
-            confirm_query.where(HostRequest.initiator_user_id == context.user_id)
-            .where(HostRequest.status == HostRequestStatus.accepted)
-            .where(HostRequest.end_time > func.now())
-            .order_by(HostRequest.end_time.asc())
-        ).all()
-        reminders += [
-            account_pb2.Reminder(
-                confirm_host_request_reminder=account_pb2.ConfirmHostRequestReminder(
-                    host_request_id=host_request_id,
-                    host_user=lite_user_to_pb(session, lite_user, context),
-                )
-            )
-            for host_request_id, lite_user in accepted_host_requests
-        ]
-
-        # references come second, in order of deadline, desc
-        reminders += [
-            account_pb2.Reminder(
-                write_reference_reminder=account_pb2.WriteReferenceReminder(
-                    host_request_id=host_request_id,
-                    reference_type=reftype2api[reference_type],
-                    other_user=lite_user_to_pb(session, lite_user, context),
-                )
-            )
-            for host_request_id, reference_type, _, lite_user in get_pending_references_to_write(session, context)
-        ]
-
-        if not has_completed_profile(session, user):
-            reminders.append(account_pb2.Reminder(complete_profile_reminder=account_pb2.CompleteProfileReminder()))
-
-        if user.hosting_status in (HostingStatus.can_host, HostingStatus.maybe) and not user.has_completed_my_home:
-            reminders.append(account_pb2.Reminder(complete_my_home_reminder=account_pb2.CompleteMyHomeReminder()))
-
-        return account_pb2.GetRemindersRes(reminders=reminders)
+        return get_reminders(context, session)
 
     def GetMyVolunteerInfo(
         self, request: empty_pb2.Empty, context: CouchersContext, session: Session

app/backend/src/couchers/servicers/dashboard.py

@@ -0,0 +1,71 @@
+from sqlalchemy.orm import Session
+
+from couchers.context import CouchersContext
+from couchers.proto import (
+    conversations_pb2,
+    dashboard_pb2,
+    dashboard_pb2_grpc,
+    discussions_pb2,
+    events_pb2,
+    requests_pb2,
+)
+from couchers.servicers.account import get_reminders
+from couchers.servicers.discussions import list_my_communities_discussions
+from couchers.servicers.events import list_my_events
+from couchers.servicers.requests import list_host_requests
+
+# the dashboard shows a small preview of each section
+DASHBOARD_PAGE_SIZE = 3
+
+UPCOMING_STATUSES = [
+    conversations_pb2.HOST_REQUEST_STATUS_ACCEPTED,
+    conversations_pb2.HOST_REQUEST_STATUS_CONFIRMED,
+]
+
+
+class Dashboard(dashboard_pb2_grpc.DashboardServicer):
+    def GetDashboardV2(
+        self, request: dashboard_pb2.GetDashboardV2Req, context: CouchersContext, session: Session
+    ) -> dashboard_pb2.GetDashboardV2Res:
+        return dashboard_pb2.GetDashboardV2Res(
+            reminders=get_reminders(context, session),
+            surfing=list_host_requests(
+                requests_pb2.ListHostRequestsReq(
+                    only_sent=True,
+                    only_active=True,
+                    status_in=UPCOMING_STATUSES,
+                    sort_by=requests_pb2.HOST_REQUEST_SORT_BY_FROM_DATE,
+                ),
+                context,
+                session,
+            ),
+            hosting=list_host_requests(
+                requests_pb2.ListHostRequestsReq(
+                    only_received=True,
+                    only_active=True,
+                    status_in=UPCOMING_STATUSES,
+                    sort_by=requests_pb2.HOST_REQUEST_SORT_BY_FROM_DATE,
+                ),
+                context,
+                session,
+            ),
+            my_events=list_my_events(
+                events_pb2.ListMyEventsReq(page_size=DASHBOARD_PAGE_SIZE),
+                context,
+                session,
+            ),
+            community_events=list_my_events(
+                events_pb2.ListMyEventsReq(
+                    page_size=DASHBOARD_PAGE_SIZE,
+                    my_communities=True,
+                    my_communities_exclude_global=True,
+                ),
+                context,
+                session,
+            ),
+            discussions=list_my_communities_discussions(
+                discussions_pb2.ListMyCommunitiesDiscussionsReq(page_size=DASHBOARD_PAGE_SIZE),
+                context,
+                session,
+            ),
+        )

app/backend/src/couchers/servicers/discussions.py

@@ -91,6 +91,39 @@ def generate_create_discussion_notifications(payload: jobs_pb2.GenerateCreateDis
             )
 
 
+def list_my_communities_discussions(
+    request: discussions_pb2.ListMyCommunitiesDiscussionsReq, context: CouchersContext, session: Session
+) -> discussions_pb2.ListMyCommunitiesDiscussionsRes:
+    page_size = min(MAX_PAGE_SIZE, request.page_size or MAX_PAGE_SIZE)
+    next_page_id = int(request.page_token) if request.page_token else 2**63 - 1
+
+    discussions = (
+        session.execute(
+            where_moderated_content_visible(
+                select(Discussion)
+                .join(Cluster, Cluster.id == Discussion.owner_cluster_id)
+                .join(ClusterSubscription, ClusterSubscription.cluster_id == Cluster.id)
+                .where(ClusterSubscription.user_id == context.user_id)
+                .where(Cluster.is_official_cluster)
+                .where(Cluster.small_community_features_enabled)
+                .where(Discussion.id <= next_page_id)
+                .order_by(Discussion.id.desc())
+                .limit(page_size + 1),
+                context,
+                Discussion,
+                is_list_operation=True,
+            )
+        )
+        .scalars()
+        .all()
+    )
+
+    return discussions_pb2.ListMyCommunitiesDiscussionsRes(
+        discussions=[discussion_to_pb(session, d, context) for d in discussions[:page_size]],
+        next_page_token=str(discussions[-1].id) if len(discussions) > page_size else None,
+    )
+
+
 class Discussions(discussions_pb2_grpc.DiscussionsServicer):
     def CreateDiscussion(
         self, request: discussions_pb2.CreateDiscussionReq, context: CouchersContext, session: Session
@@ -285,31 +318,4 @@ def DeleteDiscussion(
     def ListMyCommunitiesDiscussions(
         self, request: discussions_pb2.ListMyCommunitiesDiscussionsReq, context: CouchersContext, session: Session
     ) -> discussions_pb2.ListMyCommunitiesDiscussionsRes:
-        page_size = min(MAX_PAGE_SIZE, request.page_size or MAX_PAGE_SIZE)
-        next_page_id = int(request.page_token) if request.page_token else 2**63 - 1
-
-        discussions = (
-            session.execute(
-                where_moderated_content_visible(
-                    select(Discussion)
-                    .join(Cluster, Cluster.id == Discussion.owner_cluster_id)
-                    .join(ClusterSubscription, ClusterSubscription.cluster_id == Cluster.id)
-                    .where(ClusterSubscription.user_id == context.user_id)
-                    .where(Cluster.is_official_cluster)
-                    .where(Cluster.small_community_features_enabled)
-                    .where(Discussion.id <= next_page_id)
-                    .order_by(Discussion.id.desc())
-                    .limit(page_size + 1),
-                    context,
-                    Discussion,
-                    is_list_operation=True,
-                )
-            )
-            .scalars()
-            .all()
-        )
-
-        return discussions_pb2.ListMyCommunitiesDiscussionsRes(
-            discussions=[discussion_to_pb(session, d, context) for d in discussions[:page_size]],
-            next_page_token=str(discussions[-1].id) if len(discussions) > page_size else None,
-        )
+        return list_my_communities_discussions(request, context, session)