[arenabuddy] Add automatic match sync from server on login and startup (#318)

This pull request implements automatic match synchronization from the server to the local database. 

**Key Changes:**

- **Post-login sync**: After successful authentication, the app now automatically syncs matches from the server in the background
- **Initial sync on startup**: When the app launches with saved authentication, it performs an initial sync to fetch any new matches
- **New sync module**: Added `backend/sync.rs` with `sync_matches()` function that compares server and local match lists, downloading missing matches with proper token refresh handling
- **Match filtering**: Added filter to exclude matches with game_number ≤ 0 from the UI display
- **Logging improvements**: Changed missing match details from error to debug level, and added comprehensive sync logging

The sync process fetches the server's match list, compares against local matches by ID, and downloads any missing match data. Token refresh is handled automatically during sync operations.

Author: gazure

.sqlx/query-24fb9ee1dbc43a016bbbd2828600f4682ca81e22156533d2859eb469a4f924f7.json

@@ -6,7 +6,7 @@ use crate::{
         debug_logs::DebugLogs, draft_details::DraftDetails, drafts::Drafts, error_logs::ErrorLogs,
         match_details::MatchDetails, matches::Matches, stats::Stats,
     },
-    backend::{BackgroundRuntime, SharedAuthState},
+    backend::{BackgroundRuntime, Service, SharedAuthState},
 };
 
 fn open_github() {
@@ -98,12 +98,15 @@ fn Layout() -> Element {
     });
 
     let bg_runtime = use_context::<BackgroundRuntime>();
+    let service = use_context::<Service>();
     let on_login = {
         let auth_state = auth_state.clone();
         let bg_runtime = bg_runtime.clone();
+        let service = service.clone();
         move |_| {
             let auth_state = auth_state.clone();
             let bg = bg_runtime.clone();
+            let service = service.clone();
             spawn(async move {
                 let grpc_url = crate::backend::paths::grpc_url();
                 let client_id =
@@ -123,6 +126,16 @@ fn Layout() -> Element {
                         let username = state.user.username.clone();
                         *auth_state.lock().await = Some(state);
                         login_status.set(Some(username));
+
+                        // Sync matches from server after login
+                        let sync_db = service.db.clone();
+                        let sync_auth = auth_state.clone();
+                        bg.spawn(async move {
+                            match crate::backend::sync::sync_matches(&sync_db, &sync_auth).await {
+                                Ok(n) => tracingx::info!("Post-login sync complete: {n} new matches"),
+                                Err(e) => tracingx::error!("Post-login sync failed: {e}"),
+                            }
+                        });
                     }
                     Ok(Err(e)) => {
                         tracingx::error!("Login failed: {e}");

arenabuddy/arenabuddy/src/app/pages.rs

@@ -9,7 +9,7 @@ use dioxus::{
 use start::AppMeta;
 use tracing_appender::rolling::{RollingFileAppender, Rotation};
 use tracingx::{
-    EnvFilter, Layer, Level, SubscriberExt, SubscriberInitExt,
+    EnvFilter, Layer, Level, SubscriberExt, SubscriberInitExt, error,
     fmt::{self, writer::MakeWriterExt},
     info,
 };
@@ -40,6 +40,16 @@ pub fn launch() -> Result<()> {
     if let Some(saved) = crate::backend::auth::load_auth() {
         info!("Restored auth session for {}", saved.user.username);
         *auth_state.blocking_lock() = Some(saved);
+
+        // Sync matches from server in background
+        let sync_db = service.db.clone();
+        let sync_auth = auth_state.clone();
+        background.spawn(async move {
+            match crate::backend::sync::sync_matches(&sync_db, &sync_auth).await {
+                Ok(n) => info!("Initial sync complete: {n} new matches"),
+                Err(e) => error!("Initial sync failed: {e}"),
+            }
+        });
     }
     let service2 = service.clone();
     let auth_state2 = auth_state.clone();

arenabuddy/arenabuddy/src/backend/launch.rs

@@ -4,6 +4,7 @@ pub(crate) mod ingest;
 mod launch;
 pub(crate) mod paths;
 mod service;
+pub(crate) mod sync;
 
 pub use auth::{SharedAuthState, new_shared_auth_state};
 pub use launch::{BackgroundRuntime, launch};

arenabuddy/arenabuddy/src/backend/mod.rs

@@ -115,6 +115,7 @@ where
                 Vec::default()
             })
             .iter()
+            .filter(|mr| mr.game_number() > 0)
             .map(|mr| {
                 GameResultDisplay::from_match_result(
                     mr,

arenabuddy/arenabuddy/src/backend/service.rs

@@ -0,0 +1,139 @@
+use std::collections::HashSet;
+
+use arenabuddy_core::{
+    models::{MTGAMatch, MatchData},
+    services::match_service::{GetMatchDataRequest, ListMatchesRequest, match_service_client::MatchServiceClient},
+};
+use arenabuddy_data::{ArenabuddyRepository, MatchDB};
+use tracingx::{error, info};
+
+use super::auth::{SharedAuthState, needs_refresh, refresh};
+
+fn attach_token<T>(request: &mut tonic::Request<T>, token: &str) {
+    let bearer = format!("Bearer {token}");
+    if let Ok(value) = bearer.parse() {
+        request.metadata_mut().insert("authorization", value);
+    }
+}
+
+async fn current_token(auth_state: &SharedAuthState, grpc_url: &str) -> Option<String> {
+    let mut guard = auth_state.lock().await;
+    let state = guard.as_ref()?;
+
+    if needs_refresh(state) {
+        info!("Access token expiring soon, refreshing for sync");
+        match refresh(grpc_url, state).await {
+            Ok(new_state) => {
+                let token = new_state.token.clone();
+                *guard = Some(new_state);
+                return Some(token);
+            }
+            Err(e) => {
+                error!("Failed to refresh token for sync: {e}");
+            }
+        }
+    }
+
+    Some(state.token.clone())
+}
+
+/// Sync matches from the server into the local database.
+///
+/// Fetches the server's match list for the authenticated user, compares
+/// against local matches, and downloads any that are missing locally.
+///
+/// Returns the number of newly synced matches.
+///
+/// # Errors
+///
+/// Returns an error if the user is not authenticated, the gRPC connection
+/// fails, or the server returns an error from `ListMatches`.
+pub async fn sync_matches(
+    db: &MatchDB,
+    auth_state: &SharedAuthState,
+) -> Result<usize, Box<dyn std::error::Error + Send + Sync>> {
+    let grpc_url = super::paths::grpc_url();
+
+    let token = current_token(auth_state, &grpc_url).await.ok_or("not authenticated")?;
+
+    let mut client = MatchServiceClient::connect(grpc_url).await?;
+
+    // Get server match list
+    let mut request = tonic::Request::new(ListMatchesRequest {});
+    attach_token(&mut request, &token);
+
+    let server_matches = client.list_matches(request).await?.into_inner().matches;
+    info!("Server has {} matches for this user", server_matches.len());
+
+    // Get local match IDs
+    let local_ids: HashSet<_> = db
+        .list_matches(None)
+        .await
+        .map_err(|e| e.to_string())?
+        .iter()
+        .map(|m| m.id().to_owned())
+        .collect();
+
+    // Find matches we're missing locally
+    let missing: Vec<_> = server_matches
+        .iter()
+        .filter(|m| !local_ids.contains(m.id.as_str()))
+        .collect();
+
+    if missing.is_empty() {
+        info!("Local database is up to date");
+        return Ok(0);
+    }
+
+    info!("Syncing {} new matches from server", missing.len());
+
+    let mut synced = 0;
+    for server_match in &missing {
+        let mut request = tonic::Request::new(GetMatchDataRequest {
+            match_id: server_match.id.clone(),
+        });
+        attach_token(&mut request, &token);
+
+        let response = match client.get_match_data(request).await {
+            Ok(r) => r.into_inner(),
+            Err(e) => {
+                error!("Failed to fetch match {}: {e}", server_match.id);
+                continue;
+            }
+        };
+
+        let Some(match_data_proto) = response.match_data else {
+            error!("Server returned empty match_data for {}", server_match.id);
+            continue;
+        };
+
+        let match_data: MatchData = match (&match_data_proto).try_into() {
+            Ok(data) => data,
+            Err(e) => {
+                error!("Failed to convert match {}: {e}", server_match.id);
+                continue;
+            }
+        };
+
+        if let Err(e) = db
+            .upsert_match_data(
+                &match_data.mtga_match,
+                &match_data.decks,
+                &match_data.mulligans,
+                &match_data.results,
+                &match_data.opponent_deck.cards,
+                &match_data.event_logs,
+                None,
+            )
+            .await
+        {
+            error!("Failed to write match {} locally: {e}", server_match.id);
+            continue;
+        }
+
+        synced += 1;
+    }
+
+    info!("Synced {synced}/{} matches from server", missing.len());
+    Ok(synced)
+}

arenabuddy/arenabuddy/src/backend/sync.rs

@@ -614,7 +614,7 @@ impl ArenabuddyRepository for PostgresMatchDB {
                 Some(MatchResult::new_match_result(row.id, row.winning_team_id)),
             ))
         } else {
-            error!("Error getting match details for match_id: {}", match_id);
+            debug!("No match-level result found for match_id: {}", match_id);
             Ok((MTGAMatch::default(), None))
         }
     }
@@ -704,7 +704,7 @@ impl ArenabuddyRepository for PostgresMatchDB {
     async fn list_match_results(&self, match_id: &str) -> Result<Vec<MatchResult>> {
         let match_id = Uuid::parse_str(match_id)?;
         let results = sqlx::query!(
-            "SELECT game_number, winning_team_id, result_scope FROM match_result WHERE match_id = $1 AND game_number > 0",
+            "SELECT game_number, winning_team_id, result_scope FROM match_result WHERE match_id = $1",
             match_id
         )
         .fetch_all(&self.pool)