sdk: handle all relationship types for events in EventCache

Author: jmartinesp

crates/matrix-sdk/src/event_cache/mod.rs

@@ -406,39 +406,47 @@ impl EventCacheInner {
             };
 
             // Handle and cache events and relations
-            let mut relations = self.relations.write().await;
             for ev in &joined_room_update.timeline.events {
                 if let Ok(AnySyncTimelineEvent::MessageLike(ev)) = ev.event.deserialize() {
                     if let Some(AnyMessageLikeEventContent::RoomMessage(c)) = ev.original_content()
                     {
-                        if let Some(Relation::Replacement(relation)) = c.relates_to {
-                            if let Some(replacements) = relations.get_mut(&relation.event_id) {
-                                replacements.insert(ev.event_id().to_owned());
-                            } else {
-                                relations.insert(
-                                    relation.event_id,
-                                    BTreeSet::from_iter(vec![ev.event_id().to_owned()]),
-                                );
+                        if let Some(relation) = c.relates_to {
+                            match relation {
+                                Relation::Replacement(replacement) => {
+                                    self.insert_or_update_relationship(
+                                        &replacement.event_id,
+                                        ev.event_id(),
+                                    )
+                                    .await;
+                                }
+                                Relation::Reply { in_reply_to } => {
+                                    self.insert_or_update_relationship(
+                                        &in_reply_to.event_id,
+                                        ev.event_id(),
+                                    )
+                                    .await;
+                                }
+                                Relation::Thread(thread) => {
+                                    self.insert_or_update_relationship(
+                                        &thread.event_id,
+                                        ev.event_id(),
+                                    )
+                                    .await;
+                                }
+                                // Do nothing for custom
+                                _ => (),
                             }
                         }
                     } else if let Some(AnyMessageLikeEventContent::RoomRedaction(c)) =
                         ev.original_content()
                     {
                         if let Some(redacted_ev_id) = c.redacts {
-                            let original_ev_id = redacted_ev_id;
-                            if let Some(replacements) = relations.get_mut(&original_ev_id) {
-                                replacements.insert(ev.event_id().to_owned());
-                            } else {
-                                relations.insert(
-                                    original_ev_id,
-                                    BTreeSet::from_iter(vec![ev.event_id().to_owned()]),
-                                );
-                            }
+                            self.insert_or_update_relationship(&redacted_ev_id, ev.event_id())
+                                .await;
                         }
                     }
                 }
             }
-            drop(relations);
 
             let mut events = self.events.write().await;
             for ev in &joined_room_update.timeline.events {
@@ -496,6 +504,18 @@ impl EventCacheInner {
             }
         }
     }
+
+    async fn insert_or_update_relationship(&self, orig_ev_id: &EventId, related_ev_id: &EventId) {
+        let mut relations = self.relations.write().await;
+
+        if let Some(replacements) = relations.get_mut(orig_ev_id) {
+            replacements.insert(related_ev_id.to_owned());
+        } else {
+            relations
+                .insert(orig_ev_id.to_owned(), BTreeSet::from_iter(vec![related_ev_id.to_owned()]));
+        }
+        drop(relations);
+    }
 }
 
 /// A subset of an event cache, for a room.