IndexedDB: Add IndexedDB implementation of LinkedChunk-related functions in EventCacheStore

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

@@ -502,6 +502,59 @@ pub async fn test_load_last_chunk(store: IndexeddbEventCacheStore) {
     assert_eq!(chunk_identifier_generator.current(), 42);
 }
 
+pub async fn test_load_previous_chunk(store: IndexeddbEventCacheStore) {
+    let room_id = &DEFAULT_TEST_ROOM_ID;
+    let linked_chunk_id = LinkedChunkId::Room(room_id);
+    let event = |msg: &str| make_test_event(room_id, msg);
+
+    // Case #1: no chunk at all, equivalent to having an nonexistent
+    // `before_chunk_identifier`.
+    let previous_chunk =
+        store.load_previous_chunk(linked_chunk_id, ChunkIdentifier::new(153)).await.unwrap();
+    assert!(previous_chunk.is_none());
+
+    // Case #2: there is one chunk only: we request the previous on this
+    // one, it doesn't exist.
+    let updates =
+        vec![Update::NewItemsChunk { previous: None, new: ChunkIdentifier::new(42), next: None }];
+    store.handle_linked_chunk_updates(linked_chunk_id, updates).await.unwrap();
+
+    let previous_chunk =
+        store.load_previous_chunk(linked_chunk_id, ChunkIdentifier::new(42)).await.unwrap();
+    assert!(previous_chunk.is_none());
+
+    // Case #3: there are two chunks.
+    let updates = vec![
+        // new chunk before the one that exists.
+        Update::NewItemsChunk {
+            previous: None,
+            new: ChunkIdentifier::new(7),
+            next: Some(ChunkIdentifier::new(42)),
+        },
+        Update::PushItems {
+            at: Position::new(ChunkIdentifier::new(7), 0),
+            items: vec![event("brigand du jorat"), event("morbier")],
+        },
+    ];
+    store.handle_linked_chunk_updates(linked_chunk_id, updates).await.unwrap();
+
+    let previous_chunk =
+        store.load_previous_chunk(linked_chunk_id, ChunkIdentifier::new(42)).await.unwrap();
+
+    assert_matches!(previous_chunk, Some(previous_chunk) => {
+        assert_eq!(previous_chunk.identifier, 7);
+        assert!(previous_chunk.previous.is_none());
+        assert_matches!(previous_chunk.next, Some(next) => {
+            assert_eq!(next, 42);
+        });
+        assert_matches!(previous_chunk.content, ChunkContent::Items(items) => {
+            assert_eq!(items.len(), 2);
+            check_test_event(&items[0], "brigand du jorat");
+            check_test_event(&items[1], "morbier");
+        });
+    });
+}
+
 /// Macro for generating tests for IndexedDB implementation of
 /// [`EventCacheStore`]
 ///
@@ -621,6 +674,13 @@ macro_rules! indexeddb_event_cache_store_integration_tests {
                 $crate::event_cache_store::integration_tests::test_load_last_chunk(store)
                     .await
             }
+
+            #[async_test]
+            async fn test_load_previous_chunk() {
+                let store = get_event_cache_store().await.expect("Failed to get event cache store");
+                $crate::event_cache_store::integration_tests::test_load_previous_chunk(store)
+                    .await
+            }
         }
     };
 }
@@ -654,13 +714,34 @@ macro_rules! event_cache_store_integration_tests {
                 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 =

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

@@ -287,10 +287,27 @@ impl_event_cache_store! {
         &self,
         linked_chunk_id: LinkedChunkId<'_>,
     ) -> Result<Vec<ChunkMetadata>, IndexeddbEventCacheStoreError> {
-        self.memory_store
-            .load_all_chunks_metadata(linked_chunk_id)
-            .await
-            .map_err(IndexeddbEventCacheStoreError::MemoryStore)
+        let linked_chunk_id = linked_chunk_id.to_owned();
+        let room_id = linked_chunk_id.room_id();
+
+        let transaction = self.transaction(
+            &[keys::LINKED_CHUNKS, keys::EVENTS, keys::GAPS],
+            IdbTransactionMode::Readwrite,
+        )?;
+
+        let mut raw_chunks = Vec::new();
+        let chunks = transaction.get_chunks_in_room(room_id).await?;
+        for chunk in chunks {
+            let chunk_id = ChunkIdentifier::new(chunk.identifier);
+            let num_items = transaction.get_events_count_by_chunk(room_id, &chunk_id).await?;
+            raw_chunks.push(ChunkMetadata {
+                num_items,
+                previous: chunk.previous.map(ChunkIdentifier::new),
+                identifier: ChunkIdentifier::new(chunk.identifier),
+                next: chunk.next.map(ChunkIdentifier::new),
+            });
+        }
+        Ok(raw_chunks)
     }
 
     async fn load_last_chunk(
@@ -353,17 +370,31 @@ impl_event_cache_store! {
         linked_chunk_id: LinkedChunkId<'_>,
         before_chunk_identifier: ChunkIdentifier,
     ) -> Result<Option<RawChunk<Event, Gap>>, IndexeddbEventCacheStoreError> {
-        self.memory_store
-            .load_previous_chunk(linked_chunk_id, before_chunk_identifier)
-            .await
-            .map_err(IndexeddbEventCacheStoreError::MemoryStore)
+        let linked_chunk_id = linked_chunk_id.to_owned();
+        let room_id = linked_chunk_id.room_id();
+        let transaction = self.transaction(
+            &[keys::LINKED_CHUNKS, keys::EVENTS, keys::GAPS],
+            IdbTransactionMode::Readonly,
+        )?;
+        if let Some(chunk) = transaction.get_chunk_by_id(room_id, &before_chunk_identifier).await? {
+            if let Some(previous_identifier) = chunk.previous {
+                let previous_identifier = ChunkIdentifier::new(previous_identifier);
+                return Ok(transaction.load_chunk_by_id(room_id, &previous_identifier).await?);
+            }
+        }
+        Ok(None)
     }
 
     async fn clear_all_linked_chunks(&self) -> Result<(), IndexeddbEventCacheStoreError> {
-        self.memory_store
-            .clear_all_linked_chunks()
-            .await
-            .map_err(IndexeddbEventCacheStoreError::MemoryStore)
+        let transaction = self.transaction(
+            &[keys::LINKED_CHUNKS, keys::EVENTS, keys::GAPS],
+            IdbTransactionMode::Readwrite,
+        )?;
+        transaction.clear::<types::Chunk>().await?;
+        transaction.clear::<types::Event>().await?;
+        transaction.clear::<types::Gap>().await?;
+        transaction.commit().await?;
+        Ok(())
     }
 
     async fn filter_duplicated_events(

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

@@ -580,6 +580,17 @@ impl<'a> IndexeddbEventCacheStoreTransaction<'a> {
         self.get_items_by_key_components::<Event, IndexedEventPositionKey>(room_id, range).await
     }
 
+    /// Query IndexedDB for number of events in the given position range in the
+    /// given room.
+    pub async fn get_events_count_by_position(
+        &self,
+        room_id: &RoomId,
+        range: impl Into<IndexedKeyRange<&Position>>,
+    ) -> Result<usize, IndexeddbEventCacheStoreTransactionError> {
+        self.get_items_count_by_key_components::<Event, IndexedEventPositionKey>(room_id, range)
+            .await
+    }
+
     /// Query IndexedDB for events in the given chunk in the given room.
     pub async fn get_events_by_chunk(
         &self,
@@ -594,6 +605,21 @@ impl<'a> IndexeddbEventCacheStoreTransaction<'a> {
         self.get_events_by_position(room_id, range).await
     }
 
+    /// Query IndexedDB for number of events in the given chunk in the given
+    /// room.
+    pub async fn get_events_count_by_chunk(
+        &self,
+        room_id: &RoomId,
+        chunk_id: &ChunkIdentifier,
+    ) -> Result<usize, IndexeddbEventCacheStoreTransactionError> {
+        let mut lower = IndexedEventPositionKey::lower_key_components();
+        lower.chunk_identifier = chunk_id.index();
+        let mut upper = IndexedEventPositionKey::upper_key_components();
+        upper.chunk_identifier = chunk_id.index();
+        let range = IndexedKeyRange::Bound(&lower, &upper);
+        self.get_events_count_by_position(room_id, range).await
+    }
+
     /// Puts an event in the given room. If an event with the same key already
     /// exists, it will be overwritten.
     pub async fn put_event(