IndexedDB: handle LinkedChunkId properly in EventCacheStore implementation

crates/matrix-sdk-common/src/linked_chunk/mod.rs

@@ -107,6 +107,7 @@ use std::{
 pub use as_vector::*;
 pub use order_tracker::OrderTracker;
 use ruma::{EventId, OwnedEventId, OwnedRoomId, RoomId};
+use serde::{Deserialize, Serialize};
 pub use updates::*;
 
 /// An identifier for a linked chunk; borrowed variant.
@@ -116,6 +117,17 @@ pub enum LinkedChunkId<'a> {
     Thread(&'a RoomId, &'a EventId),
 }
 
+impl Display for LinkedChunkId<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Room(room_id) => write!(f, "{room_id}"),
+            Self::Thread(room_id, thread_root) => {
+                write!(f, "{room_id}:thread:{thread_root}")
+            }
+        }
+    }
+}
+
 impl LinkedChunkId<'_> {
     pub fn storage_key(&self) -> impl '_ + AsRef<[u8]> {
         match self {
@@ -134,6 +146,12 @@ impl LinkedChunkId<'_> {
     }
 }
 
+impl<'a> From<&'a OwnedLinkedChunkId> for LinkedChunkId<'a> {
+    fn from(value: &'a OwnedLinkedChunkId) -> Self {
+        value.as_ref()
+    }
+}
+
 impl PartialEq<&OwnedLinkedChunkId> for LinkedChunkId<'_> {
     fn eq(&self, other: &&OwnedLinkedChunkId) -> bool {
         match (self, other) {
@@ -154,26 +172,20 @@ impl PartialEq<LinkedChunkId<'_>> for OwnedLinkedChunkId {
 }
 
 /// An identifier for a linked chunk; owned variant.
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum OwnedLinkedChunkId {
     Room(OwnedRoomId),
     Thread(OwnedRoomId, OwnedEventId),
 }
 
 impl Display for OwnedLinkedChunkId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            OwnedLinkedChunkId::Room(room_id) => write!(f, "{room_id}"),
-            OwnedLinkedChunkId::Thread(room_id, thread_root) => {
-                write!(f, "{room_id}:thread:{thread_root}")
-            }
-        }
+        self.as_ref().fmt(f)
     }
 }
 
 impl OwnedLinkedChunkId {
-    #[cfg(test)]
-    fn as_ref(&self) -> LinkedChunkId<'_> {
+    pub fn as_ref(&self) -> LinkedChunkId<'_> {
         match self {
             OwnedLinkedChunkId::Room(room_id) => LinkedChunkId::Room(room_id.as_ref()),
             OwnedLinkedChunkId::Thread(room_id, event_id) => {
@@ -190,6 +202,12 @@ impl OwnedLinkedChunkId {
     }
 }
 
+impl From<LinkedChunkId<'_>> for OwnedLinkedChunkId {
+    fn from(value: LinkedChunkId<'_>) -> Self {
+        value.to_owned()
+    }
+}
+
 /// Errors of [`LinkedChunk`].
 #[derive(thiserror::Error, Debug)]
 pub enum Error {

crates/matrix-sdk-indexeddb/src/event_cache_store/integration_tests.rs

@@ -684,98 +684,3 @@ macro_rules! indexeddb_event_cache_store_integration_tests {
         }
     };
 }
-
-// This is copied from `matrix_sdk_base::event_cache::store::integration_tests`
-// for the time being, because the IndexedDB implementation of `EventCacheStore`
-// is being completed iteratively. So, we are only bringing over the tests
-// relevant to the implemented functions. At the moment, this includes the
-// following.
-//
-// - EventCacheStore::handle_linked_chunk_updates
-// - EventCacheStore::load_all_chunks
-//
-// When all functions are implemented, we can get rid of this macro and use the
-// one from `matrix_sdk_base`.
-#[macro_export]
-macro_rules! event_cache_store_integration_tests {
-    () => {
-        mod event_cache_store_integration_tests {
-            use matrix_sdk_base::event_cache::store::{
-                EventCacheStoreIntegrationTests, IntoEventCacheStore,
-            };
-            use matrix_sdk_test::async_test;
-
-            use super::get_event_cache_store;
-
-            #[async_test]
-            async fn test_handle_updates_and_rebuild_linked_chunk() {
-                let event_cache_store =
-                    get_event_cache_store().await.unwrap().into_event_cache_store();
-                event_cache_store.test_handle_updates_and_rebuild_linked_chunk().await;
-            }
-
-            #[async_test]
-            async fn test_linked_chunk_incremental_loading() {
-                let event_cache_store =
-                    get_event_cache_store().await.unwrap().into_event_cache_store();
-                event_cache_store.test_linked_chunk_incremental_loading().await;
-            }
-
-            #[async_test]
-            async fn test_rebuild_empty_linked_chunk() {
-                let event_cache_store =
-                    get_event_cache_store().await.unwrap().into_event_cache_store();
-                event_cache_store.test_rebuild_empty_linked_chunk().await;
-            }
-
-            #[async_test]
-            async fn test_load_all_chunks_metadata() {
-                let event_cache_store =
-                    get_event_cache_store().await.unwrap().into_event_cache_store();
-                event_cache_store.test_load_all_chunks_metadata().await;
-            }
-
-            #[async_test]
-            async fn test_clear_all_linked_chunks() {
-                let event_cache_store =
-                    get_event_cache_store().await.unwrap().into_event_cache_store();
-                event_cache_store.test_clear_all_linked_chunks().await;
-            }
-
-            #[async_test]
-            async fn test_remove_room() {
-                let event_cache_store =
-                    get_event_cache_store().await.unwrap().into_event_cache_store();
-                event_cache_store.test_remove_room().await;
-            }
-
-            #[async_test]
-            async fn test_filter_duplicated_events() {
-                let event_cache_store =
-                    get_event_cache_store().await.unwrap().into_event_cache_store();
-                event_cache_store.test_filter_duplicated_events().await;
-            }
-
-            #[async_test]
-            async fn test_find_event() {
-                let event_cache_store =
-                    get_event_cache_store().await.unwrap().into_event_cache_store();
-                event_cache_store.test_find_event().await;
-            }
-
-            #[async_test]
-            async fn test_find_event_relations() {
-                let event_cache_store =
-                    get_event_cache_store().await.unwrap().into_event_cache_store();
-                event_cache_store.test_find_event_relations().await;
-            }
-
-            #[async_test]
-            async fn test_save_event() {
-                let event_cache_store =
-                    get_event_cache_store().await.unwrap().into_event_cache_store();
-                event_cache_store.test_save_event().await;
-            }
-        }
-    };
-}

crates/matrix-sdk-indexeddb/src/event_cache_store/migrations.rs

@@ -112,12 +112,15 @@ pub mod v1 {
         pub const LEASES: &str = "leases";
         pub const LEASES_KEY_PATH: &str = "id";
         pub const ROOMS: &str = "rooms";
+        pub const LINKED_CHUNK_IDS: &str = "linked_chunk_ids";
         pub const LINKED_CHUNKS: &str = "linked_chunks";
         pub const LINKED_CHUNKS_KEY_PATH: &str = "id";
         pub const LINKED_CHUNKS_NEXT: &str = "linked_chunks_next";
         pub const LINKED_CHUNKS_NEXT_KEY_PATH: &str = "next";
         pub const EVENTS: &str = "events";
         pub const EVENTS_KEY_PATH: &str = "id";
+        pub const EVENTS_ROOM: &str = "events_room";
+        pub const EVENTS_ROOM_KEY_PATH: &str = "room";
         pub const EVENTS_POSITION: &str = "events_position";
         pub const EVENTS_POSITION_KEY_PATH: &str = "position";
         pub const EVENTS_RELATION: &str = "events_relation";
@@ -169,6 +172,7 @@ pub mod v1 {
     /// Create an object store for tracking information about events.
     ///
     /// * Primary Key - `id`
+    /// * Index (unique) - `room` - tracks whether an event is in a given room
     /// * Index (unique) - `position` - tracks position of an event in linked
     ///   chunks
     /// * Index - `relation` - tracks any event to which the given event is
@@ -178,6 +182,14 @@ pub mod v1 {
         object_store_params.key_path(Some(&keys::EVENTS_KEY_PATH.into()));
         let events = db.create_object_store_with_params(keys::EVENTS, &object_store_params)?;
 
+        let events_room_params = IdbIndexParameters::new();
+        events_room_params.set_unique(true);
+        events.create_index_with_params(
+            keys::EVENTS_ROOM,
+            &keys::EVENTS_ROOM_KEY_PATH.into(),
+            &events_room_params,
+        );
+
         let events_position_params = IdbIndexParameters::new();
         events_position_params.set_unique(true);
         events.create_index_with_params(