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 find or not.
+    async fn test_find_event(&self);
 }
 
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
@@ -797,6 +800,61 @@ impl EventCacheStoreIntegrationTests for DynEventCacheStore {
         assert_eq!(duplicated_events[1], event_morbier.event_id().unwrap());
         assert_eq!(duplicated_events[2], event_mont_dor.event_id().unwrap());
     }
+
+    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
@@ -893,6 +951,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

@@ -21,15 +21,15 @@ use std::{
 use async_trait::async_trait;
 use matrix_sdk_common::{
     linked_chunk::{
-        relational::RelationalLinkedChunk, ChunkIdentifier, ChunkIdentifierGenerator, RawChunk,
-        Update,
+        relational::RelationalLinkedChunk, ChunkIdentifier, ChunkIdentifierGenerator, Position,
+        RawChunk, Update,
     },
     ring_buffer::RingBuffer,
     store_locks::memory_store_helper::try_take_leased_lock,
 };
 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 in inner.events.unordered_events(room_id) {
+        for event 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

@@ -16,10 +16,10 @@ use std::{fmt, sync::Arc};
 
 use async_trait::async_trait;
 use matrix_sdk_common::{
-    linked_chunk::{ChunkIdentifier, ChunkIdentifierGenerator, RawChunk, Update},
+    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>, 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>(&'a self, room_id: &'a RoomId) -> impl Iterator<Item = &'a Item> {
+    pub fn unordered_items<'a>(&'a self, room_id: &'a RoomId) -> impl Iterator<Item = &'a Item> {
         self.items.iter().filter_map(move |item_row| {
             if item_row.room_id == room_id {
                 match &item_row.item {
@@ -307,6 +307,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>
@@ -1128,7 +1139,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');
         assert_eq!(*events.next().unwrap(), 'b');

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

@@ -29,7 +29,9 @@ use matrix_sdk_base::{
         },
         Event, Gap,
     },
-    linked_chunk::{ChunkContent, ChunkIdentifier, ChunkIdentifierGenerator, RawChunk, Update},
+    linked_chunk::{
+        ChunkContent, ChunkIdentifier, ChunkIdentifierGenerator, Position, RawChunk, Update,
+    },
     media::{MediaRequestParameters, UniqueKey},
 };
 use matrix_sdk_store_encryption::StoreCipher;
@@ -846,6 +848,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,