feat(event cache): include the reply count in the ThreadSummary

Author: bnjbvr

bindings/matrix-sdk-ffi/src/timeline/msg_like.rs

@@ -242,6 +242,7 @@ pub struct PollAnswer {
 #[derive(Clone, uniffi::Object)]
 pub struct ThreadSummary {
     pub latest_event: ThreadSummaryLatestEventDetails,
+    pub num_replies: usize,
 }
 
 #[matrix_sdk_ffi_macros::export]
@@ -275,6 +276,6 @@ impl From<matrix_sdk_ui::timeline::ThreadSummary> for ThreadSummary {
             }
         };
 
-        Self { latest_event }
+        Self { latest_event, num_replies: value.num_replies }
     }
 }

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

@@ -124,6 +124,11 @@ pub trait EventCacheStore: AsyncTraitDeps {
 
     /// Find all the events that relate to a given event.
     ///
+    /// Note: it doesn't process relations recursively: for instance, if
+    /// requesting only thread events, it will NOT return the aggregated
+    /// events affecting the returned events. It is the responsibility of
+    /// the caller to do so, if needed.
+    ///
     /// An additional filter can be provided to only retrieve related events for
     /// a certain relationship.
     async fn find_event_relations(

crates/matrix-sdk-common/src/deserialized_responses.rs

@@ -370,10 +370,15 @@ impl<'de> Deserialize<'de> for EncryptionInfo {
 /// - the number of replies to the thread,
 /// - the full event of the latest reply to the thread,
 /// - whether the user participated or not to this thread.
-///
-/// At the moment, it contains nothing.
 #[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct ThreadSummary {}
+pub struct ThreadSummary {
+    /// The number of replies to the thread.
+    ///
+    /// This doesn't include the thread root event itself. It can be zero if no
+    /// events in the thread are considered to be meaningful (or they've all
+    /// been redacted).
+    pub num_replies: usize,
+}
 
 /// The status of a thread summary.
 #[derive(Clone, Debug, Default, Serialize, Deserialize)]
@@ -1365,7 +1370,9 @@ mod tests {
         // When creating a timeline event from a raw event, the thread summary is always
         // extracted, if available.
         let timeline_event = TimelineEvent::new(raw);
-        assert_matches!(timeline_event.thread_summary, ThreadSummaryStatus::Some(ThreadSummary {}));
+        assert_matches!(timeline_event.thread_summary, ThreadSummaryStatus::Some(ThreadSummary { num_replies }) => {
+            assert_eq!(num_replies, 2);
+        });
 
         // When deserializing an old serialized timeline event, the thread summary is
         // also extracted, if it wasn't serialized.
@@ -1379,7 +1386,9 @@ mod tests {
 
         let timeline_event: TimelineEvent =
             serde_json::from_value(serialized_timeline_item).unwrap();
-        assert_matches!(timeline_event.thread_summary, ThreadSummaryStatus::Some(ThreadSummary {}));
+        assert_matches!(timeline_event.thread_summary, ThreadSummaryStatus::Some(ThreadSummary { num_replies }) => {
+            assert_eq!(num_replies, 2);
+        });
     }
 
     #[test]
@@ -1642,7 +1651,7 @@ mod tests {
                 )])),
             }),
             push_actions: Default::default(),
-            thread_summary: ThreadSummaryStatus::Some(ThreadSummary {}),
+            thread_summary: ThreadSummaryStatus::Some(ThreadSummary { num_replies: 2 }),
         };
 
         with_settings!({ sort_maps => true, prepend_module_to_snapshot => false }, {

crates/matrix-sdk-common/src/serde_helpers.rs

@@ -18,7 +18,7 @@
 use ruma::{
     events::{relation::BundledThread, AnySyncTimelineEvent},
     serde::Raw,
-    OwnedEventId,
+    OwnedEventId, UInt,
 };
 use serde::Deserialize;
 
@@ -77,9 +77,12 @@ struct Unsigned {
 pub fn extract_bundled_thread_summary(event: &Raw<AnySyncTimelineEvent>) -> ThreadSummaryStatus {
     match event.get_field::<Unsigned>("unsigned") {
         Ok(Some(Unsigned { relations: Some(Relations { thread: Some(bundled_thread) }) })) => {
-            // Currently, we don't do anything with the bundled thread, but later we will!
-            let _ = bundled_thread;
-            ThreadSummaryStatus::Some(ThreadSummary {})
+            // Take the count from the bundled thread summary, if available. If it can't be
+            // converted to a `u64`, we use `UInt::MAX` as a fallback, as this is unlikely
+            // to happen to have that many events in real-world threads.
+            let count = bundled_thread.count.try_into().unwrap_or(UInt::MAX.try_into().unwrap());
+
+            ThreadSummaryStatus::Some(ThreadSummary { num_replies: count })
         }
         Ok(_) => ThreadSummaryStatus::None,
         Err(_) => ThreadSummaryStatus::Unknown,

crates/matrix-sdk-common/src/snapshots/snapshot_test_sync_timeline_event.snap

@@ -46,6 +46,8 @@ expression: "serde_json::to_value(&room_event).unwrap()"
     }
   },
   "thread_summary": {
-    "Some": {}
+    "Some": {
+      "num_replies": 2
+    }
   }
 }

crates/matrix-sdk-ui/src/timeline/controller/state_transaction.rs

@@ -558,9 +558,9 @@ impl<'a> TimelineStateTransaction<'a> {
         // TODO: do something with the thread summary!
         let TimelineEvent { push_actions, kind, thread_summary } = event;
 
-        let thread_summary = thread_summary.summary().map(|_common_summary| {
-            // TODO: later, fill the latest event in the thread summary!
-            ThreadSummary { latest_event: TimelineDetails::Unavailable }
+        let thread_summary = thread_summary.summary().map(|summary| ThreadSummary {
+            latest_event: TimelineDetails::Unavailable,
+            num_replies: summary.num_replies,
         });
 
         let encryption_info = kind.encryption_info().cloned();

crates/matrix-sdk-ui/src/timeline/event_item/content/msg_like.rs

@@ -39,6 +39,15 @@ pub enum MsgLikeKind {
 #[derive(Clone, Debug)]
 pub struct ThreadSummary {
     pub latest_event: TimelineDetails<Box<ThreadSummaryLatestEvent>>,
+
+    /// The number of events in the thread, except for the thread root.
+    ///
+    /// This can be zero if all the events in the thread have been redacted.
+    ///
+    /// Note: this doesn't interact with the timeline filter; so opening a
+    /// thread-focused timeline with the same timeline filter may result in
+    /// *fewer* events than this number.
+    pub num_replies: usize,
 }
 
 #[derive(Clone, Debug)]

crates/matrix-sdk-ui/tests/integration/timeline/thread.rs

@@ -236,6 +236,7 @@ async fn test_extract_bundled_thread_summary() {
     assert_let!(Some(summary) = event_item.content().thread_summary());
     // Soon™, Stefan, soon™.
     assert!(summary.latest_event.is_unavailable());
+    assert_eq!(summary.num_replies, 42);
 
     assert_let!(VectorDiff::PushFront { value } = &timeline_updates[1]);
     assert!(value.is_date_divider());
@@ -278,8 +279,8 @@ async fn test_new_thread_reply_causes_thread_summary() {
     // When I receive a threaded reply to this event,
     let reply_event_id = event_id!("$thread_reply");
     let event = f
-        .sender(&BOB)
         .text_msg("thread reply")
+        .sender(&BOB)
         .in_thread(thread_event_id, thread_event_id)
         .event_id(reply_event_id);
 
@@ -323,4 +324,57 @@ async fn test_new_thread_reply_causes_thread_summary() {
     assert_let!(Some(summary) = event_item.content().thread_summary());
     // Soon™, Stefan, soon™.
     assert!(summary.latest_event.is_unavailable());
+    assert_eq!(summary.num_replies, 1);
+
+    assert_pending!(stream);
+
+    // A new thread reply updates the number of replies in the thread.
+    let another_reply_event_id = event_id!("$another_thread_reply");
+    server
+        .sync_room(
+            &client,
+            JoinedRoomBuilder::new(room_id).add_timeline_event(
+                f.text_msg("another thread reply")
+                    .sender(&BOB)
+                    .in_thread(thread_event_id, reply_event_id)
+                    .event_id(another_reply_event_id),
+            ),
+        )
+        .await;
+
+    assert_let_timeout!(Some(timeline_updates) = stream.next());
+    assert_eq!(timeline_updates.len(), 4);
+
+    // (Read receipt from Bob moves.)
+    assert_let!(VectorDiff::Set { index: 2, .. } = &timeline_updates[0]);
+
+    // Then we're seeing the new thread reply.
+    assert_let!(VectorDiff::PushBack { value } = &timeline_updates[1]);
+    let event_item = value.as_event().unwrap();
+    assert_eq!(event_item.event_id().unwrap(), another_reply_event_id);
+    assert!(event_item.content().thread_summary().is_none());
+    assert_eq!(event_item.content().thread_root().as_deref(), Some(thread_event_id));
+
+    // Then the first thread reply is updated with the up-to-date thread summary in
+    // the replied-to event.
+    assert_let!(VectorDiff::Set { index: 2, value } = &timeline_updates[2]);
+    let event_item = value.as_event().unwrap();
+    assert_eq!(event_item.event_id().unwrap(), reply_event_id);
+    let replied_to_details = value.as_event().unwrap().content().in_reply_to().unwrap().event;
+    assert_let!(TimelineDetails::Ready(replied_to_event) = replied_to_details);
+    // Spoiling a bit here…
+    assert_eq!(replied_to_event.content().thread_summary().unwrap().num_replies, 2);
+
+    // Then, we receive an update for the thread root itself, which now has an
+    // up-to-date thread summary.
+    assert_let!(VectorDiff::Set { index: 1, value } = &timeline_updates[3]);
+    let event_item = value.as_event().unwrap();
+    assert_eq!(event_item.event_id().unwrap(), thread_event_id);
+    assert!(event_item.content().thread_root().is_none());
+
+    assert_let!(Some(summary) = event_item.content().thread_summary());
+    // Soon™, Stefan, soon™.
+    assert!(summary.latest_event.is_unavailable());
+    // The number of replies has been updated.
+    assert_eq!(summary.num_replies, 2);
 }

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

@@ -1210,17 +1210,21 @@ mod private {
                 return Ok(());
             };
 
-            match target_event.thread_summary {
-                ThreadSummaryStatus::Unknown | ThreadSummaryStatus::None => {}
-                ThreadSummaryStatus::Some(_thread_summary) => {
-                    // The event already had a thread summary; ignore.
-                    // TODO: later, we might want to recompute the thread summary here, and cause
-                    // an update if it's changed.
-                    return Ok(());
-                }
-            }
+            // Read the latest number of thread replies from the store.
+            //
+            // Implementation note: since this is based on the `m.relates_to` field, and
+            // that field can only be present on room messages, we don't have to
+            // worry about filtering out aggregation events (like
+            // reactions/edits/etc.). Pretty neat, huh?
+            let num_replies = {
+                let store_guard = &*self.store.lock().await?;
+                let related_thread_events = store_guard
+                    .find_event_relations(&self.room, &thread_root, Some(&[RelationType::Thread]))
+                    .await?;
+                related_thread_events.len()
+            };
 
-            target_event.thread_summary = ThreadSummaryStatus::Some(ThreadSummary {});
+            target_event.thread_summary = ThreadSummaryStatus::Some(ThreadSummary { num_replies });
 
             self.replace_event_at(location, target_event).await?;