Struct Http 

pub struct Http<InputProtocol, OutputProtocol>(/* private fields */);

The http protocol with specific input and output encodings for the request and response. This is the default protocol server functions use if no override is set in the server function macro

The http protocol accepts two generic argument that define how the input and output for a server function are turned into HTTP requests and responses. For example, Http<GetUrl, Json> will accept a Url encoded Get request and return a JSON post response.

Example

use serde::{Serialize, Deserialize};
use server_fn::{Http, ServerFnError, codec::{Json, GetUrl}};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Message {
    user: String,
    message: String,
}

// The http protocol can be used on any server function that accepts and returns arguments that implement
// the [`IntoReq`] and [`FromRes`] traits.
//
// In this case, the input and output encodings are [`GetUrl`] and [`Json`], respectively which requires
// the items to implement [`IntoReq<GetUrl, ...>`] and [`FromRes<Json, ...>`]. Both of those implementations
// require the items to implement [`Serialize`] and [`Deserialize`].
#[server(protocol = Http<GetUrl, Json>)]
async fn echo_http(
    input: Message,
) -> Result<Message, ServerFnError> {
    Ok(input)
}

Trait Implementations

impl<InputProtocol, OutputProtocol, Input, Output, Client, Server, E> Protocol<Input, Output, Client, Server, E> for Http<InputProtocol, OutputProtocol>

where Input: IntoReq<InputProtocol, <Client as Client<E>>::Request, E> + FromReq<InputProtocol, <Server as Server<E>>::Request, E> + Send, Output: IntoRes<OutputProtocol, <Server as Server<E>>::Response, E> + FromRes<OutputProtocol, <Client as Client<E>>::Response, E> + Send, E: FromServerFnError, InputProtocol: Encoding, OutputProtocol: Encoding, Client: Client<E>, Server: Server<E>,

const METHOD: Method = InputProtocol::METHOD

The HTTP method used for requests.

async fn run_server<F, Fut>( request: <Server as Server<E>>::Request, server_fn: F, ) -> Result<<Server as Server<E>>::Response, E>

where F: Fn(Input) -> Fut + Send, Fut: Future<Output = Result<Output, E>> + Send,

Run the server function on the server. The implementation should handle deserializing the input, running the server function, and serializing the output.

async fn run_client(path: &str, input: Input) -> Result<Output, E>

where Client: Client<E>,

Run the server function on the client. The implementation should handle serializing the input, sending the request, and deserializing the output.