Refactor Client to support AppserviceUserIdentity

Author: rsb-tbg

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:
 

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,7 @@ 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_as,
 };
 
 mod builder;
@@ -83,6 +83,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> {
@@ -108,20 +120,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 +137,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),
+            R::PathBuilder::get_path_builder_input(self),
+            identity,
+            request,
+        )
+        .await
     }
 
     /// Log in with a username and password.

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, OutgoingRequestAppserviceExt,
+    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;
@@ -106,8 +103,8 @@ 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.
@@ -116,20 +113,21 @@ pub trait HttpClientExt: HttpClient {
         homeserver_url: &str,
         access_token: SendAccessToken<'a>,
         path_builder_input: <R::PathBuilder as PathBuilder>::Input<'_>,
-        user_id: &'a UserId,
+        identity: AppserviceUserIdentity<'a>,
         request: R,
     ) -> Pin<Box<dyn Future<Output = ResponseResult<Self, R>> + 'a>>
     where
-        R: OutgoingRequest,
-        R::Authentication: AuthScheme<Input<'a> = SendAccessToken<'a>>,
+        R: OutgoingRequestAppserviceExt,
+        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,
             request,
-            add_user_id_to_query::<Self, R>(user_id),
-        )
+        ))
     }
 }
 

src/lib.rs

@@ -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},
@@ -156,6 +153,18 @@ where
                 })
         });
 
+    send_http_request::<C, R>(http_client, homeserver_url, http_req)
+}
+
+fn send_http_request<'a, C, R>(
+    http_client: &'a C,
+    homeserver_url: &str,
+    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,
+{
     let send_span = info_span!(
         "send_request",
         request_type = type_name::<R>(),
@@ -178,23 +187,30 @@ 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()?),
-        }))?;
+fn send_request_as<'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<'_>,
+    identity: AppserviceUserIdentity<'_>,
+    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_as", 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)
+        });
 
-        Ok(())
-    }
+    send_http_request::<C, R>(http_client, homeserver_url, http_req)
 }