feat(sdk): add a room method to retrieve a list of threads

Author: bnjbvr

crates/matrix-sdk/CHANGELOG.md

@@ -8,6 +8,8 @@ All notable changes to this project will be documented in this file.
 
 ### Features
 
+- `Room::list_threads()` is a new method to list all the threads in a room.
+
 ### Bug fixes
 
 ### Refactor

crates/matrix-sdk/src/room/messages.rs

@@ -17,7 +17,11 @@ use std::fmt;
 use matrix_sdk_common::{debug::DebugStructExt as _, deserialized_responses::TimelineEvent};
 use ruma::{
     api::{
-        client::{filter::RoomEventFilter, message::get_message_events},
+        client::{
+            filter::RoomEventFilter,
+            message::get_message_events,
+            threads::get_threads::{self, v1::IncludeThreads},
+        },
         Direction,
     },
     assign,
@@ -174,3 +178,49 @@ pub struct EventWithContextResponse {
     /// membership events.
     pub state: Vec<Raw<AnyStateEvent>>,
 }
+
+/// Options for [super::Room::list_threads].
+#[derive(Debug, Default)]
+pub struct ListThreadsOptions {
+    /// An extra filter to select which threads should be returned.
+    pub include_threads: IncludeThreads,
+
+    /// The token to start returning events from.
+    ///
+    /// This token can be obtained from a [`ThreadRoots::prev_batch_token`]
+    /// returned by a previous call to [`super::Room::list_threads()`].
+    ///
+    /// If `from` isn't provided the homeserver shall return a list of thread
+    /// roots from end of the timeline history.
+    pub from: Option<String>,
+
+    /// The maximum number of events to return.
+    ///
+    /// Default: 10.
+    pub limit: Option<UInt>,
+}
+
+impl ListThreadsOptions {
+    /// Converts the thread options into a Ruma request.
+    pub(super) fn into_request(self, room_id: &RoomId) -> get_threads::v1::Request {
+        assign!(get_threads::v1::Request::new(room_id.to_owned()), {
+            from: self.from,
+            include: self.include_threads,
+            limit: self.limit,
+        })
+    }
+}
+
+/// The result of a [`super::Room::list_threads`] query.
+///
+/// This is a wrapper around the Ruma equivalent, with events decrypted if needs
+/// be.
+#[derive(Debug)]
+pub struct ThreadRoots {
+    /// The events that are thread roots in the current batch.
+    pub chunk: Vec<TimelineEvent>,
+
+    /// Token to paginate backwards in a subsequent query to
+    /// [`super::Room::list_threads`].
+    pub prev_batch_token: Option<String>,
+}

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

@@ -54,6 +54,7 @@ use matrix_sdk_common::{
     executor::{spawn, JoinHandle},
     timeout::timeout,
 };
+use messages::{ListThreadsOptions, ThreadRoots};
 use mime::Mime;
 use reply::Reply;
 #[cfg(feature = "e2e-encryption")]
@@ -3544,6 +3545,27 @@ impl Room {
     pub fn privacy_settings(&self) -> RoomPrivacySettings<'_> {
         RoomPrivacySettings::new(&self.inner, &self.client)
     }
+
+    /// Retrieve a list of all the threads for the current room.
+    ///
+    /// Since this client-server API is paginated, the return type may include a
+    /// token used to resuming back-pagination into the list of results, in
+    /// [`ThreadRoots::prev_batch_token`]. This token can be fed back into
+    /// [`ListThreadsOptions::from`] to continue the pagination
+    /// from the previous position.
+    pub async fn list_threads(&self, opts: ListThreadsOptions) -> Result<ThreadRoots> {
+        let request = opts.into_request(self.room_id());
+
+        let response = self.client.send(request).await?;
+
+        let push_ctx = self.push_context().await?;
+        let chunk = join_all(
+            response.chunk.into_iter().map(|ev| self.try_decrypt_event(ev, push_ctx.as_ref())),
+        )
+        .await;
+
+        Ok(ThreadRoots { chunk, prev_batch_token: response.next_batch })
+    }
 }
 
 #[cfg(all(feature = "e2e-encryption", not(target_arch = "wasm32")))]
@@ -3872,6 +3894,7 @@ mod tests {
     use super::ReportedContentScore;
     use crate::{
         config::RequestConfig,
+        room::messages::ListThreadsOptions,
         test_utils::{client::mock_matrix_session, logged_in_client, mocks::MatrixMockServer},
         Client,
     };