feat(base): Add get_room_events to EventCacheStore trait and impls.

Author: Shrey Patel

crates/matrix-sdk-base/src/event_cache/store/integration_tests.rs

@@ -141,6 +141,9 @@ pub trait EventCacheStoreIntegrationTests {
     /// Test that finding event relations works as expected.
     async fn test_find_event_relations(&self);
 
+    /// Test that getting all events in a room works as expected.
+    async fn test_get_room_events(&self);
+
     /// Test that saving an event works as expected.
     async fn test_save_event(&self);
 
@@ -919,6 +922,61 @@ impl EventCacheStoreIntegrationTests for DynEventCacheStore {
         );
     }
 
+    async fn test_get_room_events(&self) {
+        let room_id = room_id!("!r0:matrix.org");
+        let another_room_id = room_id!("!r1:matrix.org");
+        let linked_chunk_id = LinkedChunkId::Room(room_id);
+        let another_linked_chunk_id = LinkedChunkId::Room(another_room_id);
+        let event = |msg: &str| make_test_event(room_id, msg);
+
+        let event_comte = event("comté");
+        let event_gruyere = event("gruyère");
+        let event_stilton = event("stilton");
+
+        // Add one event in one room.
+        self.handle_linked_chunk_updates(
+            linked_chunk_id,
+            vec![
+                Update::NewItemsChunk { previous: None, new: CId::new(0), next: None },
+                Update::PushItems {
+                    at: Position::new(CId::new(0), 0),
+                    items: vec![event_comte.clone(), event_gruyere.clone()],
+                },
+            ],
+        )
+        .await
+        .unwrap();
+
+        // Add an event in a different room.
+        self.handle_linked_chunk_updates(
+            another_linked_chunk_id,
+            vec![
+                Update::NewItemsChunk { previous: None, new: CId::new(0), next: None },
+                Update::PushItems {
+                    at: Position::new(CId::new(0), 0),
+                    items: vec![event_stilton.clone()],
+                },
+            ],
+        )
+        .await
+        .unwrap();
+
+        // Now let's find the events.
+        let events = self.get_room_events(room_id).await.expect("failed to query for room events");
+
+        assert_eq!(events.len(), 2);
+
+        let got_ids: Vec<_> = events.into_iter().map(|ev| ev.event_id()).collect();
+        let expected_ids = vec![event_comte.event_id(), event_gruyere.event_id()];
+
+        for expected in expected_ids {
+            assert!(
+                got_ids.contains(&expected),
+                "Expected event {expected:?} not in got events: {got_ids:?}."
+            );
+        }
+    }
+
     async fn test_save_event(&self) {
         let room_id = room_id!("!r0:matrix.org");
         let another_room_id = room_id!("!r1:matrix.org");
@@ -1199,6 +1257,13 @@ macro_rules! event_cache_store_integration_tests {
                 event_cache_store.test_find_event_relations().await;
             }
 
+            #[async_test]
+            async fn test_get_room_events() {
+                let event_cache_store =
+                    get_event_cache_store().await.unwrap().into_event_cache_store();
+                event_cache_store.test_get_room_events().await;
+            }
+
             #[async_test]
             async fn test_save_event() {
                 let event_cache_store =

crates/matrix-sdk-base/src/event_cache/store/memory_store.rs

@@ -220,6 +220,15 @@ impl EventCacheStore for MemoryStore {
         Ok(related_events)
     }
 
+    async fn get_room_events(&self, room_id: &RoomId) -> Result<Vec<Event>, Self::Error> {
+        let inner = self.inner.read().unwrap();
+
+        let event: Vec<_> =
+            inner.events.items(room_id).map(|(event, _pos)| event.clone()).collect();
+
+        Ok(event)
+    }
+
     async fn save_event(&self, room_id: &RoomId, event: Event) -> Result<(), Self::Error> {
         if event.event_id().is_none() {
             error!(%room_id, "Trying to save an event with no ID");

crates/matrix-sdk-base/src/event_cache/store/traits.rs

@@ -154,6 +154,12 @@ pub trait EventCacheStore: AsyncTraitDeps {
         filter: Option<&[RelationType]>,
     ) -> Result<Vec<(Event, Option<Position>)>, Self::Error>;
 
+    /// Get all events in this room.
+    ///
+    /// This method must return events saved either in any linked chunks, *or*
+    /// events saved "out-of-band" with the [`Self::save_event`] method.
+    async fn get_room_events(&self, room_id: &RoomId) -> Result<Vec<Event>, Self::Error>;
+
     /// Save an event, that might or might not be part of an existing linked
     /// chunk.
     ///
@@ -258,6 +264,10 @@ impl<T: EventCacheStore> EventCacheStore for EraseEventCacheStoreError<T> {
         self.0.find_event_relations(room_id, event_id, filter).await.map_err(Into::into)
     }
 
+    async fn get_room_events(&self, room_id: &RoomId) -> Result<Vec<Event>, Self::Error> {
+        self.0.get_room_events(room_id).await.map_err(Into::into)
+    }
+
     async fn save_event(&self, room_id: &RoomId, event: Event) -> Result<(), Self::Error> {
         self.0.save_event(room_id, event).await.map_err(Into::into)
     }

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

@@ -469,6 +469,21 @@ impl EventCacheStore for IndexeddbEventCacheStore {
         Ok(related_events)
     }
 
+    #[instrument(skip(self))]
+    async fn get_room_events(
+        &self,
+        room_id: &RoomId,
+    ) -> Result<Vec<Event>, IndexeddbEventCacheStoreError> {
+        let _timer = timer!("method");
+
+        let transaction = self.transaction(&[keys::EVENTS], IdbTransactionMode::Readonly)?;
+        transaction
+            .get_room_events(room_id)
+            .await
+            .map(|vec| vec.into_iter().map(Into::into).collect())
+            .map_err(Into::into)
+    }
+
     #[instrument(skip(self, event))]
     async fn save_event(
         &self,

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

@@ -32,7 +32,7 @@ use crate::event_cache_store::{
         types::{
             IndexedChunkIdKey, IndexedEventIdKey, IndexedEventPositionKey, IndexedEventRelationKey,
             IndexedEventRoomKey, IndexedGapIdKey, IndexedKeyRange, IndexedLeaseIdKey,
-            IndexedNextChunkIdKey,
+            IndexedNextChunkIdKey, IndexedRoomId,
         },
         IndexeddbEventCacheStoreSerializer,
     },
@@ -677,6 +677,15 @@ impl<'a> IndexeddbEventCacheStoreTransaction<'a> {
         self.get_item_by_key::<Event, IndexedEventRoomKey>(key).await
     }
 
+    /// Query IndexedDB for events that are in the given
+    /// room.
+    pub async fn get_room_events(
+        &self,
+        room_id: &RoomId,
+    ) -> Result<Vec<Event>, IndexeddbEventCacheStoreTransactionError> {
+        self.get_items_in_room::<Event, IndexedEventRoomKey>(room_id).await
+    }
+
     /// Query IndexedDB for events in the given position range matching the
     /// given linked chunk id.
     pub async fn get_events_by_position(

crates/matrix-sdk-sqlite/src/event_cache_store.rs

@@ -1282,6 +1282,32 @@ impl EventCacheStore for SqliteEventCacheStore {
             .await
     }
 
+    #[instrument(skip(self))]
+    async fn get_room_events(&self, room_id: &RoomId) -> Result<Vec<Event>, Self::Error> {
+        let _timer = timer!("method");
+
+        let this = self.clone();
+
+        let hashed_room_id = self.encode_key(keys::LINKED_CHUNKS, room_id);
+
+        self.read()
+            .await?
+            .with_transaction(move |txn| -> Result<_> {
+                let mut statement = txn.prepare("SELECT content FROM events WHERE room_id = ?")?;
+                let maybe_events =
+                    statement.query_map((hashed_room_id,), |row| row.get::<_, Vec<u8>>(0))?;
+
+                let mut events = Vec::new();
+                for ev in maybe_events {
+                    let event = serde_json::from_slice(&this.decode_value(&ev?)?)?;
+                    events.push(event);
+                }
+
+                Ok(events)
+            })
+            .await
+    }
+
     #[instrument(skip(self, event))]
     async fn save_event(&self, room_id: &RoomId, event: Event) -> Result<(), Self::Error> {
         let _timer = timer!("method");