accessing the request body from multiple extractors

[SildCave]

Summary

Is there a way to extract something from request body without consuming the body and request itself? Im stuck because I have 2 FromRequest extractors that both want access to req body. I was told that you can achieve that with buffering but its less than perfect solution for me, mainly because of the complexity.

Details of my problem:

let's say I have a following body:

{
    "username": "xyz",
    "password": "123"
    "captcha-code": "kjvivisvbdsvjk78i232r7gfiksbvs"
}

I want to run one extractor to verify the "captcha-code" by performing an http request to cloudflare, then the 2nd extractor would extract user info from the same body.
part of my captcha extractor:

#[derive(Debug, Clone, PartialEq)]
pub enum TurnstileResult {
    Allowed,
    Denied,
}

#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
struct TurnstileRequest {
    #[serde(rename = "cf-turnstile-response")]
    cf_turnstile_response: String,
}

#[async_trait]
impl FromRequest<TurnstileState> for TurnstileResult
{

    type Rejection = TurnstileError;
    async fn from_request(
        req: Request,
        state: &TurnstileState
    ) -> Result<Self, Self::Rejection> {...}

part of my user extractor:

#[async_trait]
impl<S> FromRequest<S> for CredentialBasedRegistrationPayload
{

    type Rejection = RegistrationError;
    async fn from_request(
        req: Request,
        _state: &S
    ) -> Result<Self, Self::Rejection>
    {...}

The endpoint bellow doesnt compile, error (#[axum::debug_handler doesn't help):

error[E0277]: the trait bound `fn(TurnstileResult, CredentialBasedRegistrationPayload) -> impl std::future::Future<Output = (reqwest::StatusCode, std::string::String)> {register_user}: Handler<_, _>` is not satisfied
   --> server/src/routes/mod.rs:71:39
    |
71  |         .route("/register_user", post(registration::register_user))
    |                                  ---- ^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Handler<_, _>` is not implemented for fn item `fn(TurnstileResult, CredentialBasedRegistrationPayload) -> impl std::future::Future<Output = (reqwest::StatusCode, std::string::String)> {register_user}`
    |                                  |
    |                                  required by a bound introduced by this call
    |
    = note: Consider using `#[axum::debug_handler]` to improve the error message
    = help: the following other types implement trait `Handler<T, S>`:
              `IntoHandler<H, T, S>` implements `Handler<T, S>`
              `MethodRouter<S>` implements `Handler<(), S>`
              `axum::handler::Layered<L, H, T, S>` implements `Handler<T, S>`
              `axum_extra::handler::Or<L, R, Lt, Rt, S>` implements `Handler<(M, Lt, Rt), S>`

endpoint:

pub async fn register_user(
    turnstile_result: TurnstileResult,
    registration_form: CredentialBasedRegistrationPayload
) -> (StatusCode, String) {...}

axum version

version = "0.7.5"

[mladedav]

There's only one body which may be a stream so you cannot consume it multiple times. What you can do is combine the two extractors with something like

#[derive(Debug, Clone, PartialEq)]
pub enum TurnstileResult<T> {
    Allowed(T),
    Denied,
}

And in its implementation you can check cloudflare and then return the deserialized body.

Another option would be collecting the body and then using it directly which I assume is what you meant by buffering.