Add custom future type, ResponseFuture, for HTTP responses

eng/dict/rust-custom.txt

@@ -1,4 +1,6 @@
 bindgen
+impl
+impls
 newtype
 repr
 rustc

eng/test/mock_transport/src/mock_response.rs

@@ -21,7 +21,7 @@ impl From<MockResponse> for Response {
     fn from(mock_response: MockResponse) -> Self {
         let bytes_stream: azure_core::BytesStream = mock_response.body.into();
 
-        Self::new(
+        Self::from_stream(
             mock_response.status,
             mock_response.headers,
             Box::pin(bytes_stream),
@@ -46,7 +46,7 @@ impl MockResponse {
             "an error occurred fetching the next part of the byte stream",
         )?;
 
-        let response = Response::new(
+        let response = Response::from_stream(
             status_code,
             header_map.clone(),
             Box::pin(BytesStream::new(response_bytes.clone())),

sdk/core/azure_core/Cargo.toml

@@ -62,5 +62,4 @@ features = [
   "reqwest_rustls",
   "hmac_rust",
   "hmac_openssl",
-  "xml",
 ]

sdk/core/azure_core/src/lib.rs

@@ -15,6 +15,14 @@
 #![deny(missing_debug_implementations, nonstandard_style)]
 // #![warn(missing_docs, future_incompatible, unreachable_pub)]
 
+// Docs.rs build is done with the nightly compiler, so we can enable nightly features in that build.
+// In this case we enable two features:
+// - `doc_auto_cfg`: Automatically scans `cfg` attributes and uses them to show those required configurations in the generated documentation.
+// - `doc_cfg_hide`: Ignore the `doc` configuration for `doc_auto_cfg`.
+// See https://doc.rust-lang.org/rustdoc/unstable-features.html#doc_auto_cfg-automatically-generate-doccfg for more details.
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg_hide))]
+
 #[macro_use]
 mod macros;
 
@@ -38,7 +46,9 @@ pub use models::*;
 pub use options::*;
 pub use pipeline::*;
 pub use policies::*;
-pub use typespec_client_core::http::response::{Model, PinnedStream, Response, ResponseBody};
+pub use typespec_client_core::http::{
+    LazyResponse, PinnedStream, Response, ResponseBody, ResponseFuture,
+};
 
 // Re-export typespec types that are not specific to Azure.
 pub use typespec::{Error, Result};

sdk/cosmos/azure_data_cosmos/examples/cosmos_metadata.rs

@@ -39,16 +39,12 @@ pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let db_client = client.database_client(&args.database);
     if let Some(container_name) = args.container {
         let container_client = db_client.container_client(container_name);
-        let response = container_client
-            .read(None)
-            .await?
-            .deserialize_body()
-            .await?;
-        println!("{:?}", response);
+        let response = container_client.read(None).await?;
+        println!("{:?}", response.into_body());
         return Ok(());
     } else {
-        let response = db_client.read(None).await?.deserialize_body().await?;
-        println!("{:?}", response);
+        let response = db_client.read(None).await?;
+        println!("{:?}", response.into_body());
     }
     Ok(())
 }

sdk/cosmos/azure_data_cosmos/src/clients/container_client.rs

@@ -34,17 +34,14 @@ pub trait ContainerClientMethods {
     /// # async fn doc() {
     /// # use azure_data_cosmos::clients::{ContainerClient, ContainerClientMethods};
     /// # let container_client: ContainerClient = panic!("this is a non-running example");
-    /// let response = container_client.read(None)
-    ///     .await.unwrap()
-    ///     .deserialize_body()
-    ///     .await.unwrap();
+    /// let response = container_client.read(None).await.unwrap();
     /// # }
     /// ```
     #[allow(async_fn_in_trait)] // REASON: See https://github.com/Azure/azure-sdk-for-rust/issues/1796 for detailed justification
-    async fn read(
+    fn read(
         &self,
         options: Option<ReadContainerOptions>,
-    ) -> azure_core::Result<azure_core::Response<ContainerProperties>>;
+    ) -> azure_core::ResponseFuture<ContainerProperties>;
 
     /// Executes a single-partition query against items in the container.
     ///
@@ -129,17 +126,16 @@ impl ContainerClient {
 }
 
 impl ContainerClientMethods for ContainerClient {
-    async fn read(
+    fn read(
         &self,
 
         #[allow(unused_variables)]
         // This is a documented public API so prefixing with '_' is undesirable.
         options: Option<ReadContainerOptions>,
-    ) -> azure_core::Result<azure_core::Response<ContainerProperties>> {
-        let mut req = Request::new(self.container_url.clone(), azure_core::Method::Get);
+    ) -> azure_core::ResponseFuture<ContainerProperties> {
+        let req = Request::new(self.container_url.clone(), azure_core::Method::Get);
         self.pipeline
-            .send(Context::new(), &mut req, ResourceType::Containers)
-            .await
+            .send(Context::new(), req, ResourceType::Containers)
     }
 
     fn query_items<T: DeserializeOwned + Send>(
@@ -159,16 +155,6 @@ impl ContainerClientMethods for ContainerClient {
             documents: Vec<M>,
         }
 
-        // We have to manually implement Model, because the derive macro doesn't support auto-inferring type and lifetime bounds.
-        // See https://github.com/Azure/azure-sdk-for-rust/issues/1803
-        impl<M: DeserializeOwned> azure_core::Model for QueryResponseModel<M> {
-            async fn from_response_body(
-                body: azure_core::ResponseBody,
-            ) -> typespec_client_core::Result<Self> {
-                body.json().await
-            }
-        }
-
         let mut url = self.container_url.clone();
         url.append_path_segments(["docs"]);
         let mut base_req = Request::new(url, azure_core::Method::Post);
@@ -196,7 +182,7 @@ impl ContainerClientMethods for ContainerClient {
                 }
 
                 let resp = pipeline
-                    .send(Context::new(), &mut req, ResourceType::Items)
+                    .send(Context::new(), req, ResourceType::Items)
                     .await?;
 
                 let query_metrics = resp
@@ -208,7 +194,7 @@ impl ContainerClientMethods for ContainerClient {
                 let continuation_token =
                     resp.headers().get_optional_string(&constants::CONTINUATION);
 
-                let query_response: QueryResponseModel<T> = resp.deserialize_body().await?;
+                let query_response: QueryResponseModel<T> = resp.into_body();
 
                 let query_results = QueryResults {
                     items: query_response.documents,

sdk/cosmos/azure_data_cosmos/src/clients/database_client.rs

@@ -30,17 +30,14 @@ pub trait DatabaseClientMethods {
     /// # async fn doc() {
     /// # use azure_data_cosmos::clients::{DatabaseClient, DatabaseClientMethods};
     /// # let database_client: DatabaseClient = panic!("this is a non-running example");
-    /// let response = database_client.read(None)
-    ///     .await.unwrap()
-    ///     .deserialize_body()
-    ///     .await.unwrap();
+    /// let response = database_client.read(None).await.unwrap();
     /// # }
     /// ```
     #[allow(async_fn_in_trait)] // REASON: See https://github.com/Azure/azure-sdk-for-rust/issues/1796 for detailed justification
-    async fn read(
+    fn read(
         &self,
         options: Option<ReadDatabaseOptions>,
-    ) -> azure_core::Result<azure_core::Response<DatabaseProperties>>;
+    ) -> azure_core::ResponseFuture<DatabaseProperties>;
 
     /// Gets a [`ContainerClient`] that can be used to access the collection with the specified name.
     ///
@@ -70,17 +67,16 @@ impl DatabaseClient {
 }
 
 impl DatabaseClientMethods for DatabaseClient {
-    async fn read(
+    fn read(
         &self,
 
         #[allow(unused_variables)]
         // This is a documented public API so prefixing with '_' is undesirable.
         options: Option<ReadDatabaseOptions>,
-    ) -> azure_core::Result<azure_core::Response<DatabaseProperties>> {
-        let mut req = Request::new(self.database_url.clone(), azure_core::Method::Get);
+    ) -> azure_core::ResponseFuture<DatabaseProperties> {
+        let req = Request::new(self.database_url.clone(), azure_core::Method::Get);
         self.pipeline
-            .send(Context::new(), &mut req, ResourceType::Databases)
-            .await
+            .send(Context::new(), req, ResourceType::Databases)
     }
 
     fn container_client(&self, name: impl AsRef<str>) -> ContainerClient {

sdk/cosmos/azure_data_cosmos/src/models/mod.rs

@@ -5,7 +5,7 @@
 
 use azure_core::{
     date::{ComponentRange, OffsetDateTime},
-    Continuable, Model,
+    Continuable,
 };
 use serde::{Deserialize, Serialize};
 
@@ -72,7 +72,7 @@ pub struct SystemProperties {
 /// Properties of a Cosmos DB database.
 ///
 /// Returned by [`DatabaseClient::read()`](crate::clients::DatabaseClient::read()).
-#[derive(Model, Debug, Deserialize)]
+#[derive(Debug, Deserialize)]
 pub struct DatabaseProperties {
     /// The ID of the database.
     pub id: String,
@@ -85,7 +85,7 @@ pub struct DatabaseProperties {
 /// Properties of a Cosmos DB container.
 ///
 /// Returned by [`ContainerClient::read()`](crate::clients::ContainerClient::read()).
-#[derive(Model, Debug, Deserialize)]
+#[derive(Debug, Deserialize)]
 pub struct ContainerProperties {
     /// The ID of the container.
     pub id: String,

sdk/cosmos/azure_data_cosmos/src/pipeline/mod.rs

@@ -6,6 +6,7 @@ mod authorization_policy;
 use std::sync::Arc;
 
 pub(crate) use authorization_policy::{AuthorizationPolicy, ResourceType};
+use serde::de::DeserializeOwned;
 
 /// Newtype that wraps an Azure Core pipeline to provide a Cosmos-specific pipeline which configures our authorization policy and enforces that a [`ResourceType`] is set on the context.
 #[derive(Debug, Clone)]
@@ -25,13 +26,14 @@ impl CosmosPipeline {
         ))
     }
 
-    pub async fn send<T>(
-        &self,
-        ctx: azure_core::Context<'_>,
-        request: &mut azure_core::Request,
+    pub fn send<'a, T: DeserializeOwned>(
+        &'a self,
+        ctx: azure_core::Context<'a>,
+        request: azure_core::Request,
         resource_type: ResourceType,
-    ) -> azure_core::Result<azure_core::Response<T>> {
+    ) -> azure_core::ResponseFuture<'a, T> {
+        // We know all our APIs use JSON, so we can just create a wrapper that calls '.json' for us.
         let ctx = ctx.with_value(resource_type);
-        self.0.send(&ctx, request).await
+        self.0.send(ctx, request).json()
     }
 }

sdk/identity/azure_identity/src/credentials/client_certificate_credentials.rs

@@ -21,7 +21,6 @@ use openssl::{
 use serde::Deserialize;
 use std::{str, sync::Arc, time::Duration};
 use time::OffsetDateTime;
-use typespec_client_core::http::Model;
 use url::form_urlencoded;
 
 /// Refresh time to use in seconds.
@@ -255,7 +254,7 @@ impl ClientCertificateCredential {
             return Err(http_response_from_body(rsp_status, &rsp_body).into_error());
         }
 
-        let response: AadTokenResponse = rsp.deserialize_body_into().await?;
+        let response: AadTokenResponse = rsp.into_body().json().await?;
         Ok(AccessToken::new(
             response.access_token,
             OffsetDateTime::now_utc() + Duration::from_secs(response.expires_in),
@@ -326,7 +325,7 @@ impl ClientCertificateCredential {
     }
 }
 
-#[derive(Model, Deserialize, Debug, Default)]
+#[derive(Deserialize, Debug, Default)]
 #[serde(default)]
 struct AadTokenResponse {
     token_type: String,

sdk/identity/azure_identity/src/federated_credentials_flow/mod.rs

@@ -49,7 +49,7 @@ pub async fn authorize(
     let rsp_status = rsp.status();
     debug!("rsp_status == {:?}", rsp_status);
     if rsp_status.is_success() {
-        rsp.deserialize_body_into().await
+        rsp.into_body().json().await
     } else {
         let rsp_body = rsp.into_body().collect().await?;
         let text = std::str::from_utf8(&rsp_body)?;

sdk/identity/azure_identity/src/federated_credentials_flow/response.rs

@@ -6,7 +6,6 @@
 use azure_core::credentials::Secret;
 use serde::{Deserialize, Deserializer};
 use time::OffsetDateTime;
-use typespec_client_core::Model;
 
 #[derive(Debug, Clone, Deserialize)]
 struct RawLoginResponse {
@@ -19,7 +18,7 @@ struct RawLoginResponse {
     access_token: String,
 }
 
-#[derive(Model, Debug, Clone)]
+#[derive(Debug, Clone)]
 pub struct LoginResponse {
     pub token_type: String,
     pub expires_in: u64,

sdk/identity/azure_identity/src/refresh_token.rs

@@ -14,7 +14,6 @@ use azure_core::{
 use serde::Deserialize;
 use std::fmt;
 use std::sync::Arc;
-use typespec_client_core::Model;
 use url::form_urlencoded;
 
 /// Exchange a refresh token for a new access token and refresh token.
@@ -54,9 +53,7 @@ pub async fn exchange(
     let rsp_status = rsp.status();
 
     if rsp_status.is_success() {
-        rsp.deserialize_body_into()
-            .await
-            .map_kind(ErrorKind::Credential)
+        rsp.into_body().json().await.map_kind(ErrorKind::Credential)
     } else {
         let rsp_body = rsp.into_body().collect().await?;
         let token_error: RefreshTokenError =
@@ -67,7 +64,7 @@ pub async fn exchange(
 
 /// A refresh token
 #[allow(dead_code)]
-#[derive(Model, Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct RefreshTokenResponse {
     token_type: String,
     #[serde(rename = "scope", deserialize_with = "deserialize::split")]

sdk/typespec/typespec_client_core/Cargo.toml

@@ -41,7 +41,6 @@ tokio = { workspace = true, features = ["macros", "rt", "time"] }
 [dev-dependencies]
 once_cell.workspace = true
 tokio.workspace = true
-typespec_derive.workspace = true
 
 [features]
 default = [

sdk/typespec/typespec_client_core/src/error/http_error.rs

@@ -25,7 +25,7 @@ impl HttpError {
     /// Create an error from an HTTP response.
     ///
     /// This does not check whether the response was successful and should only be used with unsuccessful responses.
-    pub async fn new(response: Response<()>) -> Self {
+    pub async fn new(response: Response) -> Self {
         let status = response.status();
         let headers: HashMap<String, String> = response
             .headers()

sdk/typespec/typespec_client_core/src/http/clients/reqwest.rs

@@ -4,8 +4,7 @@
 use crate::http::{
     headers::{HeaderName, HeaderValue, Headers},
     request::{Body, Request},
-    response::PinnedStream,
-    HttpClient, Method, Response, StatusCode,
+    HttpClient, Method, PinnedStream, Response, StatusCode,
 };
 use async_trait::async_trait;
 use futures::TryStreamExt;
@@ -77,7 +76,11 @@ impl HttpClient for ::reqwest::Client {
             )
         }));
 
-        Ok(Response::new(try_from_status(status)?, headers, body))
+        Ok(Response::from_stream(
+            try_from_status(status)?,
+            headers,
+            body,
+        ))
     }
 }