feat(base): Add EventCacheStore::find_event.

This patch adds the method `find_event` on the `EventCacheStore` trait.
It helps to find a single event from the store.

Author: Hywan

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

@@ -127,6 +127,9 @@ pub trait EventCacheStoreIntegrationTests {
 
     /// Test that filtering duplicated events works as expected.
     async fn test_filter_duplicated_events(&self);
+
+    /// Test that an event can be found or not.
+    async fn test_find_event(&self);
 }
 
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -806,6 +809,61 @@ impl EventCacheStoreIntegrationTests for DynEventCacheStore {
             (event_mont_dor.event_id().unwrap(), Position::new(CId::new(2), 1))
         );
     }
+
+    async fn test_find_event(&self) {
+        let room_id = room_id!("!r0:matrix.org");
+        let another_room_id = room_id!("!r1:matrix.org");
+        let event = |msg: &str| make_test_event(room_id, msg);
+
+        let event_comte = event("comté");
+        let event_gruyere = event("gruyère");
+
+        // Add one event in one room.
+        self.handle_linked_chunk_updates(
+            room_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()],
+                },
+            ],
+        )
+        .await
+        .unwrap();
+
+        // Add another event in another room.
+        self.handle_linked_chunk_updates(
+            another_room_id,
+            vec![
+                Update::NewItemsChunk { previous: None, new: CId::new(0), next: None },
+                Update::PushItems {
+                    at: Position::new(CId::new(0), 0),
+                    items: vec![event_gruyere.clone()],
+                },
+            ],
+        )
+        .await
+        .unwrap();
+
+        // Now let's find out the event.
+        let (position, event) = self
+            .find_event(room_id, event_comte.event_id().unwrap().as_ref())
+            .await
+            .expect("failed to query for finding an event")
+            .expect("failed to find an event");
+
+        assert_eq!(position.chunk_identifier(), 0);
+        assert_eq!(position.index(), 0);
+        assert_eq!(event.event_id(), event_comte.event_id());
+
+        // Now let's try to find an event that exists, but not in the expected room.
+        assert!(self
+            .find_event(room_id, event_gruyere.event_id().unwrap().as_ref())
+            .await
+            .expect("failed to query for finding an event")
+            .is_none());
+    }
 }
 
 /// Macro building to allow your `EventCacheStore` implementation to run the
@@ -902,6 +960,13 @@ macro_rules! event_cache_store_integration_tests {
                     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;
+            }
         }
     };
 }

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

@@ -29,7 +29,7 @@ use matrix_sdk_common::{
 };
 use ruma::{
     time::{Instant, SystemTime},
-    MxcUri, OwnedEventId, OwnedMxcUri, RoomId,
+    EventId, MxcUri, OwnedEventId, OwnedMxcUri, RoomId,
 };
 
 use super::{
@@ -183,7 +183,7 @@ impl EventCacheStore for MemoryStore {
 
         let mut duplicated_events = Vec::new();
 
-        for (event, position) in inner.events.unordered_events(room_id) {
+        for (event, position) in inner.events.unordered_items(room_id) {
             // If `events` is empty, we can short-circuit.
             if events.is_empty() {
                 break;
@@ -202,6 +202,21 @@ impl EventCacheStore for MemoryStore {
         Ok(duplicated_events)
     }
 
+    async fn find_event(
+        &self,
+        room_id: &RoomId,
+        event_id: &EventId,
+    ) -> Result<Option<(Position, Event)>, Self::Error> {
+        let inner = self.inner.read().unwrap();
+
+        let event_and_room = inner.events.items().find_map(|(position, event, this_room_id)| {
+            (room_id == this_room_id && event.event_id()? == event_id)
+                .then_some((position, event.clone()))
+        });
+
+        Ok(event_and_room)
+    }
+
     async fn add_media_content(
         &self,
         request: &MediaRequestParameters,

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

@@ -19,7 +19,7 @@ use matrix_sdk_common::{
     linked_chunk::{ChunkIdentifier, ChunkIdentifierGenerator, Position, RawChunk, Update},
     AsyncTraitDeps,
 };
-use ruma::{MxcUri, OwnedEventId, RoomId};
+use ruma::{EventId, MxcUri, OwnedEventId, RoomId};
 
 use super::{
     media::{IgnoreMediaRetentionPolicy, MediaRetentionPolicy},
@@ -109,6 +109,13 @@ pub trait EventCacheStore: AsyncTraitDeps {
         events: Vec<OwnedEventId>,
     ) -> Result<Vec<(OwnedEventId, Position)>, Self::Error>;
 
+    /// Find an event by its ID.
+    async fn find_event(
+        &self,
+        room_id: &RoomId,
+        event_id: &EventId,
+    ) -> Result<Option<(Position, Event)>, Self::Error>;
+
     /// Add a media file's content in the media store.
     ///
     /// # Arguments
@@ -299,6 +306,14 @@ impl<T: EventCacheStore> EventCacheStore for EraseEventCacheStoreError<T> {
         self.0.filter_duplicated_events(room_id, events).await.map_err(Into::into)
     }
 
+    async fn find_event(
+        &self,
+        room_id: &RoomId,
+        event_id: &EventId,
+    ) -> Result<Option<(Position, Event)>, Self::Error> {
+        self.0.find_event(room_id, event_id).await.map_err(Into::into)
+    }
+
     async fn add_media_content(
         &self,
         request: &MediaRequestParameters,

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

@@ -293,9 +293,9 @@ impl<Item, Gap> RelationalLinkedChunk<Item, Gap> {
         }
     }
 
-    /// Return an iterator that yields events of a particular room with no
+    /// Return an iterator that yields items of a particular room with no
     /// particular order.
-    pub fn unordered_events<'a>(
+    pub fn unordered_items<'a>(
         &'a self,
         room_id: &'a RoomId,
     ) -> impl Iterator<Item = (&'a Item, Position)> {
@@ -310,6 +310,17 @@ impl<Item, Gap> RelationalLinkedChunk<Item, Gap> {
             }
         })
     }
+
+    /// Return an iterator over all items.
+    pub fn items(&self) -> impl Iterator<Item = (Position, &Item, &RoomId)> {
+        self.items.iter().filter_map(|item_row| {
+            if let Either::Item(item) = &item_row.item {
+                Some((item_row.position, item, item_row.room_id.as_ref()))
+            } else {
+                None
+            }
+        })
+    }
 }
 
 impl<Item, Gap> RelationalLinkedChunk<Item, Gap>
@@ -1131,7 +1142,7 @@ mod tests {
             ],
         );
 
-        let mut events = relational_linked_chunk.unordered_events(room_id);
+        let mut events = relational_linked_chunk.unordered_items(room_id);
 
         assert_eq!(events.next().unwrap(), (&'a', Position::new(CId::new(0), 0)));
         assert_eq!(events.next().unwrap(), (&'b', Position::new(CId::new(0), 1)));

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

@@ -854,6 +854,42 @@ impl EventCacheStore for SqliteEventCacheStore {
             .await
     }
 
+    async fn find_event(
+        &self,
+        room_id: &RoomId,
+        event_id: &EventId,
+    ) -> Result<Option<(Position, Event)>, Self::Error> {
+        let hashed_room_id = self.encode_key(keys::LINKED_CHUNKS, room_id);
+        let event_id = event_id.to_owned();
+        let this = self.clone();
+
+        self.acquire()
+            .await?
+            .with_transaction(move |txn| -> Result<_> {
+                let Some((chunk_identifier, index, event)) = txn
+                    .prepare(
+                        "SELECT chunk_id, position, content FROM events WHERE room_id = ? AND event_id = ?",
+                    )?
+                    .query_row((hashed_room_id, event_id.as_str(),), |row| {
+                        Ok((
+                            row.get::<_, u64>(0)?,
+                            row.get::<_, usize>(1)?,
+                            row.get::<_, Vec<u8>>(2)?,
+                        ))
+                    })
+                    .optional()?
+                else {
+                    // Event is not found.
+                    return Ok(None);
+                };
+
+                let event = serde_json::from_slice(&this.decode_value(&event)?)?;
+
+                Ok(Some((Position::new(ChunkIdentifier::new(chunk_identifier), index), event)))
+            })
+            .await
+    }
+
     async fn add_media_content(
         &self,
         request: &MediaRequestParameters,