Possible to pass extension/args to basic middleware functions?

[ra0x3]

• I'm referencing the following example from the Axum docs here
• I have a piece of code that basically mirrors that example ☝🏽
• However, in my code, (referencing the snippet above) in my authorize_current_user function, I'd like to authorize the user based on the value of some config.
  • This config is used on other route handlers in my code as an Extension
• I'm pretty much having trouble figuring out if it's even possible to add an argument to the auth function (in the snippet above).
• Ideally I'm trying to implement the following:

use axum::{
    Router,
    http::{Request, StatusCode},
    routing::get,
    response::{IntoResponse, Response},
    middleware::{self, Next},
    extract::Extension,
};

#[derive(Clone)]
struct CurrentUser { /* ... */ }

async fn auth<B>(mut req: Request<B>, next: Next<B>, config: Config) -> Result<Response, StatusCode> {
    let auth_header = req.headers()
        .get(http::header::AUTHORIZATION)
        .and_then(|header| header.to_str().ok());

    let auth_header = if let Some(auth_header) = auth_header {
        auth_header
    } else {
        return Err(StatusCode::UNAUTHORIZED);
    };

    if let Some(current_user) = authorize_current_user(auth_header, config).await {
        // insert the current user into a request extension so the handler can
        // extract it
        req.extensions_mut().insert(current_user);
        Ok(next.run(req).await)
    } else {
        Err(StatusCode::UNAUTHORIZED)
    }
}

async fn authorize_current_user(auth_token: &str, config: Config) -> Option<CurrentUser> {
    // authorize the user using `auth_token`, but based on some value in `Config`
}

async fn handler(
    // extract the current user, set by the middleware
    Extension(current_user): Extension<CurrentUser>,
) {
    // ...
}

let app = Router::new()
    .route("/", get(handler))
    .route_layer(middleware::from_fn(auth));

[davidpdrsn]

Yes. See https://docs.rs/axum/latest/axum/middleware/index.html#accessing-state-in-axummiddlewarefrom_fn

[ra0x3]

@davidpdrsn Quick follow up.

• The implementation in the link you shared works perfectly 🙏🏽
• However, one other question I had (not sure if this should be asked in a separate question) is if I use your suggested implementation ☝🏽 , how am I supposed to add an Extension onto my route handler?
• Using your suggested implementation, I still plan to insert an Extension into my request (req.extensions_mut().insert(current_user)) before calling self.inner.call(req).
• However, not really sure if I can just add an Extension in my route handler in order to access that data, similar to how this works with simple state-less middlware functions
• As I'm trying it now, getting some gnarly errors related to the trait Handler<_, _, _> is not implemented for fn item...

[davidpdrsn]

However, one other question I had (not sure if this should be asked in a separate question) is if I use your suggested implementation ☝🏽 , how am I supposed to add an Extension onto my route handler?

Extension is also an extractor so you can just add it as a function argument like any other extractor.

As I'm trying it now, getting some gnarly errors related to the trait Handler<_, _, _> is not implemented for fn item...

Use https://docs.rs/axum/latest/axum/attr.debug_handler.html for those.

[ra0x3]

@davidpdrsn Hopefully this is my last question 😅

• But it seems I'm getting a Missing request extension: Extension of type ___ response
• I have my stateful middleware implementation here (confirming the proper codepath is hit)
• I'm injecting the middleware in question here
• I'm adding that middleware layer onto my router here
• Finally, I have my Extension in question in my handler here
• Everything appears to be hooked up from what I can see (going by the docs)
• I'm pretty certain I'm overlooking something. Just not sure what that something might be, from reading the docs

🤔

(Apologies for not having a more ready minimum reproducible example)

Edit: as expected, was a me issue :)