Struct WebContext

pub struct WebContext;

middleware for bridging xitca-http and xitca-web types. useful for utilizing xitca-web when manually constructing http services.

Examples

use xitca_http::util::{
    middleware::context::ContextBuilder,
    service::{handler::handler_service, route::get, Router}
};
use xitca_service::{Service, ServiceExt};
use xitca_web::{error::Error, handler::state::StateRef};

// handler function depending on xitca-web types.
async fn handler(StateRef(_): StateRef<'_, ()>) -> Error {
    xitca_web::error::ErrorStatus::bad_request().into()
}

// low level router from xitca-http
let router = Router::new()
    // utilize handler function with xitca-web types
    .insert("/", get(handler_service(handler)))
    // utilize xitca-web's middleware to xitca-http's router
    .enclosed(xitca_web::middleware::CatchUnwind)
    // converting xitca-http types to xitca-web types with web context middleware.
    .enclosed(xitca_web::middleware::WebContext)
    // xitca-http's context builder middleware is also needed for helping type conversion.
    // this middleware is tasked with constructing typed application state and pass down it
    // to xitca_web's WebContext middleware. In case of absence of application state a tuple
    // is constructed to act as the default type.
    .enclosed(ContextBuilder::new(|| async { Ok::<_, std::convert::Infallible>(()) }));

// call the router service and observe the output. in real world the service caller should be a http
// library and server.
let res = router
    .call(())
    .await
    .unwrap()
    .call(Default::default())
    .await
    .unwrap();

assert_eq!(res.status(), xitca_http::http::StatusCode::BAD_REQUEST);

Trait Implementations

impl<S, E> Service<Result<S, E>> for WebContext

type Response = WebContextService<S>

The Ok part of output future.

type Error = E

The Err part of output future.

async fn call(&self, res: Result<S, E>) -> Result<Self::Response, Self::Error>