Struct ServerBuilder 

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

A builder for composing large APIs from sub-APIs.

Each .mount::<SubAPI>(handlers) call registers a sub-API’s handlers and records the mount at the type level. .build() only compiles when all sub-APIs in the full API type have been mounted.

Example

ServerBuilder::<FullAPI>::new()
    .mount::<UsersAPI>(users_handlers)
    .mount::<OrdersAPI>(orders_handlers)
    .build()
    .serve(addr)
    .await?;

A builder for composing large APIs from sub-APIs with compile-time tracking of both mounted sub-APIs and provided middleware effects.

• A: the full API type
• Mounted: type-level list of mounted sub-APIs (starts as MNil)
• Provided: type-level list of provided effects (starts as ENil)

Implementations

impl<A: ApiSpec> ServerBuilder<A, MNil, ENil>

pub fn new() -> Self

Create a new builder for the given API type.

impl<A: ApiSpec, M, P> ServerBuilder<A, M, P>

pub fn mount<Sub: ApiSpec, H: Serves<Sub>>( self, handlers: H, ) -> ServerBuilder<A, MCons<Sub, M>, P>

Mount a sub-API with its handler tuple.

The type system tracks which sub-APIs have been mounted.

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

Declare that a middleware effect has been provided.

Pair with .layer() to apply the actual middleware. The type system tracks which effects have been provided across all sub-APIs.

pub fn layer<L>(self, layer: L) -> LayeredServerBuilder<A, M, 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.

Typically paired with .provide::<E>() to discharge an effect requirement. The layer wraps the entire router — applied once, covering all mounted sub-APIs.

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

Set shared state accessible via State<T> extractors.

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

Set the maximum request body size in bytes.

pub fn build<MIdx, PIdx>(self) -> Server<A>

where A: AllMounted<M, MIdx> + AllProvided<P, PIdx>,

Finalize the server.

Only compiles when:

• All sub-APIs in the full API type have been mounted
• All Requires<E, _> effects have been provided

Trait Implementations

impl<A: ApiSpec> Default for ServerBuilder<A, MNil, ENil>

fn default() -> Self

Returns the “default value” for a type.