Refactor Client to support AppserviceUserIdentity

rsb-tbg · rsb-tbg · commit 8acf4eb94f7a · 2025-11-29T10:43:56.000-06:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -8,6 +8,7 @@ Breaking changes:
     compatible with all requests from ruma-client-api and ruma-appservice-api.
   - `HttpRequest::RequestBuilder` has an extra `AsRef<[u8]>` bound.
   - Bump MSRV to 1.88
+- `Client::send_request_as()` now takes `AppserviceUserIdentity` instead of `&UserId`.
   
 Improvements:
 
diff --git a/src/client.rs b/src/client.rs
@@ -8,9 +8,9 @@ use assign::assign;
 use async_stream::try_stream;
 use futures_core::stream::Stream;
 use ruma::{
-    DeviceId, UserId,
+    DeviceId,
     api::{
-        OutgoingRequest, SupportedVersions,
+        AppserviceUserIdentity, OutgoingRequest, OutgoingRequestAppserviceExt, SupportedVersions,
         auth_scheme::{AuthScheme, SendAccessToken},
         client::{
             account::register::{self, RegistrationKind},
@@ -24,7 +24,8 @@ use ruma::{
 };
 
 use crate::{
-    Error, HttpClient, ResponseError, ResponseResult, add_user_id_to_query, send_customized_request,
+    Error, HttpClient, ResponseError, ResponseResult, send_customized_request, send_request,
+    send_request_as,
 };
 
 mod builder;
@@ -83,6 +84,18 @@ impl<C> Client<C> {
     pub fn access_token(&self) -> Option<String> {
         self.0.access_token.lock().expect("session mutex was poisoned").clone()
     }
+
+    /// Get the `SendAccessToken` according to the client's `TokenMode`.
+    fn send_access_token<'a>(&self, access_token: &'a Option<String>) -> SendAccessToken<'a> {
+        let token_mode = self.0.token_mode;
+
+        match (token_mode, access_token.as_deref()) {
+            (TokenMode::AppService, Some(at)) => SendAccessToken::Appservice(at),
+            (TokenMode::SendIfRequired, Some(at)) => SendAccessToken::IfRequired(at),
+            (TokenMode::SendAlways, Some(at)) => SendAccessToken::Always(at),
+            (_, None) => SendAccessToken::None,
+        }
+    }
 }
 
 impl<C: HttpClient> Client<C> {
@@ -93,7 +106,16 @@ impl<C: HttpClient> Client<C> {
         for<'a> R::Authentication: AuthScheme<Input<'a> = SendAccessToken<'a>>,
         R::PathBuilder: SupportedPathBuilder,
     {
-        self.send_customized_request(request, |_| Ok(())).await
+        let access_token = self.access_token();
+
+        send_request(
+            &self.0.http_client,
+            &self.0.homeserver_url,
+            self.send_access_token(&access_token),
+            R::PathBuilder::get_path_builder_input(self),
+            request,
+        )
+        .await
     }
 
     /// Makes a request to a Matrix API endpoint including additional URL parameters.
@@ -108,20 +130,12 @@ impl<C: HttpClient> Client<C> {
         R::PathBuilder: SupportedPathBuilder,
         F: FnOnce(&mut http::Request<C::RequestBody>) -> Result<(), ResponseError<C, R>>,
     {
-        let token_mode = self.0.token_mode;
         let access_token = self.access_token();
 
-        let send_access_token = match (token_mode, access_token.as_deref()) {
-            (TokenMode::AppService, Some(at)) => SendAccessToken::Appservice(at),
-            (TokenMode::SendIfRequired, Some(at)) => SendAccessToken::IfRequired(at),
-            (TokenMode::SendAlways, Some(at)) => SendAccessToken::Always(at),
-            (_, None) => SendAccessToken::None,
-        };
-
         send_customized_request(
             &self.0.http_client,
             &self.0.homeserver_url,
-            send_access_token,
+            self.send_access_token(&access_token),
             R::PathBuilder::get_path_builder_input(self),
             request,
             customize,
@@ -133,13 +147,27 @@ impl<C: HttpClient> Client<C> {
     ///
     /// This method is meant to be used by application services when interacting with the
     /// client-server API.
-    pub async fn send_request_as<R>(&self, user_id: &UserId, request: R) -> ResponseResult<C, R>
+    pub async fn send_request_as<R>(
+        &self,
+        identity: AppserviceUserIdentity<'_>,
+        request: R,
+    ) -> ResponseResult<C, R>
     where
-        R: OutgoingRequest,
+        R: OutgoingRequestAppserviceExt,
         for<'a> R::Authentication: AuthScheme<Input<'a> = SendAccessToken<'a>>,
         R::PathBuilder: SupportedPathBuilder,
     {
-        self.send_customized_request(request, add_user_id_to_query::<C, R>(user_id)).await
+        let access_token = self.access_token();
+
+        send_request_as(
+            &self.0.http_client,
+            &self.0.homeserver_url,
+            self.send_access_token(&access_token),
+            identity,
+            R::PathBuilder::get_path_builder_input(self),
+            request,
+        )
+        .await
     }
 
     /// Log in with a username and password.
diff --git a/src/http_client.rs b/src/http_client.rs
@@ -4,16 +4,13 @@
 use std::{future::Future, pin::Pin};
 
 use bytes::BufMut;
-use ruma::{
-    UserId,
-    api::{
-        OutgoingRequest,
-        auth_scheme::{AuthScheme, SendAccessToken},
-        path_builder::PathBuilder,
-    },
+use ruma::api::{
+    AppserviceUserIdentity, OutgoingRequest,
+    auth_scheme::{AuthScheme, SendAccessToken},
+    path_builder::PathBuilder,
 };
 
-use crate::{ResponseError, ResponseResult, add_user_id_to_query};
+use crate::{ResponseError, ResponseResult};
 
 #[cfg(feature = "hyper")]
 mod hyper;
@@ -59,25 +56,18 @@ pub trait DefaultConstructibleHttpClient: HttpClient {
 /// trait should make that relatively easy.
 pub trait HttpClientExt: HttpClient {
     /// Send a strongly-typed matrix request to get back a strongly-typed response.
-    // TODO: `R: 'a` bound should not be needed
     fn send_matrix_request<'a, R>(
         &'a self,
         homeserver_url: &str,
-        access_token: SendAccessToken<'a>,
-        path_builder_input: <R::PathBuilder as PathBuilder>::Input<'_>,
+        access_token: SendAccessToken<'_>,
+        for_versions: <R::PathBuilder as PathBuilder>::Input<'_>,
         request: R,
     ) -> Pin<Box<dyn Future<Output = ResponseResult<Self, R>> + 'a + Send>>
     where
         R: OutgoingRequest,
-        R::Authentication: AuthScheme<Input<'a> = SendAccessToken<'a>>,
+        for<'b> R::Authentication: AuthScheme<Input<'b> = SendAccessToken<'b>>,
     {
-        self.send_customized_matrix_request(
-            homeserver_url,
-            access_token,
-            path_builder_input,
-            request,
-            |_| Ok(()),
-        )
+        Box::pin(crate::send_request(self, homeserver_url, access_token, for_versions, request))
     }
 
     /// Turn a strongly-typed matrix request into an `http::Request`, customize it and send it to
@@ -106,30 +96,31 @@ pub trait HttpClientExt: HttpClient {
         ))
     }
 
-    /// Turn a strongly-typed matrix request into an `http::Request`, add a `user_id` query
-    /// parameter to it and send it to get back a strongly-typed response.
+    /// Turn a strongly-typed matrix request into an `http::Request`, add `user_id` and/or
+    /// `device_id` query parameters to it and send it to get back a strongly-typed response.
     ///
     /// This method is meant to be used by application services when interacting with the
     /// client-server API.
     fn send_matrix_request_as<'a, R>(
         &'a self,
         homeserver_url: &str,
-        access_token: SendAccessToken<'a>,
-        path_builder_input: <R::PathBuilder as PathBuilder>::Input<'_>,
-        user_id: &'a UserId,
+        access_token: SendAccessToken<'_>,
+        identity: AppserviceUserIdentity<'_>,
+        for_versions: <R::PathBuilder as PathBuilder>::Input<'_>,
         request: R,
-    ) -> Pin<Box<dyn Future<Output = ResponseResult<Self, R>> + 'a>>
+    ) -> Pin<Box<dyn Future<Output = ResponseResult<Self, R>> + 'a + Send>>
     where
         R: OutgoingRequest,
-        R::Authentication: AuthScheme<Input<'a> = SendAccessToken<'a>>,
+        for<'b> R::Authentication: AuthScheme<Input<'b> = SendAccessToken<'b>>,
     {
-        self.send_customized_matrix_request(
+        Box::pin(crate::send_request_as(
+            self,
             homeserver_url,
             access_token,
-            path_builder_input,
+            identity,
+            for_versions,
             request,
-            add_user_id_to_query::<Self, R>(user_id),
-        )
+        ))
     }
 }
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -64,7 +64,7 @@
 //! #     .await?;
 //!
 //! use ruma::{
-//!     api::{MatrixVersion, client::alias::get_alias},
+//!     api::{client::alias::get_alias, MatrixVersion},
 //!     owned_room_alias_id, room_id,
 //! };
 //!
@@ -101,13 +101,10 @@ use std::{any::type_name, future::Future};
 
 #[doc(no_inline)]
 pub use ruma;
-use ruma::{
-    UserId,
-    api::{
-        OutgoingRequest,
-        auth_scheme::{AuthScheme, SendAccessToken},
-        path_builder::PathBuilder,
-    },
+use ruma::api::{
+    AppserviceUserIdentity, OutgoingRequest, OutgoingRequestAppserviceExt,
+    auth_scheme::{AuthScheme, SendAccessToken},
+    path_builder::PathBuilder,
 };
 use tracing::{Instrument, info_span};
 
@@ -117,7 +114,7 @@ mod error;
 pub mod http_client;
 
 #[cfg(feature = "client-api")]
-pub use self::client::{Client, ClientBuilder, SupportedPathBuilder, TokenMode};
+pub use self::client::{Client, ClientBuilder, TokenMode};
 pub use self::{
     error::Error,
     http_client::{DefaultConstructibleHttpClient, HttpClient, HttpClientExt},
@@ -131,31 +128,15 @@ pub type ResponseError<C, R> =
 pub type ResponseResult<C, R> =
     Result<<R as OutgoingRequest>::IncomingResponse, ResponseError<C, R>>;
 
-fn send_customized_request<'a, C, R, F>(
+fn send_prepared_request<'a, C, R>(
     http_client: &'a C,
     homeserver_url: &str,
-    send_access_token: SendAccessToken<'a>,
-    path_builder_input: <R::PathBuilder as PathBuilder>::Input<'_>,
-    request: R,
-    customize: F,
-) -> impl Future<Output = ResponseResult<C, R>> + Send + 'a + use<'a, C, R, F>
+    http_req: Result<http::Request<C::RequestBody>, ResponseError<C, R>>,
+) -> impl Future<Output = ResponseResult<C, R>> + Send + 'a + use<'a, C, R>
 where
     C: HttpClient + ?Sized,
     R: OutgoingRequest,
-    R::Authentication: AuthScheme<Input<'a> = SendAccessToken<'a>>,
-    F: FnOnce(&mut http::Request<C::RequestBody>) -> Result<(), ResponseError<C, R>>,
 {
-    let http_req =
-        info_span!("serialize_request", request_type = type_name::<R>()).in_scope(move || {
-            request
-                .try_into_http_request(homeserver_url, send_access_token, path_builder_input)
-                .map_err(ResponseError::<C, R>::from)
-                .and_then(|mut req| {
-                    customize(&mut req)?;
-                    Ok(req)
-                })
-        });
-
     let send_span = info_span!(
         "send_request",
         request_type = type_name::<R>(),
@@ -178,23 +159,78 @@ where
     }
 }
 
-fn add_user_id_to_query<C: HttpClient + ?Sized, R: OutgoingRequest>(
-    user_id: &UserId,
-) -> impl FnOnce(&mut http::Request<C::RequestBody>) -> Result<(), ResponseError<C, R>> + '_ {
-    use assign::assign;
-    use http::uri::Uri;
-
-    move |http_request| {
-        let extra_params = serde_html_form::to_string([("user_id", user_id)]).unwrap();
-        let uri = http_request.uri_mut();
-        let new_path_and_query = match uri.query() {
-            Some(params) => format!("{}?{params}&{extra_params}", uri.path()),
-            None => format!("{}?{extra_params}", uri.path()),
-        };
-        *uri = Uri::from_parts(assign!(uri.clone().into_parts(), {
-            path_and_query: Some(new_path_and_query.parse()?),
-        }))?;
-
-        Ok(())
-    }
+fn send_request<'a, C, R>(
+    http_client: &'a C,
+    homeserver_url: &str,
+    authentication_input: <R::Authentication as AuthScheme>::Input<'_>,
+    path_builder_input: <R::PathBuilder as PathBuilder>::Input<'_>,
+    request: R,
+) -> impl Future<Output = ResponseResult<C, R>> + Send + 'a + use<'a, C, R>
+where
+    C: HttpClient + ?Sized,
+    R: OutgoingRequest,
+{
+    let http_req =
+        info_span!("serialize_request", request_type = type_name::<R>()).in_scope(move || {
+            request
+                .try_into_http_request(homeserver_url, authentication_input, path_builder_input)
+                .map_err(ResponseError::<C, R>::from)
+        });
+
+    send_prepared_request::<C, R>(http_client, homeserver_url, http_req)
+}
+
+fn send_request_as<'a, C, R>(
+    http_client: &'a C,
+    homeserver_url: &str,
+    authentication_input: <R::Authentication as AuthScheme>::Input<'_>,
+    identity: AppserviceUserIdentity<'_>,
+    path_builder_input: <R::PathBuilder as PathBuilder>::Input<'_>,
+    request: R,
+) -> impl Future<Output = ResponseResult<C, R>> + Send + 'a + use<'a, C, R>
+where
+    C: HttpClient + ?Sized,
+    R: OutgoingRequestAppserviceExt,
+    for<'b> R::Authentication: AuthScheme<Input<'b> = SendAccessToken<'b>>,
+{
+    let http_req =
+        info_span!("serialize_request", request_type = type_name::<R>()).in_scope(move || {
+            request
+                .try_into_http_request_with_identity(
+                    homeserver_url,
+                    authentication_input,
+                    identity,
+                    path_builder_input,
+                )
+                .map_err(ResponseError::<C, R>::from)
+        });
+
+    send_prepared_request::<C, R>(http_client, homeserver_url, http_req)
+}
+
+fn send_customized_request<'a, C, R, F>(
+    http_client: &'a C,
+    homeserver_url: &str,
+    authentication_input: <R::Authentication as AuthScheme>::Input<'_>,
+    path_builder_input: <R::PathBuilder as PathBuilder>::Input<'_>,
+    request: R,
+    customize: F,
+) -> impl Future<Output = ResponseResult<C, R>> + Send + 'a + use<'a, C, R, F>
+where
+    C: HttpClient + ?Sized,
+    R: OutgoingRequest,
+    F: FnOnce(&mut http::Request<C::RequestBody>) -> Result<(), ResponseError<C, R>>,
+{
+    let http_req =
+        info_span!("serialize_request", request_type = type_name::<R>()).in_scope(move || {
+            request
+                .try_into_http_request(homeserver_url, authentication_input, path_builder_input)
+                .map_err(ResponseError::<C, R>::from)
+                .and_then(|mut req| {
+                    customize(&mut req)?;
+                    Ok(req)
+                })
+        });
+
+    send_prepared_request::<C, R>(http_client, homeserver_url, http_req)
 }
