Struct EffectfulServer 

pub struct EffectfulServer<A: ApiSpec, Provided = ENil> { /* private fields */ }

A server builder that tracks which middleware effects have been provided.

The Provided type parameter is a type-level list of effects that have been discharged via .provide::<E>(). It starts as ENil and grows with each .provide() call.

The .serve() method requires A: AllProvided<Provided, _>, ensuring that every Requires<E, _> in the API type has a corresponding .provide::<E>().

Implementations

impl<A: ApiSpec> EffectfulServer<A, ENil>

pub fn new<H: Serves<A>>(handlers: H) -> Self

Create an effectful server from a handler tuple.

The handler tuple must cover every endpoint in the API, just like Server::new.

impl<A: ApiSpec, P> EffectfulServer<A, P>

pub fn provide<E: Effect>(self) -> EffectfulServer<A, ECons<E, P>>

Declare that a middleware effect has been provided.

Each .provide::<E>() call adds E to the type-level list of provided effects. Pair this with a .layer() call that applies the actual middleware.

Example

server
    .provide::<AuthRequired>()
    .layer(auth_layer)

pub fn nest(self, prefix: &str) -> Self

Set a path prefix for all routes.

pub fn max_body_size(self, max: usize) -> Self

Set the maximum request body size in bytes.

pub fn with_state<T: Clone + Send + Sync + 'static>(self, state: T) -> Self

Add shared state accessible via State<T> extractors.

pub fn layer<L>(self, layer: L) -> EffectfulLayeredServer<A, P, L::Service>

where L: Layer<RouterService>, L::Service: Service<Request<Incoming>, Response = Response<BoxBody>, Error = Infallible> + Clone + Send + 'static, <L::Service as Service<Request<Incoming>>>::Future: Send + 'static,

Apply a Tower middleware layer to the server.

The layer wraps the entire router service. This is typically paired with a .provide::<E>() call to discharge an effect requirement.

Example

server
    .provide::<CorsRequired>()
    .layer(CorsLayer::permissive())

pub fn ready<Idx>(self) -> Server<A>

where A: AllProvided<P, Idx>,

Finalize the server and convert to a regular Server.

Only compiles if all required effects have been provided.

pub async fn serve<Idx>( self, addr: SocketAddr, ) -> Result<(), Box<dyn Error + Send + Sync>>

where A: AllProvided<P, Idx>,

Start serving HTTP requests on the given address.

Only compiles if all required effects have been provided via .provide::<E>() calls.

pub async fn serve_with_shutdown<Idx>( self, listener: TcpListener, shutdown: impl Future<Output = ()> + Send, ) -> Result<(), Box<dyn Error + Send + Sync>>

where A: AllProvided<P, Idx>,

Start serving with graceful shutdown.

Only compiles if all required effects have been provided.