Layout middleware

[Gashmob]

Hi!

I'm using actix to render html pages and I am currently trying to share the same base template across pages (especially for head tag)

So I have 2 structures: Layout and LayoutExtractor. The first holds data and the second only contains a Rc<RefCell<Layout>>. Then LayoutExtractor implements FromRequest to get the layout from request extensions:

#[derive(Default)]
pub struct Layout {
    pub title: String,
}

pub struct LayoutExtractor(pub Rc<RefCell<Layout>>);

impl FromRequest for LayoutExtractor {
    type Error = Error;
    type Future = Ready<Result<Self, Self::Error>>;

    fn from_request(request: &HttpRequest, _: &mut Payload) -> Self::Future {
        let layout = request
            .extensions()
            .get::<Rc<RefCell<Layout>>>()
            .expect("Layout not inserted by middleware")
            .clone();

        ready(Ok(LayoutExtractor(layout)))
    }
}

Then I have 2 other structures for a middleware. LayoutMiddleware with exactly the same Transform implementation of the doc and LayoutMiddlewareService implementing Service. For this one I first add the Layout in request extensions, then call the service. And the hell comes just after: I retrieve the layout from the service response and use it to render my mustache template. Until this point all is good (almost). My problem is just after, I want to replace the response body with my newly rendered one, so I use map_body but I get a compilation error -> expected 'Result<ServiceResponse<B>, Error>', found 'Result<ServiceResponse<String>, _>' (ideally I will also want to pass the previous body to my renderer in order to include it)

pub struct LayoutMiddlewareService<S> {
    service: S,
}

impl<S, B> Service<ServiceRequest> for LayoutMiddlewareService<S>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: 'static,
{
    type Response = ServiceResponse<B>;
    type Error = Error;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

    forward_ready!(service);

    fn call(&self, req: ServiceRequest) -> Self::Future {
        let layout = Rc::new(RefCell::new(Layout::default()));
        req.extensions_mut().insert(layout.clone());

        let future = self.service.call(req);

        Box::pin(async move {
            let mut response = future.await?;

            let layout_rc = response
                .request()
                .extensions()
                .get::<Rc<RefCell<Layout>>>()
                .expect("Layout not found in response")
                .clone();
            let layout = layout_rc.borrow();

            let rendered: String = render_mustache_template(&layout)?;

            let new_response = response.map_body(|_, body| rendered);

            Ok(new_response)
        })
    }
}

I have searched for discussion here, on stack-overflow and asked AI but found no viable answer. Am I totally wrong on my architecture?

The handler looks like this:

#[get("/")]
pub async fn home(layout: LayoutExtractor) -> impl Responder {
    layout.0.borrow_mut().title = "Title".to_string();

    HttpResponse::Ok().body("Hello World!")
}

[ryux1]

map_body changes the response body type. Your service promises ServiceResponse<B>, but the closure returns a String, so the compiler is correctly producing ServiceResponse<String>.

If the old body is intentionally discarded, change the associated response type in both the Transform and Service implementations. Using BoxBody is convenient for middleware:

use actix_web::body::{BoxBody, MessageBody};

impl<S, B> Service<ServiceRequest> for LayoutMiddlewareService<S>
where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: MessageBody + 'static,
{
    type Response = ServiceResponse<BoxBody>;
    type Error = Error;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

    // ...

    fn call(&self, req: ServiceRequest) -> Self::Future {
        let layout = Rc::new(RefCell::new(Layout::default()));
        req.extensions_mut().insert(layout);
        let future = self.service.call(req);

        Box::pin(async move {
            let response = future.await?;
            let layout = response
                .request()
                .extensions()
                .get::<Rc<RefCell<Layout>>>()
                .expect("Layout not inserted by middleware")
                .clone();

            let rendered = render_mustache_template(&layout.borrow())?;

            Ok(response
                .map_body(|_, _old_body| rendered)
                .map_into_boxed_body())
        })
    }
}

If you need the handler's previous body inside the layout, map_body alone is not enough: its closure is synchronous, while a generic B: MessageBody may be streaming. Split the response with into_parts(), collect the body with body::to_bytes_limited(...).await, render using those bytes, then rebuild it with head.set_body(rendered) and ServiceResponse::new(request, ...). Use a real size limit; collecting an arbitrary response without one can turn this middleware into a memory-exhaustion path.

The request-extension approach can work, but for HTML-only handlers a typed page/view model rendered by a shared layout helper is usually simpler. Middleware has to erase or buffer arbitrary response bodies and also decide what to do with redirects, errors, streams, and non-HTML responses.