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!")
}