Refactor Client to support AppserviceUserIdentity with improved access token handling

Author: rsb-tbg

.github/workflows/ci.yml

@@ -3,7 +3,7 @@ name: CI
 env:
   CARGO_TERM_COLOR: always
   CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
-  NIGHTLY: nightly-2025-11-06
+  NIGHTLY: nightly-2025-08-08
 
 on:
   push:
@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repo
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Install rust nightly toolchain
         uses: dtolnay/rust-toolchain@master
@@ -27,7 +27,7 @@ jobs:
       - uses: Swatinem/rust-cache@v2
 
       - name: Check spelling
-        uses: crate-ci/typos@v1.39.2
+        uses: crate-ci/typos@v1.36.0
 
       - name: Install cargo-sort
         uses: taiki-e/cache-cargo-install-action@v2
@@ -44,19 +44,19 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repo
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Install MSRV toolchain
         uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: "1.88"
+          toolchain: "1.82"
 
       - uses: Swatinem/rust-cache@v2
         with:
           # A stable compiler update should automatically not reuse old caches.
           # Add the MSRV as a stable cache key too so bumping it also gets us a
           # fresh cache.
-          shared-key: msrv1.88
+          shared-key: msrv1.82
 
       - name: Run checks
         run: cargo check --all-features
@@ -78,7 +78,7 @@ jobs:
 
     steps:
       - name: Checkout repo
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Install rust stable toolchain
         uses: dtolnay/rust-toolchain@stable
@@ -102,16 +102,16 @@ jobs:
             cmd: check --all-features
 
           - name: Clippy Default Features
-            cmd: clippy --all-targets -- -D warnings
+            cmd: clippy
             components: clippy
 
           - name: Clippy All Features
-            cmd: clippy --all-features --all-targets -- -D warnings
+            cmd: clippy --all-features
             components: clippy
 
     steps:
       - name: Checkout repo
-        uses: actions/checkout@v6
+        uses: actions/checkout@v4
 
       - name: Install rust nightly toolchain
         uses: dtolnay/rust-toolchain@master

.github/workflows/deps.yml

@@ -16,5 +16,5 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
       - uses: EmbarkStudios/cargo-deny-action@v2

CHANGELOG.md

@@ -1,19 +1,19 @@
 # [unreleased]
 
+Improvements:
+
+-   `ClientBuilder` now has `token_mode()` which takes a `TokenMode` for correlation to `SendAccessToken` behavior.
+-   Add `SupportedPathBuilder` trait to enable supporting both `VersionHistory` and `SinglePath` path builders in client request methods.
+-   Add `send_matrix_request_as()` method to `HttpClientExt` trait for application service requests.
+
 Breaking changes:
 
-- Upgrade ruma to 0.14.0.
-  - The `send_request`, `send_request_as` and `send_customized_request` of
-    `Client` now have stricter bounds for the request. These bounds are
-    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
-  
-Improvements:
+-   `send_request` and `send_request_as` now require `R::PathBuilder: SupportedPathBuilder` bound.
+-   `send_request_as` now takes `AppserviceUserIdentity` instead of `&UserId` for the identity parameter.
+-   Remove `send_customized_request` from `Client`
+-   Remove `send_customized_matrix_request()` method from `HttpClientExt` trait.
+-   Add `C::RequestBody: AsRef<[u8]>` bound to various `Client` and `HttpClientExt` methods.
 
-- `ClientBuilder` now has `token_mode()` which takes a `TokenMode` for
-  correlation to `SendAccessToken` behavior.
-  
 # 0.16.0
 
 Breaking changes:

Cargo.toml

@@ -86,4 +86,4 @@ wildcard_imports = "warn"
 # Not that good of a lint
 new_without_default = "allow"
 # Disabled temporarily because it triggers false positives for types with generics.
-arc_with_non_send_sync = "allow"
+arc_with_non_send_sync = "allow"

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.

src/client/builder.rs

@@ -1,7 +1,7 @@
 use std::sync::{Arc, Mutex};
 
 use ruma::api::{
-    SupportedVersions, auth_scheme::SendAccessToken, client::discovery::get_supported_versions,
+    auth_scheme::SendAccessToken, client::discovery::get_supported_versions, SupportedVersions,
 };
 
 use super::{Client, ClientData, TokenMode};
@@ -63,6 +63,7 @@ impl ClientBuilder {
     pub async fn build<C>(self) -> Result<Client<C>, Error<C::Error, ruma::api::client::Error>>
     where
         C: DefaultConstructibleHttpClient,
+        C::RequestBody: AsRef<[u8]>,
     {
         self.http_client(C::default()).await
     }
@@ -78,6 +79,7 @@ impl ClientBuilder {
     ) -> Result<Client<C>, Error<C::Error, ruma::api::client::Error>>
     where
         C: HttpClient,
+        C::RequestBody: AsRef<[u8]>,
     {
         let homeserver_url = self
             .homeserver_url

src/error.rs

@@ -40,10 +40,7 @@ impl<E: Display, F: Display> Display for Error<E, F> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
             Self::AuthenticationRequired => {
-                write!(
-                    f,
-                    "The queried endpoint requires authentication but was called with an anonymous client."
-                )
+                write!(f, "The queried endpoint requires authentication but was called with an anonymous client.")
             }
             Self::IntoHttp(err) => write!(f, "HTTP request construction failed: {err}"),
             Self::Url(err) => write!(f, "Invalid URL: {err}"),

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,19 @@ 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>>,
+        Self::RequestBody: AsRef<[u8]>,
+        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 +97,32 @@ 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>>,
+        Self::RequestBody: AsRef<[u8]>,
+        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),
-        )
+        ))
     }
 }