Using AppState in extractor

[alexandrepossebom]

Guys, do you know if have a way to use AppState inside extractor?

#[async_trait]
impl<S> FromRequestParts<S> for Claims
where
    S: Send + Sync,
{
    type Rejection = AppError;
    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
        let TypedHeader(Authorization(bearer)) = parts
            .extract::<TypedHeader<Authorization<Bearer>>>()
            .await
            .map_err(|_| AppError::InvalidToken)?;

        let token_data = decode::<Claims>(bearer.token(), &KEYS.decoding, &Validation::default()).map_err(|_| AppError::InvalidToken)?;

       // Here I need AppState to check in redis if token is valid and use database to update last_activity.

        Ok(token_data.claims)
    }
}

[davidpdrsn]

S in FromRequestParts<S> is the state. So you can replace that with FromRequestParts<AppState>.

[alexandrepossebom]

Thank you for reply but now I got different problem:

the trait `FromRef<Arc<AppState>>` is not implemented for `AppState`

[davidpdrsn]

well then FromRequestParts<Arc<AppState>>

[alexandrepossebom]

I think I did it

Thank you a lot @davidpdrsn

#[async_trait]
impl<S> FromRequestParts<S> for Claims
where
    Arc<AppState>: FromRef<S>,
    S: Send + Sync,
{
    type Rejection = AppError;

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        // Extract the token from the authorization header
        let TypedHeader(Authorization(bearer)) = parts.extract::<TypedHeader<Authorization<Bearer>>>().await.map_err(|e| {
            dbg!(e);
            AppError::InvalidToken
        })?;

        // Decode the employee data
        let token_data = decode::<Claims>(bearer.token(), &KEYS.decoding, &Validation::default()).map_err(|e| {
            dbg!(e);
            AppError::InvalidToken
        })?;

        // Check if the employee exists
        let state = Arc::from_ref(state);
        let employee = state.employee_repo.get_employee_by_id(token_data.claims.id).await.map_err(|e| {
            dbg!(e);
            AppError::InvalidToken
        })?;

        println!("Employee: {}", employee.name);

        Ok(token_data.claims)
    }
}

[zjhsd2007]

I also encountered such a problem. After adjusting like you did, it still didn't work and reported an error.
the trait bound Arc: FromRef<()> is not satisfied

[adamanteye]

I came acrros the same problem as you did and had it solved by referring to #1373 and #1342, it turned out to be that you as well as I are using from_extractor, which resulted in missing generic S and then raised "the trait bound AppState: FromRef<()> is not satisfied".

Here is a working example:

use std::convert::Infallible;

use axum::{
    async_trait,
    extract::{FromRef, FromRequestParts},
    http::request::Parts,
    middleware,
    routing::get,
};

#[derive(Clone)]
struct AppState;

struct UserToken;

#[async_trait]
impl<S> FromRequestParts<S> for UserToken
where
    S: Send + Sync,
    AppState: FromRef<S>,
{
    type Rejection = Infallible;
    async fn from_request_parts(_parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
        Ok(Self)
    }
}

async fn handler() -> &'static str {
    "ok"
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let state = AppState {};
    let auth = middleware::from_extractor_with_state::<UserToken, AppState>(state.clone());
    let app = axum::Router::new()
        .route("/", get(handler))
        .route_layer(auth.clone());
    let addr: std::net::SocketAddr = "127.0.0.1:1234".parse().expect("Invalid address");
    let listener = tokio::net::TcpListener::bind(addr).await?;
    axum::serve(listener, app).await.expect("failed to run app");
    Ok(())
}

[package]
name = "tmp"
version = "0.1.0"
edition = "2021"

[dependencies]
axum = "0.7.4"
axum-extra = "0.9.2"
tokio = { version = "1.36.0", features = ["rt-multi-thread"] }

by writing like this the error will be reproduced:

#[async_trait]
impl<S> FromRequestParts<S> for UserToken
where
    S: Send + Sync,
    std::sync::Arc<AppState>: FromRef<S>,
// other code
let auth = middleware::from_extractor_with_state::<UserToken, ()>(());