Accessing a form in middleware

[yatesco]

Hi - in my handlers I accept a Form(form): Form<MyStruct> which works fine. However, I now want to pre-process that form in some middleware, before the handler gets it's grubby mitts on it.

Is this possible? I know I can get extensions in the middleware via req.extensions(), but req.extensions().get::<MyStruct> always returns none. Do I have to build the Form myself or is there a trick I can use?

Thanks!

[davidpdrsn]

Its possible but hard since the middleware would have to consume the request body and insert it back before calling the handler.

Instead I'd recommend writing your own extractor that internally calls Form and does whatever processing needed there. Then you can use that extractor in your handlers instead.

[yatesco]

Thanks @davidpdrsn. Do you happen to have a pointer to the existing code I could crib from?

[jplatte]

The custom_extractor module in the customize-extractor-error example does something similar, except it does post-processing of the error path rather pre-processing (or post-extractor processing) on the happy path.

[yatesco]

thanks @jplatte. I ended up hooking up cobbling together something that worked:

• I have a RawActionForm which is populated by the existing Form extractor
• I then process this and create the actual ActionForm which is used by the handlers:

    #[async_trait]
    impl<B> FromRequest<B> for ActionFormExtractor
    where
        B: HttpBody + Send,
        B::Data: Send,
        B::Error: Into<BoxError>,
    {
        type Rejection = (StatusCode, &'static str);

        async fn from_request(req: &mut RequestParts<B>) -> Result<Self, Self::Rejection> {
            let Form(mut raw_form): Form<RawActionForm> =
                Form::from_request(req).await.map_err(|e| {
                    error!("failed to create raw action form: {}", &e);
                    (StatusCode::BAD_REQUEST, "unknown error")
                })?;
            raw_form.prune();

            let action = serde_json::from_str(&raw_form.action).map_err(|e| {
                error!("error {} parsing JSON: {}", e, &raw_form.action);
                (StatusCode::BAD_REQUEST, "JSON error")
            })?;

            let form = ActionForm {
                action,
                note: raw_form.note.clone(),
                unacceptable_reason_id: raw_form.unacceptable_reason_id,
            };

            Ok(ActionFormExtractor(form))
        }
    }

so the handlers now accept ActionFormExtractor(form): ActionFormExtractor. I'll review the link you posted - thanks!