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>>> { ... }
}

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.

Implementations on Foreign Types

impl ServerFn for GetUsers

const PATH: &'static str

type Client = BrowserClient

type Server = AxumServerFnBackend

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

type Output = Vec<UserData>

type Error = ServerFnError<LoginError>

type InputStreamError = ServerFnError<LoginError>

type OutputStreamError = ServerFnError<LoginError>

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

fn run_body( self, ) -> impl Future<Output = Result<Vec<UserData>, ServerFnError<LoginError>>> + Send

impl ServerFn for Login

const PATH: &'static str

type Client = BrowserClient

type Server = AxumServerFnBackend

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

type Output = Option<LoginState>

type Error = ServerFnError<LoginError>

type InputStreamError = ServerFnError<LoginError>

type OutputStreamError = ServerFnError<LoginError>

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

fn run_body( self, ) -> impl Future<Output = Result<Option<LoginState>, ServerFnError<LoginError>>> + Send

impl ServerFn for LoginStateFn

const PATH: &'static str

type Client = BrowserClient

type Server = AxumServerFnBackend

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

type Output = LoginState

type Error = ServerFnError<String>

type InputStreamError = ServerFnError<String>

type OutputStreamError = ServerFnError<String>

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

fn run_body( self, ) -> impl Future<Output = Result<LoginState, ServerFnError<String>>> + Send

impl ServerFn for Logout

const PATH: &'static str

type Client = BrowserClient

type Server = AxumServerFnBackend

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

type Output = ()

type Error = ServerFnError<LoginError>

type InputStreamError = ServerFnError<LoginError>

type OutputStreamError = ServerFnError<LoginError>

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

fn run_body( self, ) -> impl Future<Output = Result<(), ServerFnError<LoginError>>> + Send

impl ServerFn for SetAdmin

const PATH: &'static str

type Client = BrowserClient

type Server = AxumServerFnBackend

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

type Output = ()

type Error = ServerFnError<LoginError>

type InputStreamError = ServerFnError<LoginError>

type OutputStreamError = ServerFnError<LoginError>

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

fn run_body( self, ) -> impl Future<Output = Result<(), ServerFnError<LoginError>>> + Send

Implementors

impl ServerFn for IsLsp

const PATH: &'static str

type Client = BrowserClient

type Server = AxumServerFnBackend

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

type Output = bool

type Error = ServerFnError

type InputStreamError = ServerFnError

type OutputStreamError = ServerFnError