Remove concurrency helpers from repository layer

Move concurrency orchestration logic out of the repository layer.
These helpers (`begin_refresh`, `begin_fetch_next_page`, `complete_sync`,
`complete_sync_with_error`) belong in a service layer since they:
- Orchestrate multiple repository operations
- Apply business rules (checking page counts, deciding state transitions)
- Return domain-specific result types

The repository now provides clean primitives that a service layer can compose:
- `get_or_create_and_increment_version` for atomic create/increment
- `update_state_by_list_metadata_id` for state changes
- `get_header`, `get_items`, etc. for reads

Author: oguzkocer

wp_mobile_cache/src/repository/list_metadata.rs

@@ -486,129 +486,6 @@ impl ListMetadataRepository {
         })
         .map_err(SqliteDbError::from)
     }
-
-    // ============================================================
-    // Concurrency Helpers
-    // ============================================================
-
-    /// Begin a refresh operation (fetch first page).
-    ///
-    /// Atomically:
-    /// 1. Creates header if needed and increments version
-    /// 2. Updates state to FetchingFirstPage
-    /// 3. Returns info needed for the fetch
-    ///
-    /// Call this before starting an API fetch for page 1.
-    pub fn begin_refresh(
-        executor: &impl QueryExecutor,
-        site: &DbSite,
-        key: &ListKey,
-    ) -> Result<RefreshInfo, SqliteDbError> {
-        log::debug!("ListMetadataRepository::begin_refresh: key={}", key);
-
-        // Get or create header and increment version in a single query
-        let header_info = Self::get_or_create_and_increment_version(executor, site, key)?;
-
-        // Update state to fetching
-        Self::update_state_by_list_metadata_id(
-            executor,
-            header_info.list_metadata_id,
-            ListState::FetchingFirstPage,
-            None,
-        )?;
-
-        Ok(RefreshInfo {
-            list_metadata_id: header_info.list_metadata_id,
-            version: header_info.version,
-            per_page: header_info.per_page,
-        })
-    }
-
-    /// Begin a load-next-page operation.
-    ///
-    /// Atomically:
-    /// 1. Gets current pagination state
-    /// 2. Checks if there are more pages to load
-    /// 3. Updates state to FetchingNextPage
-    /// 4. Returns info needed for the fetch (including version for later check)
-    ///
-    /// Returns None if already at the last page or no pages loaded yet.
-    /// Call this before starting an API fetch for page N+1.
-    pub fn begin_fetch_next_page(
-        executor: &impl QueryExecutor,
-        site: &DbSite,
-        key: &ListKey,
-    ) -> Result<Option<FetchNextPageInfo>, SqliteDbError> {
-        log::debug!("ListMetadataRepository::begin_fetch_next_page: key={}", key);
-
-        let header = match Self::get_header(executor, site, key)? {
-            Some(h) => h,
-            None => return Ok(None), // List doesn't exist
-        };
-
-        // Check if we have pages loaded and more to fetch
-        if header.current_page == 0 {
-            return Ok(None); // No pages loaded yet, need refresh first
-        }
-
-        if let Some(total_pages) = header.total_pages
-            && header.current_page >= total_pages
-        {
-            return Ok(None); // Already at last page
-        }
-
-        let next_page = header.current_page + 1;
-
-        // Update state to fetching
-        Self::update_state_by_list_metadata_id(
-            executor,
-            header.row_id,
-            ListState::FetchingNextPage,
-            None,
-        )?;
-
-        Ok(Some(FetchNextPageInfo {
-            list_metadata_id: header.row_id,
-            page: next_page,
-            version: header.version,
-            per_page: header.per_page,
-        }))
-    }
-
-    /// Complete a sync operation successfully.
-    ///
-    /// Updates state to Idle and clears any error message.
-    pub fn complete_sync(
-        executor: &impl QueryExecutor,
-        list_metadata_id: RowId,
-    ) -> Result<(), SqliteDbError> {
-        log::debug!(
-            "ListMetadataRepository::complete_sync: list_metadata_id={}",
-            list_metadata_id.0
-        );
-        Self::update_state_by_list_metadata_id(executor, list_metadata_id, ListState::Idle, None)
-    }
-
-    /// Complete a sync operation with an error.
-    ///
-    /// Updates state to Error with the provided message.
-    pub fn complete_sync_with_error(
-        executor: &impl QueryExecutor,
-        list_metadata_id: RowId,
-        error_message: &str,
-    ) -> Result<(), SqliteDbError> {
-        log::debug!(
-            "ListMetadataRepository::complete_sync_with_error: list_metadata_id={}, error={}",
-            list_metadata_id.0,
-            error_message
-        );
-        Self::update_state_by_list_metadata_id(
-            executor,
-            list_metadata_id,
-            ListState::Error,
-            Some(error_message),
-        )
-    }
 }
 
 /// Header info returned from `get_or_create_and_increment_version`.
@@ -622,30 +499,6 @@ pub struct HeaderVersionInfo {
     pub per_page: i64,
 }
 
-/// Information returned when starting a refresh operation.
-#[derive(Debug, Clone)]
-pub struct RefreshInfo {
-    /// Row ID of the list_metadata record
-    pub list_metadata_id: RowId,
-    /// New version number (for concurrency checking)
-    pub version: i64,
-    /// Items per page setting
-    pub per_page: i64,
-}
-
-/// Information returned when starting a load-next-page operation.
-#[derive(Debug, Clone)]
-pub struct FetchNextPageInfo {
-    /// Row ID of the list_metadata record
-    pub list_metadata_id: RowId,
-    /// Page number to fetch
-    pub page: i64,
-    /// Version at start (check before storing results)
-    pub version: i64,
-    /// Items per page setting
-    pub per_page: i64,
-}
-
 /// Input for creating a list metadata item.
 #[derive(Debug, Clone)]
 pub struct ListMetadataItemInput {
@@ -1228,217 +1081,4 @@ mod tests {
             assert_eq!(item.entity_id, ((i + 1) * 100) as i64);
         }
     }
-
-    // ============================================================
-    // Concurrency Helper Tests
-    // ============================================================
-
-    #[rstest]
-    fn test_begin_refresh_creates_header_and_sets_state(test_ctx: TestContext) {
-        let key = ListKey::from("edit:posts:publish");
-
-        let info = ListMetadataRepository::begin_refresh(&test_ctx.conn, &test_ctx.site, &key)
-            .expect("should succeed");
-
-        // Verify version was incremented (from 0 to 1)
-        assert_eq!(info.version, 1);
-        assert_eq!(info.per_page, 20); // default
-
-        // Verify state is FetchingFirstPage
-        let state =
-            ListMetadataRepository::get_state_by_list_key(&test_ctx.conn, &test_ctx.site, &key)
-                .expect("should succeed");
-        assert_eq!(state, ListState::FetchingFirstPage);
-    }
-
-    #[rstest]
-    fn test_begin_refresh_increments_version_each_time(test_ctx: TestContext) {
-        let key = ListKey::from("edit:posts:draft");
-
-        let info1 = ListMetadataRepository::begin_refresh(&test_ctx.conn, &test_ctx.site, &key)
-            .expect("should succeed");
-        assert_eq!(info1.version, 1);
-
-        // Complete the first refresh
-        ListMetadataRepository::complete_sync(&test_ctx.conn, info1.list_metadata_id)
-            .expect("should succeed");
-
-        let info2 = ListMetadataRepository::begin_refresh(&test_ctx.conn, &test_ctx.site, &key)
-            .expect("should succeed");
-        assert_eq!(info2.version, 2);
-    }
-
-    #[rstest]
-    fn test_begin_fetch_next_page_returns_none_for_non_existent_list(test_ctx: TestContext) {
-        let result = ListMetadataRepository::begin_fetch_next_page(
-            &test_ctx.conn,
-            &test_ctx.site,
-            &ListKey::from("nonexistent"),
-        )
-        .expect("should succeed");
-        assert!(result.is_none());
-    }
-
-    #[rstest]
-    fn test_begin_fetch_next_page_returns_none_when_no_pages_loaded(test_ctx: TestContext) {
-        let key = ListKey::from("edit:posts:publish");
-
-        // Create header but don't set current_page
-        ListMetadataRepository::get_or_create(&test_ctx.conn, &test_ctx.site, &key)
-            .expect("should succeed");
-
-        let result =
-            ListMetadataRepository::begin_fetch_next_page(&test_ctx.conn, &test_ctx.site, &key)
-                .expect("should succeed");
-        assert!(result.is_none());
-    }
-
-    #[rstest]
-    fn test_begin_fetch_next_page_returns_none_at_last_page(test_ctx: TestContext) {
-        let key = ListKey::from("edit:posts:publish");
-
-        // Set up header with current_page = total_pages
-        let update = ListMetadataHeaderUpdate {
-            total_pages: Some(3),
-            total_items: Some(60),
-            current_page: 3,
-            per_page: 20,
-        };
-        ListMetadataRepository::update_header_by_list_key(
-            &test_ctx.conn,
-            &test_ctx.site,
-            &key,
-            &update,
-        )
-        .expect("should succeed");
-
-        let result =
-            ListMetadataRepository::begin_fetch_next_page(&test_ctx.conn, &test_ctx.site, &key)
-                .expect("should succeed");
-        assert!(result.is_none());
-    }
-
-    #[rstest]
-    fn test_begin_fetch_next_page_returns_info_when_more_pages(test_ctx: TestContext) {
-        let key = ListKey::from("edit:posts:publish");
-
-        // Set up header with more pages available
-        let update = ListMetadataHeaderUpdate {
-            total_pages: Some(5),
-            total_items: Some(100),
-            current_page: 2,
-            per_page: 20,
-        };
-        ListMetadataRepository::update_header_by_list_key(
-            &test_ctx.conn,
-            &test_ctx.site,
-            &key,
-            &update,
-        )
-        .expect("should succeed");
-
-        let result =
-            ListMetadataRepository::begin_fetch_next_page(&test_ctx.conn, &test_ctx.site, &key)
-                .expect("should succeed");
-        assert!(result.is_some());
-
-        let info = result.expect("should succeed");
-        assert_eq!(info.page, 3); // next page
-        assert_eq!(info.per_page, 20);
-
-        // Verify state changed to FetchingNextPage
-        let state =
-            ListMetadataRepository::get_state_by_list_key(&test_ctx.conn, &test_ctx.site, &key)
-                .expect("should succeed");
-        assert_eq!(state, ListState::FetchingNextPage);
-    }
-
-    #[rstest]
-    fn test_complete_sync_sets_state_to_idle(test_ctx: TestContext) {
-        let key = ListKey::from("edit:posts:publish");
-
-        let info = ListMetadataRepository::begin_refresh(&test_ctx.conn, &test_ctx.site, &key)
-            .expect("should succeed");
-        ListMetadataRepository::complete_sync(&test_ctx.conn, info.list_metadata_id)
-            .expect("should succeed");
-
-        let state =
-            ListMetadataRepository::get_state_by_list_key(&test_ctx.conn, &test_ctx.site, &key)
-                .expect("should succeed");
-        assert_eq!(state, ListState::Idle);
-    }
-
-    #[rstest]
-    fn test_complete_sync_with_error_sets_state_and_message(test_ctx: TestContext) {
-        let key = ListKey::from("edit:posts:publish");
-
-        let info = ListMetadataRepository::begin_refresh(&test_ctx.conn, &test_ctx.site, &key)
-            .expect("should succeed");
-        ListMetadataRepository::complete_sync_with_error(
-            &test_ctx.conn,
-            info.list_metadata_id,
-            "Network timeout",
-        )
-        .expect("should succeed");
-
-        let state_record = ListMetadataRepository::get_state_by_list_metadata_id(
-            &test_ctx.conn,
-            info.list_metadata_id,
-        )
-        .expect("query should succeed")
-        .expect("should succeed");
-        assert_eq!(state_record.state, ListState::Error);
-        assert_eq!(
-            state_record.error_message.as_deref(),
-            Some("Network timeout")
-        );
-    }
-
-    #[rstest]
-    fn test_version_check_detects_stale_operation(test_ctx: TestContext) {
-        let key = ListKey::from("edit:posts:publish");
-
-        // Start a refresh (version becomes 1)
-        let refresh_info =
-            ListMetadataRepository::begin_refresh(&test_ctx.conn, &test_ctx.site, &key)
-                .expect("should succeed");
-        assert_eq!(refresh_info.version, 1);
-
-        // Update header to simulate page 1 loaded
-        let update = ListMetadataHeaderUpdate {
-            total_pages: Some(5),
-            total_items: Some(100),
-            current_page: 1,
-            per_page: 20,
-        };
-        ListMetadataRepository::update_header_by_list_key(
-            &test_ctx.conn,
-            &test_ctx.site,
-            &key,
-            &update,
-        )
-        .expect("should succeed");
-        ListMetadataRepository::complete_sync(&test_ctx.conn, refresh_info.list_metadata_id)
-            .expect("should succeed");
-
-        // Start load-next-page (captures version = 1)
-        let next_page_info =
-            ListMetadataRepository::begin_fetch_next_page(&test_ctx.conn, &test_ctx.site, &key)
-                .expect("query should succeed")
-                .expect("should succeed");
-        let captured_version = next_page_info.version;
-
-        // Another refresh happens (version becomes 2)
-        ListMetadataRepository::begin_refresh(&test_ctx.conn, &test_ctx.site, &key)
-            .expect("should succeed");
-
-        // Version check should fail (stale)
-        let current_version =
-            ListMetadataRepository::get_version(&test_ctx.conn, &test_ctx.site, &key)
-                .expect("should succeed");
-        assert_ne!(
-            current_version, captured_version,
-            "Version should not match after refresh"
-        );
-    }
 }