Trait ServerFn

pub trait ServerFn: Sized + Send {
    type Client: Client<Self::Error, Self::InputStreamError, Self::OutputStreamError>;
    type Server: Server<Self::Error, Self::InputStreamError, Self::OutputStreamError>;
    type Protocol: Protocol<Self, Self::Output, Self::Client, Self::Server, Self::Error, Self::InputStreamError, Self::OutputStreamError>;
    type Output: Send;
    type Error: FromServerFnError + Send + Sync;
    type InputStreamError: FromServerFnError + Send + Sync;
    type OutputStreamError: FromServerFnError + Send + Sync;

    const PATH: &'static str;

    // Required method
    fn run_body(
        self,
    ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send;

    // Provided methods
    fn url() -> &'static str { ... }
    fn middlewares(    ) -> Vec<Arc<dyn Layer<<Self::Server as Server<Self::Error, Self::InputStreamError, Self::OutputStreamError>>::Request, <Self::Server as Server<Self::Error, Self::InputStreamError, Self::OutputStreamError>>::Response>>> { ... }
}

Expand description

Defines a function that runs only on the server, but can be called from the server or the client.

The type for which ServerFn is implemented is actually the type of the arguments to the function, while the function body itself is implemented in run_body.

This means that Self here is usually a struct, in which each field is an argument to the function. In other words,

#[server]
pub async fn my_function(foo: String, bar: usize) -> Result<usize, ServerFnError> {
    Ok(foo.len() + bar)
}

should expand to

#[derive(Serialize, Deserialize)]
pub struct MyFunction {
    foo: String,
    bar: usize
}

impl ServerFn for MyFunction {
    async fn run_body() -> Result<usize, ServerFnError> {
        Ok(foo.len() + bar)
    }

    // etc.
}

Required Associated Constants§

const PATH: &'static str

A unique path for the server function’s API endpoint, relative to the host, including its prefix.

Required Associated Types§

type Client: Client<Self::Error, Self::InputStreamError, Self::OutputStreamError>

The type of the HTTP client that will send the request from the client side.

For example, this might be gloo-net in the browser, or reqwest for a desktop app.

type Server: Server<Self::Error, Self::InputStreamError, Self::OutputStreamError>

The type of the HTTP server that will send the response from the server side.

For example, this might be axum or actix-web.

type Protocol: Protocol<Self, Self::Output, Self::Client, Self::Server, Self::Error, Self::InputStreamError, Self::OutputStreamError>

The protocol the server function uses to communicate with the client.

type Output: Send

The return type of the server function.

This needs to be converted into ServerResponse on the server side, and converted from ClientResponse when received by the client.

type Error: FromServerFnError + Send + Sync

The type of error in the server function return. Typically ServerFnError, but allowed to be any type that implements FromServerFnError.

type InputStreamError: FromServerFnError + Send + Sync

The type of error in the server function for stream items sent from the client to the server. Typically ServerFnError, but allowed to be any type that implements FromServerFnError.

type OutputStreamError: FromServerFnError + Send + Sync

The type of error in the server function for stream items sent from the server to the client. Typically ServerFnError, but allowed to be any type that implements FromServerFnError.

Required Methods§

fn run_body( self, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send

The body of the server function. This will only run on the server.

Provided Methods§

fn url() -> &'static str

Returns Self::PATH.

fn middlewares() -> Vec<Arc<dyn Layer<<Self::Server as Server<Self::Error, Self::InputStreamError, Self::OutputStreamError>>::Request, <Self::Server as Server<Self::Error, Self::InputStreamError, Self::OutputStreamError>>::Response>>>

Middleware that should be applied to this server function.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Trait ServerFn Copy item path

Required Associated Constants§

const PATH: &'static str

Required Associated Types§

type Client: Client<Self::Error, Self::InputStreamError, Self::OutputStreamError>

type Server: Server<Self::Error, Self::InputStreamError, Self::OutputStreamError>

type Protocol: Protocol<Self, Self::Output, Self::Client, Self::Server, Self::Error, Self::InputStreamError, Self::OutputStreamError>

type Output: Send

type Error: FromServerFnError + Send + Sync

type InputStreamError: FromServerFnError + Send + Sync

type OutputStreamError: FromServerFnError + Send + Sync

Required Methods§

fn run_body( self, ) -> impl Future<Output = Result<Self::Output, Self::Error>> + Send

Provided Methods§

fn url() -> &'static str

fn middlewares() -> Vec<Arc<dyn Layer<<Self::Server as Server<Self::Error, Self::InputStreamError, Self::OutputStreamError>>::Request, <Self::Server as Server<Self::Error, Self::InputStreamError, Self::OutputStreamError>>::Response>>>

Dyn Compatibility§

Implementations on Foreign Types§

impl ServerFn for Document

const PATH: &'static str

type Client = BrowserClient

type Server = AxumServerFnBackend

type Protocol = Http<GetUrl, Post<JsonEncoding>>

type Output = <Result<(DocumentUri, Box<[Css]>, Box<str>), BackendError<ServerFnErrorErr>> as ServerFnMustReturnResult>::Ok

type Error = <Result<(DocumentUri, Box<[Css]>, Box<str>), BackendError<ServerFnErrorErr>> as ServerFnMustReturnResult>::Err

type InputStreamError = <Result<(DocumentUri, Box<[Css]>, Box<str>), BackendError<ServerFnErrorErr>> as ServerFnMustReturnResult>::Err

type OutputStreamError = <Result<(DocumentUri, Box<[Css]>, Box<str>), BackendError<ServerFnErrorErr>> as ServerFnMustReturnResult>::Err

fn middlewares() -> Vec<Arc<dyn Layer<<<Document as ServerFn>::Server as Server<<Document as ServerFn>::Error>>::Request, <<Document as ServerFn>::Server as Server<<Document as ServerFn>::Error>>::Response>>>

fn run_body( self, ) -> impl Future<Output = Result<(DocumentUri, Box<[Css]>, Box<str>), BackendError<ServerFnErrorErr>>> + Send

impl ServerFn for DocumentOf

const PATH: &'static str

type Client = BrowserClient

type Server = AxumServerFnBackend

type Protocol = Http<GetUrl, Post<JsonEncoding>>

type Output = DocumentUri

type Error = BackendError<ServerFnErrorErr>

type InputStreamError = BackendError<ServerFnErrorErr>

type OutputStreamError = BackendError<ServerFnErrorErr>

fn middlewares() -> Vec<Arc<dyn Layer<<<DocumentOf as ServerFn>::Server as Server<<DocumentOf as ServerFn>::Error>>::Request, <<DocumentOf as ServerFn>::Server as Server<<DocumentOf as ServerFn>::Error>>::Response>>>

fn run_body( self, ) -> impl Future<Output = Result<DocumentUri, BackendError<ServerFnErrorErr>>> + Send

impl ServerFn for Fragment

const PATH: &'static str

type Client = BrowserClient

type Server = AxumServerFnBackend

type Protocol = Http<GetUrl, Post<JsonEncoding>>

type Output = <Result<(Uri, Box<[Css]>, Box<str>), BackendError<ServerFnErrorErr>> as ServerFnMustReturnResult>::Ok

type Error = <Result<(Uri, Box<[Css]>, Box<str>), BackendError<ServerFnErrorErr>> as ServerFnMustReturnResult>::Err

type InputStreamError = <Result<(Uri, Box<[Css]>, Box<str>), BackendError<ServerFnErrorErr>> as ServerFnMustReturnResult>::Err

type OutputStreamError = <Result<(Uri, Box<[Css]>, Box<str>), BackendError<ServerFnErrorErr>> as ServerFnMustReturnResult>::Err

fn middlewares() -> Vec<Arc<dyn Layer<<<Fragment as ServerFn>::Server as Server<<Fragment as ServerFn>::Error>>::Request, <<Fragment as ServerFn>::Server as Server<<Fragment as ServerFn>::Error>>::Response>>>

fn run_body( self, ) -> impl Future<Output = Result<(Uri, Box<[Css]>, Box<str>), BackendError<ServerFnErrorErr>>> + Send

impl ServerFn for GetDocument

const PATH: &'static str

type Client = BrowserClient

type Server = AxumServerFnBackend

type Protocol = Http<GetUrl, Post<JsonEncoding>>

type Output = <Result<Document, BackendError<ServerFnErrorErr>> as ServerFnMustReturnResult>::Ok

type Error = <Result<Document, BackendError<ServerFnErrorErr>> as ServerFnMustReturnResult>::Err

type InputStreamError = <Result<Document, BackendError<ServerFnErrorErr>> as ServerFnMustReturnResult>::Err

type OutputStreamError = <Result<Document, BackendError<ServerFnErrorErr>> as ServerFnMustReturnResult>::Err

fn middlewares() -> Vec<Arc<dyn Layer<<<GetDocument as ServerFn>::Server as Server<<GetDocument as ServerFn>::Error>>::Request, <<GetDocument as ServerFn>::Server as Server<<GetDocument as ServerFn>::Error>>::Response>>>

fn run_body( self, ) -> impl Future<Output = Result<Document, BackendError<ServerFnErrorErr>>> + Send

impl ServerFn for GetModule

const PATH: &'static str

type Client = BrowserClient

type Server = AxumServerFnBackend

type Protocol = Http<GetUrl, Post<JsonEncoding>>

type Output = ModuleLike

type Error = BackendError<ServerFnErrorErr>

type InputStreamError = BackendError<ServerFnErrorErr>

type OutputStreamError = BackendError<ServerFnErrorErr>

fn middlewares() -> Vec<Arc<dyn Layer<<<GetModule as ServerFn>::Server as Server<<GetModule as ServerFn>::Error>>::Request, <<GetModule as ServerFn>::Server as Server<<GetModule as ServerFn>::Error>>::Response>>>

fn run_body( self, ) -> impl Future<Output = Result<ModuleLike, BackendError<ServerFnErrorErr>>> + Send

impl ServerFn for GetQuiz

const PATH: &'static str

type Client = BrowserClient

type Server = AxumServerFnBackend

type Protocol = Http<GetUrl, Post<JsonEncoding>>

type Output = <Result<Quiz, ServerFnError<String>> as ServerFnMustReturnResult>::Ok

type Error = <Result<Quiz, ServerFnError<String>> as ServerFnMustReturnResult>::Err

Trait ServerFn