Implement stale detection by comparing modified_gmt timestamps

When fetching metadata, compare the API's `modified_gmt` against cached
posts in the database. Posts with different timestamps are marked as
`Stale`, triggering a re-fetch on the next sync.

Changes:
- Add `select_modified_gmt_by_ids` to PostRepository for efficient batch lookup
- Add `detect_and_mark_stale_posts` to PostService for staleness comparison
- Call staleness detection in `fetch_and_store_metadata` after storing metadata

Author: oguzkocer

wp_mobile/src/service/posts.rs

@@ -199,6 +199,11 @@ impl PostService {
     /// - If `is_first_page` is true, replaces existing metadata for `kv_key`
     /// - If `is_first_page` is false, appends to existing metadata
     ///
+    /// Additionally performs staleness detection:
+    /// - For posts currently marked as `Cached`, compares the fetched `modified_gmt`
+    ///   against the cached value in the database
+    /// - Posts with different `modified_gmt` are marked as `Stale`
+    ///
     /// Used by `MetadataFetcher` implementations to both fetch and store
     /// in one operation.
     ///
@@ -229,9 +234,64 @@ impl PostService {
             self.metadata_store.append(kv_key, result.metadata.clone());
         }
 
+        // Detect stale posts by comparing modified_gmt
+        self.detect_and_mark_stale_posts(&result.metadata);
+
         Ok(result)
     }
 
+    /// Compare fetched metadata against cached posts and mark stale ones.
+    ///
+    /// For each post that is currently `Cached`, compares the fetched `modified_gmt`
+    /// against the database value. If they differ, the post is marked as `Stale`.
+    fn detect_and_mark_stale_posts(&self, metadata: &[EntityMetadata]) {
+        // Get IDs of posts that are currently Cached (candidates for staleness check)
+        let cached_ids: Vec<i64> = metadata
+            .iter()
+            .filter(|m| {
+                matches!(
+                    self.state_store_with_edit_context.get(m.id),
+                    EntityState::Cached
+                )
+            })
+            .map(|m| m.id)
+            .collect();
+
+        if cached_ids.is_empty() {
+            return;
+        }
+
+        // Query database for cached modified_gmt values
+        let cached_timestamps = self
+            .cache
+            .execute(|conn| {
+                let repo = PostRepository::<EditContext>::new();
+                repo.select_modified_gmt_by_ids(conn, &self.db_site, &cached_ids)
+            })
+            .unwrap_or_default();
+
+        // Compare and mark stale
+        let mut stale_count = 0;
+        for m in metadata.iter().filter(|m| cached_ids.contains(&m.id)) {
+            if let Some(fetched_modified) = &m.modified_gmt {
+                if let Some(cached_modified) = cached_timestamps.get(&m.id) {
+                    if fetched_modified != cached_modified {
+                        self.state_store_with_edit_context
+                            .set(m.id, EntityState::Stale);
+                        stale_count += 1;
+                    }
+                }
+            }
+        }
+
+        if stale_count > 0 {
+            println!(
+                "[PostService] Detected {} stale post(s) via modified_gmt comparison",
+                stale_count
+            );
+        }
+    }
+
     /// Fetch full post data for specific post IDs and save to cache.
     ///
     /// This is used for selective sync - fetching only the posts that are

wp_mobile_cache/src/repository/posts.rs

@@ -20,14 +20,15 @@ use crate::{
     term_relationships::DbTermRelationship,
 };
 use rusqlite::{OptionalExtension, Row};
-use std::{marker::PhantomData, sync::Arc};
+use std::{collections::HashMap, marker::PhantomData, sync::Arc};
 use wp_api::{
     posts::{
         AnyPostWithEditContext, AnyPostWithEmbedContext, AnyPostWithViewContext,
         PostContentWithEditContext, PostContentWithViewContext, PostGuidWithEditContext,
         PostGuidWithViewContext, PostId, PostTitleWithEditContext, PostTitleWithEmbedContext,
         PostTitleWithViewContext, SparsePostExcerpt,
     },
+    prelude::WpGmtDateTime,
     taxonomies::TaxonomyType,
     terms::TermId,
 };
@@ -307,6 +308,61 @@ impl<C: PostContext> PostRepository<C> {
         }))
     }
 
+    /// Select `modified_gmt` timestamps for multiple posts by their WordPress post IDs.
+    ///
+    /// This is a lightweight query used for staleness detection - it only fetches
+    /// the `id` and `modified_gmt` columns without loading the full post data.
+    ///
+    /// Returns a HashMap mapping post IDs to their cached `modified_gmt` timestamps.
+    /// Posts not found in the cache are simply omitted from the result.
+    ///
+    /// # Arguments
+    /// * `executor` - Database connection or transaction
+    /// * `site` - The site to query posts for
+    /// * `post_ids` - WordPress post IDs to look up
+    ///
+    /// # Returns
+    /// HashMap where keys are post IDs and values are their `modified_gmt` timestamps.
+    pub fn select_modified_gmt_by_ids(
+        &self,
+        executor: &impl QueryExecutor,
+        site: &DbSite,
+        post_ids: &[i64],
+    ) -> Result<HashMap<i64, WpGmtDateTime>, SqliteDbError> {
+        if post_ids.is_empty() {
+            return Ok(HashMap::new());
+        }
+
+        let ids_str = post_ids
+            .iter()
+            .map(|id| id.to_string())
+            .collect::<Vec<_>>()
+            .join(", ");
+
+        let sql = format!(
+            "SELECT id, modified_gmt FROM {} WHERE db_site_id = ? AND id IN ({})",
+            Self::table_name(),
+            ids_str
+        );
+
+        let mut stmt = executor.prepare(&sql)?;
+        let rows = stmt.query_map([site.row_id], |row| {
+            let id: i64 = row.get(0)?;
+            let modified_gmt_str: String = row.get(1)?;
+            Ok((id, modified_gmt_str))
+        })?;
+
+        let mut result = HashMap::new();
+        for row_result in rows {
+            let (id, modified_gmt_str) = row_result.map_err(SqliteDbError::from)?;
+            if let Ok(modified_gmt) = modified_gmt_str.parse::<WpGmtDateTime>() {
+                result.insert(id, modified_gmt);
+            }
+        }
+
+        Ok(result)
+    }
+
     /// Delete a post by its EntityId for a given site.
     ///
     /// Returns the number of rows deleted (0 or 1).