Attribute Macro server 

#[server]

Usage

#[server]
async fn blog_posts(category: String) -> Result<Vec<BlogPost>> {
    let posts = load_posts(&category).await?;
    // maybe do some other work
    Ok(posts)
}

Named Arguments

You can use any combination of the following named arguments:

• endpoint: a prefix at which the server function handler will be mounted (defaults to /api). Example: endpoint = "/my_api/my_serverfn".
• input: the encoding for the arguments, defaults to Json<T>
  • You may customize the encoding of the arguments by specifying a different type for input.
  • Any axum IntoRequest extractor can be used here, and dioxus provides
    • Json<T>: The default axum Json extractor that decodes JSON-encoded request bodies.
    • Cbor<T>: A custom axum Cbor extractor that decodes CBOR-encoded request bodies.
    • MessagePack<T>: A custom axum MessagePack extractor that decodes MessagePack-encoded request bodies.
• output: the encoding for the response (defaults to Json).
  • The output argument specifies how the server should encode the response data.
  • Acceptable values include:
    • Json: A response encoded as JSON (default). This is ideal for most web applications.
    • Cbor: A response encoded in the CBOR format for efficient, binary-encoded data.
• client: a custom Client implementation that will be used for this server function. This allows customization of the client-side behavior if needed.

Advanced Usage of input and output Fields

The input and output fields allow you to customize how arguments and responses are encoded and decoded. These fields impose specific trait bounds on the types you use. Here are detailed examples for different scenarios:

Adding layers to server functions

Layers allow you to transform the request and response of a server function. You can use layers to add authentication, logging, or other functionality to your server functions. Server functions integrate with the tower ecosystem, so you can use any layer that is compatible with tower.

Common layers include:

• tower_http::trace::TraceLayer for tracing requests and responses
• tower_http::compression::CompressionLayer for compressing large responses
• tower_http::cors::CorsLayer for adding CORS headers to responses
• tower_http::timeout::TimeoutLayer for adding timeouts to requests
• tower_sessions::service::SessionManagerLayer for adding session management to requests

You can add a tower Layer to your server function with the middleware attribute:

#[server]
// The TraceLayer will log all requests to the console
#[middleware(tower_http::timeout::TimeoutLayer::new(std::time::Duration::from_secs(5)))]
pub async fn my_wacky_server_fn(input: Vec<String>) -> ServerFnResult<usize> {
    unimplemented!()
}