Move reset_stale_fetching_states to ListMetadataRepository

Move `reset_stale_fetching_states_internal` from `WpApiCache` to
`ListMetadataRepository` where it belongs. The repository owns
the state table and should provide all operations on it.

`WpApiCache::perform_migrations` still calls this method after
migrations complete, but now delegates to the repository.

Author: oguzkocer

wp_mobile_cache/src/lib.rs

@@ -3,6 +3,8 @@ use rusqlite::types::{FromSql, FromSqlResult, ToSql, ToSqlOutput};
 use rusqlite::{Connection, Result as SqliteResult, params};
 use std::sync::Mutex;
 
+use crate::repository::list_metadata::ListMetadataRepository;
+
 pub mod context;
 pub mod db_types;
 pub mod entity;
@@ -277,7 +279,7 @@ impl WpApiCache {
             // Errors are logged but not propagated: this is a best-effort cleanup,
             // and failure doesn't affect core functionality (worst case: UI shows
             // stale loading state).
-            if let Err(e) = Self::reset_stale_fetching_states_internal(connection) {
+            if let Err(e) = ListMetadataRepository::reset_stale_fetching_states(connection) {
                 log::warn!("Failed to reset stale fetching states: {}", e);
             }
 
@@ -320,31 +322,6 @@ impl WpApiCache {
 }
 
 impl WpApiCache {
-    /// Resets stale fetching states (`FetchingFirstPage`, `FetchingNextPage`) to `Idle`.
-    ///
-    /// If the app terminates while a fetch is in progress, these transient states persist
-    /// in the database. On next launch, this could cause perpetual loading indicators or
-    /// blocked fetches. We reset them during `WpApiCache` initialization since it's
-    /// typically created once at app startup.
-    ///
-    /// Note: `Error` states are intentionally preserved for UI feedback and debugging.
-    fn reset_stale_fetching_states_internal(
-        connection: &mut Connection,
-    ) -> Result<usize, SqliteDbError> {
-        use crate::list_metadata::ListState;
-
-        connection
-            .execute(
-                "UPDATE list_metadata_state SET state = ?1 WHERE state IN (?2, ?3)",
-                params![
-                    ListState::Idle as i32,
-                    ListState::FetchingFirstPage as i32,
-                    ListState::FetchingNextPage as i32,
-                ],
-            )
-            .map_err(SqliteDbError::from)
-    }
-
     /// Execute a database operation with scoped access to the connection.
     ///
     /// This is the **only** way to access the database. The provided closure

wp_mobile_cache/src/repository/list_metadata.rs

@@ -486,6 +486,33 @@ impl ListMetadataRepository {
         })
         .map_err(SqliteDbError::from)
     }
+
+    /// Reset stale fetching states to Idle.
+    ///
+    /// If the app terminates while a fetch is in progress, `FetchingFirstPage` and
+    /// `FetchingNextPage` states persist in the database. On next launch, this could
+    /// cause perpetual loading indicators or blocked fetches.
+    ///
+    /// This resets those transient states to `Idle`. Error states are intentionally
+    /// preserved for UI feedback and debugging.
+    ///
+    /// Returns the number of rows updated.
+    pub fn reset_stale_fetching_states(
+        executor: &impl QueryExecutor,
+    ) -> Result<usize, SqliteDbError> {
+        let sql = format!(
+            "UPDATE {} SET state = ?1 WHERE state IN (?2, ?3)",
+            Self::state_table().table_name()
+        );
+        executor.execute(
+            &sql,
+            rusqlite::params![
+                ListState::Idle as i32,
+                ListState::FetchingFirstPage as i32,
+                ListState::FetchingNextPage as i32,
+            ],
+        )
+    }
 }
 
 /// Header info returned from `get_or_create_and_increment_version`.