rust: Add some convenience methods/impls to http types

And update rust outbound http examples to use "simple" types.

- Add `Request::{get,post}` associated functions which cover the most
  common request types.
- `impl TryIntoOutgoingRequest for RequestBuilder` to skip a boilerplate
  `.build()`
- Add `Response::into_builder` to ease returning an updated response.
- `impl Debug for Response` to fix examples

Signed-off-by: Lann Martin <[email protected]>

Author: lann

examples/http-rust-outbound-http/outbound-http-to-same-app/Cargo.lock

@@ -7,11 +7,7 @@ edition = "2021"
 crate-type = ["cdylib"]
 
 [dependencies]
-# Useful crate to handle errors.
 anyhow = "1"
-# Crate to simplify working with bytes.
-http = "0.2"
-# The Spin SDK.
 spin-sdk = { path = "../../../sdk/rust" }
-url = "2"
+
 [workspace]

examples/http-rust-outbound-http/outbound-http-to-same-app/Cargo.toml

@@ -1,21 +1,17 @@
 use anyhow::Result;
 use spin_sdk::{
-    http::{IntoResponse, Request},
+    http::{IntoResponse, Request, Response},
     http_component,
 };
 
 /// Send an HTTP request and return the response.
 #[http_component]
 async fn send_outbound(_req: Request) -> Result<impl IntoResponse> {
-    let mut res: http::Response<String> = spin_sdk::http::send(
-        http::Request::builder()
-            .method("GET")
-            .uri("/hello")
-            .body(())?,
-    )
-    .await?;
-    res.headers_mut()
-        .insert("spin-component", "rust-outbound-http".try_into()?);
-    println!("{:?}", res);
-    Ok(res)
+    let resp: Response = spin_sdk::http::send(Request::get("/hello")).await?;
+    let resp = resp
+        .into_builder()
+        .header("spin-component", "rust-outbound-http")
+        .build();
+    println!("{resp:?}");
+    Ok(resp)
 }

examples/http-rust-outbound-http/outbound-http-to-same-app/src/lib.rs

@@ -7,11 +7,7 @@ edition = "2021"
 crate-type = ["cdylib"]
 
 [dependencies]
-# Useful crate to handle errors.
 anyhow = "1"
-# General-purpose crate with common HTTP types.
-http = "0.2"
-# The Spin SDK.
 spin-sdk = { path = "../../../sdk/rust" }
 
 [workspace]

examples/http-rust-outbound-http/outbound-http/Cargo.lock

@@ -1,21 +1,20 @@
 use anyhow::Result;
 use spin_sdk::{
-    http::{IntoResponse, Request},
+    http::{IntoResponse, Request, Response},
     http_component,
 };
 
 /// Send an HTTP request and return the response.
 #[http_component]
 async fn send_outbound(_req: Request) -> Result<impl IntoResponse> {
-    let mut res: http::Response<String> = spin_sdk::http::send(
-        http::Request::builder()
-            .method("GET")
-            .uri("https://random-data-api.fermyon.app/animals/json")
-            .body(())?,
-    )
+    let resp: Response = spin_sdk::http::send(Request::get(
+        "https://random-data-api.fermyon.app/animals/json",
+    ))
     .await?;
-    res.headers_mut()
-        .insert("spin-component", "rust-outbound-http".try_into()?);
-    println!("{:?}", res);
-    Ok(res)
+    let resp = resp
+        .into_builder()
+        .header("spin-component", "rust-outbound-http")
+        .build();
+    println!("{resp:?}");
+    Ok(resp)
 }

examples/http-rust-outbound-http/outbound-http/Cargo.toml

@@ -34,7 +34,7 @@ pub struct Request {
 }
 
 impl Request {
-    /// Create a new request from a method and uri
+    /// Creates a new request from a method and uri
     pub fn new(method: Method, uri: impl Into<String>) -> Self {
         Self {
             method,
@@ -44,6 +44,23 @@ impl Request {
         }
     }
 
+    /// Creates a [`RequestBuilder`]
+    pub fn builder() -> RequestBuilder {
+        RequestBuilder::new(Method::Get, "/")
+    }
+
+    /// Creates a [`RequestBuilder`] to GET the given `uri`
+    pub fn get(uri: impl Into<String>) -> RequestBuilder {
+        RequestBuilder::new(Method::Get, uri)
+    }
+
+    /// Creates a [`RequestBuilder`] to POST the given `body` to `uri`
+    pub fn post(uri: impl Into<String>, body: impl conversions::IntoBody) -> RequestBuilder {
+        let mut builder = RequestBuilder::new(Method::Post, uri);
+        builder.body(body);
+        builder
+    }
+
     /// The request method
     pub fn method(&self) -> &Method {
         &self.method
@@ -95,11 +112,6 @@ impl Request {
         self.body
     }
 
-    /// Create a request builder
-    pub fn builder() -> RequestBuilder {
-        RequestBuilder::new(Method::Get, "/")
-    }
-
     fn parse_uri(uri: String) -> (Option<hyperium::Uri>, String) {
         (
             hyperium::Uri::try_from(&uri)
@@ -244,11 +256,27 @@ impl Response {
         self.body
     }
 
+    /// Converts this response into a [`ResponseBuilder`]. This can be used to
+    /// update a response before passing it on.
+    pub fn into_builder(self) -> ResponseBuilder {
+        ResponseBuilder { response: self }
+    }
+
     fn builder() -> ResponseBuilder {
         ResponseBuilder::new(200)
     }
 }
 
+impl std::fmt::Debug for Response {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Response")
+            .field("status", &self.status)
+            .field("headers", &self.headers)
+            .field("body.len()", &self.body.len())
+            .finish()
+    }
+}
+
 /// A builder for `Response``
 pub struct ResponseBuilder {
     response: Response,

examples/http-rust-outbound-http/outbound-http/src/lib.rs

@@ -4,7 +4,9 @@ use async_trait::async_trait;
 
 use crate::wit::wasi::io::streams;
 
-use super::{Headers, IncomingRequest, IncomingResponse, OutgoingRequest, OutgoingResponse};
+use super::{
+    Headers, IncomingRequest, IncomingResponse, OutgoingRequest, OutgoingResponse, RequestBuilder,
+};
 
 use super::{responses, NonUtf8BodyError, Request, Response};
 
@@ -528,6 +530,16 @@ impl TryIntoOutgoingRequest for Request {
     }
 }
 
+impl TryIntoOutgoingRequest for RequestBuilder {
+    type Error = std::convert::Infallible;
+
+    fn try_into_outgoing_request(
+        mut self,
+    ) -> Result<(OutgoingRequest, Option<Vec<u8>>), Self::Error> {
+        self.build().try_into_outgoing_request()
+    }
+}
+
 #[cfg(feature = "http")]
 impl<B> TryIntoOutgoingRequest for hyperium::Request<B>
 where