feat(indexeddb): add IndexedDB-backed impl for EventCacheStore::find_event_relations

Signed-off-by: Michael Goldenberg <[email protected]>

Author: mgoldenberg

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

@@ -763,6 +763,13 @@ macro_rules! event_cache_store_integration_tests {
                 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 =

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

@@ -480,10 +480,32 @@ impl_event_cache_store! {
         filters: Option<&[RelationType]>,
     ) -> Result<Vec<(Event, Option<Position>)>, IndexeddbEventCacheStoreError> {
         let _timer = timer!("method");
-        self.memory_store
-            .find_event_relations(room_id, event_id, filters)
-            .await
-            .map_err(IndexeddbEventCacheStoreError::MemoryStore)
+
+        let transaction =
+            self.transaction(&[keys::EVENTS], IdbTransactionMode::Readonly)?;
+
+        let mut related_events = Vec::new();
+        match filters {
+            Some(relation_types) if !relation_types.is_empty() => {
+                for relation_type in relation_types {
+                    let relation = (event_id.to_owned(), relation_type.clone());
+                    let events = transaction.get_events_by_relation(room_id, &relation).await?;
+                    for event in events {
+                        let position = event.position().map(Into::into);
+                        related_events.push((event.into(), position));
+                    }
+                }
+            }
+            _ => {
+                for event in
+                    transaction.get_events_by_related_event(room_id, &event_id.to_owned()).await?
+                {
+                    let position = event.position().map(Into::into);
+                    related_events.push((event.into(), position));
+                }
+            }
+        }
+        Ok(related_events)
     }
 
     #[instrument(skip(self, event))]

crates/matrix-sdk-indexeddb/src/event_cache_store/serializer/types.rs

@@ -417,6 +417,23 @@ pub type IndexedEventPositionIndex = usize;
 #[derive(Debug, Serialize, Deserialize)]
 pub struct IndexedEventRelationKey(IndexedRoomId, IndexedEventId, IndexedRelationType);
 
+impl IndexedEventRelationKey {
+    /// Returns an identical key, but with the related event field updated to
+    /// the given related event. This is helpful when searching for all
+    /// events which are related to the given event.
+    pub fn with_related_event_id(
+        &self,
+        related_event_id: &OwnedEventId,
+        serializer: &IndexeddbSerializer,
+    ) -> Self {
+        let room_id = self.0.clone();
+        let related_event_id =
+            serializer.encode_key_as_string(keys::EVENTS_RELATION_RELATED_EVENTS, related_event_id);
+        let relation_type = self.2.clone();
+        Self(room_id, related_event_id, relation_type)
+    }
+}
+
 impl IndexedKey<Event> for IndexedEventRelationKey {
     const INDEX: Option<&'static str> = Some(keys::EVENTS_RELATION);
 

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

@@ -631,6 +631,32 @@ impl<'a> IndexeddbEventCacheStoreTransaction<'a> {
         self.get_events_count_by_position(room_id, range).await
     }
 
+    /// Query IndexedDB for events that match the given relation range in the
+    /// given room.
+    pub async fn get_events_by_relation(
+        &self,
+        room_id: &RoomId,
+        range: impl Into<IndexedKeyRange<&(OwnedEventId, RelationType)>>,
+    ) -> Result<Vec<Event>, IndexeddbEventCacheStoreTransactionError> {
+        let range = range.into().encoded(room_id, self.serializer.inner());
+        self.get_items_by_key::<Event, IndexedEventRelationKey>(room_id, range).await
+    }
+
+    /// Query IndexedDB for events that are related to the given event in the
+    /// given room.
+    pub async fn get_events_by_related_event(
+        &self,
+        room_id: &RoomId,
+        related_event_id: &OwnedEventId,
+    ) -> Result<Vec<Event>, IndexeddbEventCacheStoreTransactionError> {
+        let lower = IndexedEventRelationKey::lower_key(room_id, self.serializer.inner())
+            .with_related_event_id(related_event_id, self.serializer.inner());
+        let upper = IndexedEventRelationKey::upper_key(room_id, self.serializer.inner())
+            .with_related_event_id(related_event_id, self.serializer.inner());
+        let range = IndexedKeyRange::Bound(lower, upper);
+        self.get_items_by_key::<Event, IndexedEventRelationKey>(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(