feat(sdk) Use the types from http instead of ruma directly.

Author: Hywan

crates/matrix-sdk-base/src/sliding_sync/http.rs

@@ -32,8 +32,8 @@ pub mod ss {
         // Request types.
         pub use super::v4::{
             AccountDataConfig as RequestAccountData, E2EEConfig as RequestE2EE,
-            ReceiptsConfig as RequestReceipts, ToDeviceConfig as RequestToDevice,
-            TypingConfig as RequestTyping,
+            ReceiptsConfig as RequestReceipts, RoomReceiptConfig as RequestReceiptsRoom,
+            ToDeviceConfig as RequestToDevice, TypingConfig as RequestTyping,
         };
 
         // Response types.

crates/matrix-sdk-base/src/sliding_sync/mod.rs

@@ -64,7 +64,8 @@ impl BaseClient {
 
         let http::ss::ResponseExtensions { to_device, e2ee, .. } = extensions;
 
-        let to_device_events = to_device.as_ref().map(|v4| v4.events.clone()).unwrap_or_default();
+        let to_device_events =
+            to_device.as_ref().map(|to_device| to_device.events.clone()).unwrap_or_default();
 
         trace!(
             to_device_events = to_device_events.len(),
@@ -713,7 +714,7 @@ fn process_room_properties(
     // Handle the room's avatar.
     //
     // It can be updated via the state events, or via the
-    // [`v4::SlidingSyncRoom::avatar`] field. This part of the code handles the
+    // [`http::ss::ResponseRoom::avatar`] field. This part of the code handles the
     // latter case. The former case is handled by [`BaseClient::handle_state`].
     match &room_data.avatar {
         // A new avatar!
@@ -726,7 +727,7 @@ fn process_room_properties(
 
     // Sliding sync doesn't have a room summary, nevertheless it contains the joined
     // and invited member counts, in addition to the heroes if it's been configured
-    // to return them (see the [`v4::RoomSubscription::include_heroes`]).
+    // to return them (see the [`http::ss::RequestRoomSubscription::include_heroes`]).
     if let Some(count) = room_data.joined_count {
         room_info.update_joined_member_count(count.into());
     }

crates/matrix-sdk/src/sliding_sync/README.md

@@ -58,7 +58,7 @@ After the general configuration, one typically wants to add a list via the
 ## Lists
 
 A list defines a subset of matching rooms one wants to filter for, and be
-kept up about. The [`v4::SyncRequestListFilters`][] allows for a granular
+kept up about. The [`http::ss::RequestListFilters`] allows for a granular
 specification of the exact rooms one wants the server to select and the way
 one wants them to be ordered before receiving. Secondly each list has a set
 of `ranges`: the subset of indexes of the entire list one is interested in
@@ -73,12 +73,13 @@ are **inclusive**) like so:
 
 ```rust
 # use matrix_sdk::sliding_sync::{SlidingSyncList, SlidingSyncMode};
-use ruma::{assign, api::client::sync::sync_events::v4};
+use matrix_sdk_base::sliding_sync::http;
+use ruma::assign;
 
 let list_builder = SlidingSyncList::builder("main_list")
     .sync_mode(SlidingSyncMode::new_selective().add_range(0..=9))
     .filters(Some(assign!(
-        v4::SyncRequestListFilters::default(), { is_dm: Some(true)}
+        http::ss::RequestListFilters::default(), { is_dm: Some(true)}
     )))
     .sort(vec!["by_recency".to_owned()]);
 ```
@@ -161,15 +162,15 @@ typing- and presence-information and account-data, but can be extended by
 any implementation as they please. Handling of the data of the e2ee,
 to-device and typing-extensions takes place transparently within the SDK.
 
-By default [`SlidingSync`][] doesn't activate _any_ extensions to save on
+By default [`SlidingSync`] doesn't activate _any_ extensions to save on
 bandwidth, but we generally recommend to use the `with_XXX_extensions` family
 of methods when building sliding sync to enable e2ee, to-device-messages and
 account-data-extensions.
 
 ## Timeline events
 
 Both the list configuration as well as the [room subscription
-settings](`v4::RoomSubscription`) allow to specify a `timeline_limit` to
+settings](`http::ss::RequestRoomSubscription`) allow to specify a `timeline_limit` to
 receive timeline events. If that is unset or set to 0, no events are sent by
 the server (which is the default), if multiple limits are found, the highest
 takes precedence. Any positive number indicates that on the first request a
@@ -229,14 +230,8 @@ In full, this typically looks like this:
 
 ```rust,no_run
 # use futures_util::{pin_mut, StreamExt};
-# use matrix_sdk::{
-#    sliding_sync::{SlidingSyncMode, SlidingSyncListBuilder},
-#    Client,
-# };
-# use ruma::{
-#    api::client::sync::sync_events::v4, assign,
-# };
-# use tracing::{debug, error, info, warn};
+# use matrix_sdk::Client;
+# use tracing::{error, info};
 # use url::Url;
 # async {
 # let homeserver = Url::parse("http://example.com")?;
@@ -288,7 +283,7 @@ will return immediately — with a proper response though. One just needs to
 make sure to not call that stream any further. Additionally, as both
 requests are sent with the same positional argument, the server might
 respond with data, the client has already processed. This isn't a problem,
-the [`SlidingSync`][] will only process new data and skip the processing
+the [`SlidingSync`] will only process new data and skip the processing
 even across restarts.
 
 To support this, in practice, one can spawn a `Future` that runs
@@ -341,32 +336,12 @@ be sent in their first request than if they were loaded from a cold cache.
 Only the latest 10 timeline items of each room are cached and they are reset
 whenever a new set of timeline items is received by the server.
 
-## Bot mode
-
-_Note_: This is not yet exposed via the API. See [#1475](https://github.com/matrix-org/matrix-rust-sdk/issues/1475)
-
-Sliding Sync is modeled for faster and more efficient user-facing client
-applications, but offers significant speed ups even for bot cases through
-its filtering mechanism. The sort-order and specific subsets, however, are
-usually not of interest for bots. For that use case the
-[`v4::SyncRequestList`][] offers the
-[`slow_get_all_rooms`](`v4::SyncRequestList::slow_get_all_rooms`) flag.
-
-Once switched on, this mode will not trigger any updates on "list
-movements", ranges and sorting are ignored and all rooms matching the filter
-will be returned with the given room details settings. Depending on the data
-that is requested this will still be significantly faster as the response
-only returns the matching rooms and states as per settings.
-
-Think about a bot that only interacts in `is_dm = true` and doesn't need
-room topic, room avatar and all the other state. It will be a lot faster to
-start up and retrieve only the data needed to actually run.
-
 # Full example
 
 ```rust,no_run
 use matrix_sdk::{Client, sliding_sync::{SlidingSyncList, SlidingSyncMode}};
-use ruma::{assign, api::client::sync::sync_events::v4, events::StateEventType};
+use matrix_sdk_base::sliding_sync::http;
+use ruma::{assign, events::StateEventType};
 use tracing::{warn, error, info, debug};
 use futures_util::{pin_mut, StreamExt};
 use url::Url;
@@ -380,11 +355,11 @@ let sliding_sync_builder = client
     .sliding_sync("main-sync")?
     .sliding_sync_proxy(Url::parse("http://sliding-sync.example.org")?) // our proxy server
     .with_account_data_extension(
-        assign!(v4::AccountDataConfig::default(), { enabled: Some(true) }),
+        assign!(http::ss::extensions::RequestAccountData::default(), { enabled: Some(true) }),
     ) // we enable the account-data extension
-    .with_e2ee_extension(assign!(v4::E2EEConfig::default(), { enabled: Some(true) })) // and the e2ee extension
+    .with_e2ee_extension(assign!(http::ss::extensions::RequestE2EE::default(), { enabled: Some(true) })) // and the e2ee extension
     .with_to_device_extension(
-        assign!(v4::ToDeviceConfig::default(), { enabled: Some(true) }),
+        assign!(http::ss::extensions::RequestToDevice::default(), { enabled: Some(true) }),
     ); // and the to-device extension
 
 let full_sync_list = SlidingSyncList::builder(&full_sync_list_name)

crates/matrix-sdk/src/sliding_sync/builder.rs

@@ -6,14 +6,10 @@ use std::{
     time::Duration,
 };
 
+use matrix_sdk_base::sliding_sync::http;
 use matrix_sdk_common::{ring_buffer::RingBuffer, timer};
-use ruma::{
-    api::client::sync::sync_events::v4::{
-        self, AccountDataConfig, E2EEConfig, ExtensionsConfig, ReceiptsConfig, ToDeviceConfig,
-        TypingConfig,
-    },
-    OwnedRoomId,
-};
+
+use ruma::OwnedRoomId;
 use tokio::sync::{broadcast::channel, Mutex as AsyncMutex, RwLock as AsyncRwLock};
 use url::Url;
 
@@ -36,8 +32,8 @@ pub struct SlidingSyncBuilder {
     sliding_sync_proxy: Option<Url>,
     client: Client,
     lists: Vec<SlidingSyncListBuilder>,
-    extensions: Option<ExtensionsConfig>,
-    subscriptions: BTreeMap<OwnedRoomId, v4::RoomSubscription>,
+    extensions: Option<http::ss::RequestExtensions>,
+    subscriptions: BTreeMap<OwnedRoomId, http::ss::RequestRoomSubscription>,
     rooms: BTreeMap<OwnedRoomId, SlidingSyncRoom>,
     poll_timeout: Duration,
     network_timeout: Duration,
@@ -135,63 +131,76 @@ impl SlidingSyncBuilder {
     }
 
     /// Set the E2EE extension configuration.
-    pub fn with_e2ee_extension(mut self, e2ee: E2EEConfig) -> Self {
+    pub fn with_e2ee_extension(mut self, e2ee: http::ss::extensions::RequestE2EE) -> Self {
         self.extensions.get_or_insert_with(Default::default).e2ee = e2ee;
         self
     }
 
     /// Unset the E2EE extension configuration.
     pub fn without_e2ee_extension(mut self) -> Self {
-        self.extensions.get_or_insert_with(Default::default).e2ee = E2EEConfig::default();
+        self.extensions.get_or_insert_with(Default::default).e2ee =
+            http::ss::extensions::RequestE2EE::default();
         self
     }
 
     /// Set the ToDevice extension configuration.
-    pub fn with_to_device_extension(mut self, to_device: ToDeviceConfig) -> Self {
+    pub fn with_to_device_extension(
+        mut self,
+        to_device: http::ss::extensions::RequestToDevice,
+    ) -> Self {
         self.extensions.get_or_insert_with(Default::default).to_device = to_device;
         self
     }
 
     /// Unset the ToDevice extension configuration.
     pub fn without_to_device_extension(mut self) -> Self {
-        self.extensions.get_or_insert_with(Default::default).to_device = ToDeviceConfig::default();
+        self.extensions.get_or_insert_with(Default::default).to_device =
+            http::ss::extensions::RequestToDevice::default();
         self
     }
 
     /// Set the account data extension configuration.
-    pub fn with_account_data_extension(mut self, account_data: AccountDataConfig) -> Self {
+    pub fn with_account_data_extension(
+        mut self,
+        account_data: http::ss::extensions::RequestAccountData,
+    ) -> Self {
         self.extensions.get_or_insert_with(Default::default).account_data = account_data;
         self
     }
 
     /// Unset the account data extension configuration.
     pub fn without_account_data_extension(mut self) -> Self {
         self.extensions.get_or_insert_with(Default::default).account_data =
-            AccountDataConfig::default();
+            http::ss::extensions::RequestAccountData::default();
         self
     }
 
     /// Set the Typing extension configuration.
-    pub fn with_typing_extension(mut self, typing: TypingConfig) -> Self {
+    pub fn with_typing_extension(mut self, typing: http::ss::extensions::RequestTyping) -> Self {
         self.extensions.get_or_insert_with(Default::default).typing = typing;
         self
     }
 
     /// Unset the Typing extension configuration.
     pub fn without_typing_extension(mut self) -> Self {
-        self.extensions.get_or_insert_with(Default::default).typing = TypingConfig::default();
+        self.extensions.get_or_insert_with(Default::default).typing =
+            http::ss::extensions::RequestTyping::default();
         self
     }
 
     /// Set the Receipt extension configuration.
-    pub fn with_receipt_extension(mut self, receipt: ReceiptsConfig) -> Self {
+    pub fn with_receipt_extension(
+        mut self,
+        receipt: http::ss::extensions::RequestReceipts,
+    ) -> Self {
         self.extensions.get_or_insert_with(Default::default).receipts = receipt;
         self
     }
 
     /// Unset the Receipt extension configuration.
     pub fn without_receipt_extension(mut self) -> Self {
-        self.extensions.get_or_insert_with(Default::default).receipts = ReceiptsConfig::default();
+        self.extensions.get_or_insert_with(Default::default).receipts =
+            http::ss::extensions::RequestReceipts::default();
         self
     }
 

crates/matrix-sdk/src/sliding_sync/client.rs

@@ -1,8 +1,8 @@
 use std::collections::BTreeMap;
 
 use imbl::Vector;
-use matrix_sdk_base::{sync::SyncResponse, PreviousEventsProvider};
-use ruma::{api::client::sync::sync_events::v4, events::AnyToDeviceEvent, serde::Raw, OwnedRoomId};
+use matrix_sdk_base::{sliding_sync::http, sync::SyncResponse, PreviousEventsProvider};
+use ruma::{events::AnyToDeviceEvent, serde::Raw, OwnedRoomId};
 
 use super::{SlidingSync, SlidingSyncBuilder};
 use crate::{Client, Result, SlidingSyncRoom};
@@ -25,7 +25,7 @@ impl Client {
     #[tracing::instrument(skip(self, response))]
     pub async fn process_sliding_sync_test_helper(
         &self,
-        response: &v4::Response,
+        response: &http::ss::Response,
     ) -> Result<SyncResponse> {
         let response = self.base_client().process_sliding_sync(response, &()).await?;
 
@@ -66,7 +66,10 @@ impl<'a> SlidingSyncResponseProcessor<'a> {
     }
 
     #[cfg(feature = "e2e-encryption")]
-    pub async fn handle_encryption(&mut self, extensions: &v4::Extensions) -> Result<()> {
+    pub async fn handle_encryption(
+        &mut self,
+        extensions: &http::ss::ResponseExtensions,
+    ) -> Result<()> {
         // This is an internal API misuse if this is triggered (calling
         // handle_room_response before this function), so panic is fine.
         assert!(self.response.is_none());
@@ -80,7 +83,7 @@ impl<'a> SlidingSyncResponseProcessor<'a> {
         Ok(())
     }
 
-    pub async fn handle_room_response(&mut self, response: &v4::Response) -> Result<()> {
+    pub async fn handle_room_response(&mut self, response: &http::ss::Response) -> Result<()> {
         self.response = Some(
             self.client
                 .base_client()

crates/matrix-sdk/src/sliding_sync/list/builder.rs

@@ -7,10 +7,8 @@ use std::{
 };
 
 use eyeball::{Observable, SharedObservable};
-use ruma::{
-    api::client::sync::sync_events::v4,
-    events::{StateEventType, TimelineEventType},
-};
+use matrix_sdk_base::sliding_sync::http;
+use ruma::events::{StateEventType, TimelineEventType};
 use tokio::sync::broadcast::Sender;
 
 use super::{
@@ -39,7 +37,7 @@ pub struct SlidingSyncListBuilder {
     sort: Vec<String>,
     required_state: Vec<(StateEventType, String)>,
     include_heroes: Option<bool>,
-    filters: Option<v4::SyncRequestListFilters>,
+    filters: Option<http::ss::RequestListFilters>,
     timeline_limit: Option<Bound>,
     pub(crate) name: String,
 
@@ -131,7 +129,7 @@ impl SlidingSyncListBuilder {
     }
 
     /// Any filters to apply to the query.
-    pub fn filters(mut self, value: Option<v4::SyncRequestListFilters>) -> Self {
+    pub fn filters(mut self, value: Option<http::ss::RequestListFilters>) -> Self {
         self.filters = value;
         self
     }

crates/matrix-sdk/src/sliding_sync/list/mod.rs

@@ -11,7 +11,8 @@ use std::{
 
 use eyeball::{Observable, SharedObservable, Subscriber};
 use futures_core::Stream;
-use ruma::{api::client::sync::sync_events::v4, assign, TransactionId};
+use matrix_sdk_base::sliding_sync::http;
+use ruma::{assign, TransactionId};
 use serde::{Deserialize, Serialize};
 use tokio::sync::broadcast::Sender;
 use tracing::{instrument, warn};
@@ -147,7 +148,7 @@ impl SlidingSyncList {
     pub(super) fn next_request(
         &self,
         txn_id: &mut LazyTransactionId,
-    ) -> Result<v4::SyncRequestList, Error> {
+    ) -> Result<http::ss::RequestList, Error> {
         self.inner.next_request(txn_id)
     }
 
@@ -274,7 +275,7 @@ impl SlidingSyncListInner {
     }
 
     /// Update the state to the next request, and return it.
-    fn next_request(&self, txn_id: &mut LazyTransactionId) -> Result<v4::SyncRequestList, Error> {
+    fn next_request(&self, txn_id: &mut LazyTransactionId) -> Result<http::ss::RequestList, Error> {
         let ranges = {
             // Use a dedicated scope to ensure the lock is released before continuing.
             let mut request_generator = self.request_generator.write().unwrap();
@@ -285,16 +286,16 @@ impl SlidingSyncListInner {
         Ok(self.request(ranges, txn_id))
     }
 
-    /// Build a [`SyncRequestList`][v4::SyncRequestList] based on the current
+    /// Build a [`SyncRequestList`][http::ss::RequestList] based on the current
     /// state of the request generator.
     #[instrument(skip(self), fields(name = self.name))]
-    fn request(&self, ranges: Ranges, txn_id: &mut LazyTransactionId) -> v4::SyncRequestList {
+    fn request(&self, ranges: Ranges, txn_id: &mut LazyTransactionId) -> http::ss::RequestList {
         use ruma::UInt;
 
         let ranges =
             ranges.into_iter().map(|r| (UInt::from(*r.start()), UInt::from(*r.end()))).collect();
 
-        let mut request = assign!(v4::SyncRequestList::default(), { ranges });
+        let mut request = assign!(http::ss::RequestList::default(), { ranges });
         {
             let mut sticky = self.sticky.write().unwrap();
             sticky.maybe_apply(&mut request, txn_id);