Struct Request

pub struct Request { /* private fields */ }

A unified request object that can represent both incoming and outgoing requests.

This should be used in favor of IncomingRequest and OutgoingRequest when there is no need for streaming bodies.

Examples

Read the method, a header, and the body an incoming HTTP request, without streaming:

fn handle_request(req: Request) -> anyhow::Result<Response> {
    let method = req.method();
    let content_type = req.header("content-type");
    if *method == Method::Post {
        let body = String::from_utf8_lossy(req.body());
    }
    todo!()
}

Send an outgoing GET request (no body) to example.com:

use spin_sdk::http::{Request, Response};

let request = Request::get("https://example.com");
let response: Response = spin_sdk::http::send(request).await?;

Send an outgoing POST request with a non-streaming body to example.com.

use spin_sdk::http::{Request, Response};

let request = Request::post("https://example.com", "it's a-me, Spin")
    .header("content-type", "text/plain")
    .build();
let response: Response = spin_sdk::http::send(request).await?;

Build and send an outgoing request without using the helper shortcut.

use spin_sdk::http::{Method, Request, Response};

let mut request = Request::new(Method::Put, "https://example.com/message/safety");
request.set_header("content-type", "text/plain");
*request.body_mut() = "beware the crocodile".as_bytes().to_vec();
let response: Response = spin_sdk::http::send(request).await?;

Build and send an outgoing request using the fluent builder.

use spin_sdk::http::{Method, Request, Response};

let request = Request::builder()
    .uri("https://example.com/message/motivational")
    .method(Method::Put)
    .header("content-type", "text/plain")
    .body("the capybaras of creativity fly higher than the bluebirds of banality")
    .build();
let response: Response = spin_sdk::http::send(request).await?;

Implementations

impl Request

pub fn new(method: Method, uri: impl Into<String>) -> Self

Creates a new request from a method and uri

pub fn builder() -> RequestBuilder

Creates a RequestBuilder

pub fn get(uri: impl Into<String>) -> RequestBuilder

Creates a RequestBuilder to GET the given uri

pub fn post(uri: impl Into<String>, body: impl IntoBody) -> RequestBuilder

Creates a RequestBuilder to POST the given body to uri

pub fn put(uri: impl Into<String>, body: impl IntoBody) -> RequestBuilder

Creates a RequestBuilder to PUT the given body to uri

pub fn patch(uri: impl Into<String>, body: impl IntoBody) -> RequestBuilder

Creates a RequestBuilder to PATCH the resource specified by uri

pub fn delete(uri: impl Into<String>) -> RequestBuilder

Creates a RequestBuilder to DELETE the resource specified by uri

pub fn method(&self) -> &Method

The request method

pub fn uri(&self) -> &str

The request uri

pub fn path(&self) -> &str

The request uri path

pub fn query(&self) -> &str

The request uri query

pub fn headers(&self) -> impl Iterator<Item = (&str, &HeaderValue)>

The request headers

pub fn header(&self, name: &str) -> Option<&HeaderValue>

Return a header value

Will return None if the header does not exist.

pub fn set_header(&mut self, name: impl Into<String>, value: impl Into<String>)

Set a header

pub fn body(&self) -> &[u8]

The request body

pub fn body_mut(&mut self) -> &mut Vec<u8>

The request body

pub fn into_body(self) -> Vec<u8>

Consume this type and return its body

pub fn path_and_query(&self) -> Option<&str>

The request path and query combined

Trait Implementations

impl TryFromIncomingRequest for Request

type Error = IncomingRequestError

The error if conversion fails

fn try_from_incoming_request<'async_trait>( request: IncomingRequest, ) -> Pin<Box<dyn Future<Output = Result<Self, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait,

Try to turn the IncomingRequest into the implementing type

impl TryFromRequest for Request

type Error = Infallible

The error if the conversion fails

fn try_from_request(req: Request) -> Result<Self, Self::Error>

where Self: Sized,

Try to turn the request into the type

impl TryIntoOutgoingRequest for Request

type Error = Error

The error if the conversion fails

fn try_into_outgoing_request( self, ) -> Result<(OutgoingRequest, Option<Vec<u8>>), Self::Error>

Turn the type into an OutgoingRequest

impl TryIntoRequest for Request

type Error = Infallible

The error if the conversion fails

fn try_into_request(self) -> Result<Request, Self::Error>

Turn self into a Request