Add database foundation for MetadataService (Phase 1)

Implement the database layer for list metadata storage, replacing the
in-memory KV store. This enables proper observer patterns and persistence
between app launches.

Database schema (3 tables):
- list_metadata: headers with pagination, version for concurrency control
- list_metadata_items: ordered entity IDs (rowid = display order)
- list_metadata_state: sync state (idle, fetching_first_page, fetching_next_page, error)

Changes:
- Add DbTable variants: ListMetadata, ListMetadataItems, ListMetadataState
- Add migration 0007-create-list-metadata-tables.sql
- Add list_metadata module with DbListMetadata, DbListMetadataItem,
  DbListMetadataState structs and ListState enum
- Add db_types/db_list_metadata.rs with column enums and from_row impls
- Add repository/list_metadata.rs with read and write operations

Author: oguzkocer

wp_mobile_cache/migrations/0007-create-list-metadata-tables.sql

@@ -0,0 +1,44 @@
+-- Table 1: List header/pagination info
+CREATE TABLE `list_metadata` (
+  `rowid` INTEGER PRIMARY KEY AUTOINCREMENT,
+  `db_site_id` INTEGER NOT NULL,
+  `key` TEXT NOT NULL,              -- e.g., "edit:posts:publish"
+  `total_pages` INTEGER,
+  `total_items` INTEGER,
+  `current_page` INTEGER NOT NULL DEFAULT 0,
+  `per_page` INTEGER NOT NULL DEFAULT 20,
+  `last_first_page_fetched_at` TEXT,
+  `last_updated_at` TEXT,
+  `version` INTEGER NOT NULL DEFAULT 0,
+
+  FOREIGN KEY (db_site_id) REFERENCES db_sites(id) ON DELETE CASCADE
+) STRICT;
+
+CREATE UNIQUE INDEX idx_list_metadata_unique_key ON list_metadata(db_site_id, key);
+
+-- Table 2: List items (rowid = insertion order = display order)
+CREATE TABLE `list_metadata_items` (
+  `rowid` INTEGER PRIMARY KEY AUTOINCREMENT,
+  `db_site_id` INTEGER NOT NULL,
+  `key` TEXT NOT NULL,
+  `entity_id` INTEGER NOT NULL,     -- post/comment/etc ID
+  `modified_gmt` TEXT,              -- nullable for entities without it
+
+  FOREIGN KEY (db_site_id) REFERENCES db_sites(id) ON DELETE CASCADE
+) STRICT;
+
+CREATE INDEX idx_list_metadata_items_key ON list_metadata_items(db_site_id, key);
+CREATE INDEX idx_list_metadata_items_entity ON list_metadata_items(db_site_id, entity_id);
+
+-- Table 3: Sync state (FK to list_metadata, not duplicating key)
+CREATE TABLE `list_metadata_state` (
+  `rowid` INTEGER PRIMARY KEY AUTOINCREMENT,
+  `list_metadata_id` INTEGER NOT NULL,
+  `state` TEXT NOT NULL DEFAULT 'idle',  -- idle, fetching_first_page, fetching_next_page, error
+  `error_message` TEXT,
+  `updated_at` TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+
+  FOREIGN KEY (list_metadata_id) REFERENCES list_metadata(rowid) ON DELETE CASCADE
+) STRICT;
+
+CREATE UNIQUE INDEX idx_list_metadata_state_unique ON list_metadata_state(list_metadata_id);

wp_mobile_cache/src/db_types.rs

@@ -1,3 +1,4 @@
+pub mod db_list_metadata;
 pub mod db_site;
 pub mod db_term_relationship;
 pub mod helpers;

wp_mobile_cache/src/db_types/db_list_metadata.rs

@@ -0,0 +1,117 @@
+use crate::{
+    SqliteDbError,
+    db_types::row_ext::{ColumnIndex, RowExt},
+    list_metadata::{DbListMetadata, DbListMetadataItem, DbListMetadataState, ListState},
+};
+use rusqlite::Row;
+
+/// Column indexes for list_metadata table.
+/// These must match the order of columns in the CREATE TABLE statement.
+#[repr(usize)]
+#[derive(Debug, Clone, Copy)]
+pub enum ListMetadataColumn {
+    Rowid = 0,
+    DbSiteId = 1,
+    Key = 2,
+    TotalPages = 3,
+    TotalItems = 4,
+    CurrentPage = 5,
+    PerPage = 6,
+    LastFirstPageFetchedAt = 7,
+    LastUpdatedAt = 8,
+    Version = 9,
+}
+
+impl ColumnIndex for ListMetadataColumn {
+    fn as_index(&self) -> usize {
+        *self as usize
+    }
+}
+
+impl DbListMetadata {
+    /// Construct a list metadata entity from a database row.
+    pub fn from_row(row: &Row) -> Result<Self, SqliteDbError> {
+        use ListMetadataColumn as Col;
+
+        Ok(Self {
+            row_id: row.get_column(Col::Rowid)?,
+            db_site_id: row.get_column(Col::DbSiteId)?,
+            key: row.get_column(Col::Key)?,
+            total_pages: row.get_column(Col::TotalPages)?,
+            total_items: row.get_column(Col::TotalItems)?,
+            current_page: row.get_column(Col::CurrentPage)?,
+            per_page: row.get_column(Col::PerPage)?,
+            last_first_page_fetched_at: row.get_column(Col::LastFirstPageFetchedAt)?,
+            last_updated_at: row.get_column(Col::LastUpdatedAt)?,
+            version: row.get_column(Col::Version)?,
+        })
+    }
+}
+
+/// Column indexes for list_metadata_items table.
+/// These must match the order of columns in the CREATE TABLE statement.
+#[repr(usize)]
+#[derive(Debug, Clone, Copy)]
+pub enum ListMetadataItemColumn {
+    Rowid = 0,
+    DbSiteId = 1,
+    Key = 2,
+    EntityId = 3,
+    ModifiedGmt = 4,
+}
+
+impl ColumnIndex for ListMetadataItemColumn {
+    fn as_index(&self) -> usize {
+        *self as usize
+    }
+}
+
+impl DbListMetadataItem {
+    /// Construct a list metadata item from a database row.
+    pub fn from_row(row: &Row) -> Result<Self, SqliteDbError> {
+        use ListMetadataItemColumn as Col;
+
+        Ok(Self {
+            row_id: row.get_column(Col::Rowid)?,
+            db_site_id: row.get_column(Col::DbSiteId)?,
+            key: row.get_column(Col::Key)?,
+            entity_id: row.get_column(Col::EntityId)?,
+            modified_gmt: row.get_column(Col::ModifiedGmt)?,
+        })
+    }
+}
+
+/// Column indexes for list_metadata_state table.
+/// These must match the order of columns in the CREATE TABLE statement.
+#[repr(usize)]
+#[derive(Debug, Clone, Copy)]
+pub enum ListMetadataStateColumn {
+    Rowid = 0,
+    ListMetadataId = 1,
+    State = 2,
+    ErrorMessage = 3,
+    UpdatedAt = 4,
+}
+
+impl ColumnIndex for ListMetadataStateColumn {
+    fn as_index(&self) -> usize {
+        *self as usize
+    }
+}
+
+impl DbListMetadataState {
+    /// Construct a list metadata state from a database row.
+    pub fn from_row(row: &Row) -> Result<Self, SqliteDbError> {
+        use ListMetadataStateColumn as Col;
+
+        let state_str: String = row.get_column(Col::State)?;
+
+        Ok(Self {
+            row_id: row.get_column(Col::Rowid)?,
+            list_metadata_id: row.get_column(Col::ListMetadataId)?,
+            state: ListState::from(state_str),
+            error_message: row.get_column(Col::ErrorMessage)?,
+            updated_at: row.get_column(Col::UpdatedAt)?,
+        })
+    }
+}

wp_mobile_cache/src/lib.rs

@@ -6,6 +6,7 @@ use std::sync::Mutex;
 pub mod context;
 pub mod db_types;
 pub mod entity;
+pub mod list_metadata;
 pub mod repository;
 pub mod term_relationships;
 
@@ -64,6 +65,12 @@ pub enum DbTable {
     DbSites,
     /// Term relationships (post-category, post-tag associations)
     TermRelationships,
+    /// List metadata headers (pagination, version)
+    ListMetadata,
+    /// List metadata items (entity IDs with ordering)
+    ListMetadataItems,
+    /// List metadata sync state (idle, fetching, error)
+    ListMetadataState,
 }
 
 impl DbTable {
@@ -79,6 +86,9 @@ impl DbTable {
             DbTable::SelfHostedSites => "self_hosted_sites",
             DbTable::DbSites => "db_sites",
             DbTable::TermRelationships => "term_relationships",
+            DbTable::ListMetadata => "list_metadata",
+            DbTable::ListMetadataItems => "list_metadata_items",
+            DbTable::ListMetadataState => "list_metadata_state",
         }
     }
 }
@@ -107,6 +117,9 @@ impl TryFrom<&str> for DbTable {
             "self_hosted_sites" => Ok(DbTable::SelfHostedSites),
             "db_sites" => Ok(DbTable::DbSites),
             "term_relationships" => Ok(DbTable::TermRelationships),
+            "list_metadata" => Ok(DbTable::ListMetadata),
+            "list_metadata_items" => Ok(DbTable::ListMetadataItems),
+            "list_metadata_state" => Ok(DbTable::ListMetadataState),
             _ => Err(DbTableError::UnknownTable(table_name.to_string())),
         }
     }
@@ -350,13 +363,14 @@ impl From<Connection> for WpApiCache {
     }
 }
 
-static MIGRATION_QUERIES: [&str; 6] = [
+static MIGRATION_QUERIES: [&str; 7] = [
     include_str!("../migrations/0001-create-sites-table.sql"),
     include_str!("../migrations/0002-create-posts-table.sql"),
     include_str!("../migrations/0003-create-term-relationships.sql"),
     include_str!("../migrations/0004-create-posts-view-context-table.sql"),
     include_str!("../migrations/0005-create-posts-embed-context-table.sql"),
     include_str!("../migrations/0006-create-self-hosted-sites-table.sql"),
+    include_str!("../migrations/0007-create-list-metadata-tables.sql"),
 ];
 
 pub struct MigrationManager<'a> {

wp_mobile_cache/src/list_metadata.rs

@@ -0,0 +1,108 @@
+use crate::RowId;
+
+/// Represents list metadata header in the database.
+///
+/// Stores pagination info and version for a specific list (e.g., "edit:posts:publish").
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DbListMetadata {
+    /// SQLite rowid of this list metadata
+    pub row_id: RowId,
+    /// Database site ID (rowid from sites table)
+    pub db_site_id: RowId,
+    /// List key (e.g., "edit:posts:publish")
+    pub key: String,
+    /// Total number of pages from API response
+    pub total_pages: Option<i64>,
+    /// Total number of items from API response
+    pub total_items: Option<i64>,
+    /// Current page that has been loaded (0 = no pages loaded)
+    pub current_page: i64,
+    /// Items per page
+    pub per_page: i64,
+    /// ISO 8601 timestamp of when page 1 was last fetched
+    pub last_first_page_fetched_at: Option<String>,
+    /// ISO 8601 timestamp of last update
+    pub last_updated_at: Option<String>,
+    /// Version number, incremented on page 1 refresh for concurrency control
+    pub version: i64,
+}
+
+/// Represents a single item in a list metadata collection.
+///
+/// Items are ordered by rowid (insertion order = display order).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DbListMetadataItem {
+    /// SQLite rowid (determines display order)
+    pub row_id: RowId,
+    /// Database site ID
+    pub db_site_id: RowId,
+    /// List key this item belongs to
+    pub key: String,
+    /// Entity ID (post ID, comment ID, etc.)
+    pub entity_id: i64,
+    /// Last modified timestamp (for staleness detection)
+    pub modified_gmt: Option<String>,
+}
+
+/// Represents sync state for a list metadata.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DbListMetadataState {
+    /// SQLite rowid
+    pub row_id: RowId,
+    /// Foreign key to list_metadata.rowid
+    pub list_metadata_id: RowId,
+    /// Current sync state
+    pub state: ListState,
+    /// Error message if state is error
+    pub error_message: Option<String>,
+    /// ISO 8601 timestamp of last state change
+    pub updated_at: String,
+}
+
+/// Sync state for a list.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, uniffi::Enum)]
+pub enum ListState {
+    /// No sync in progress
+    #[default]
+    Idle,
+    /// Fetching first page (pull-to-refresh)
+    FetchingFirstPage,
+    /// Fetching subsequent page (load more)
+    FetchingNextPage,
+    /// Last sync failed
+    Error,
+}
+
+impl ListState {
+    /// Convert to database string representation.
+    pub fn as_db_str(&self) -> &'static str {
+        match self {
+            ListState::Idle => "idle",
+            ListState::FetchingFirstPage => "fetching_first_page",
+            ListState::FetchingNextPage => "fetching_next_page",
+            ListState::Error => "error",
+        }
+    }
+}
+
+impl From<&str> for ListState {
+    fn from(s: &str) -> Self {
+        match s {
+            "idle" => ListState::Idle,
+            "fetching_first_page" => ListState::FetchingFirstPage,
+            "fetching_next_page" => ListState::FetchingNextPage,
+            "error" => ListState::Error,
+            _ => {
+                // Default to Idle for unknown states to avoid panics
+                eprintln!("Warning: Unknown ListState '{}', defaulting to Idle", s);
+                ListState::Idle
+            }
+        }
+    }
+}
+
+impl From<String> for ListState {
+    fn from(s: String) -> Self {
+        ListState::from(s.as_str())
+    }
+}