[6.15] How to access to Extension in Leptos_Axum

[SoapyDev]

Good day,

I looked everywhere I could, but could not find an answer.

Hopefully this is a problem on my side and not one on the framework, or its already fixed in 7.1.

I am attempting to retrieve in a handler a user that was extracted from my database in my middlewear.
In axum I could do it this way (per their documentation) :

async fn extension(Extension(state): Extension<State>) {}

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

So, based on this example and the section on extractors in the leptos book, I would expect this pattern to work.

#[cfg(feature = "ssr")]
pub async fn my_middlewear(
   /* ... */
    mut request: Request,
    next: Next,
) -> Result<impl IntoResponse, HttpError> {  
    /* ... */
    // Insert the user into the request
    request.extensions_mut().insert(user);
    Ok(next.run(request).await)
}

  #[server]
  pub async fn get_user_handler() -> Result<User, ServerFnError> {
      use axum::extract::Extension;
      use leptos_axum::extract;
  
      let Extension(user) : Extension<User> = extract()
          .await
          .map_err(|_| ServerFnError::new("User not found".to_string()))?; 
      
      Ok(user)
  }

What I get as a result is : "should have had Parts provided by the leptos_axum integration" that I can be found in :

leptos/integrations/axum/src/lib.rs

Line 1972 in f9533ab

"should have had Parts provided by the leptos_axum integration",

Am I missing something ?

Thanks for your time,

[gbj]

Hi -- Sorry for the delayed response. I don't have enough experience with Axum extensions or middleware to know whether extensions would behave differently from any other extractor in this situation. That said, the error message here doesn't have to do with the extractor itself, and it would actually bail out before the extractor even runs. I have not seen reports of similar issues, so you may be looking in the wrong place. (For example, are you using a custom handler or something similar that doesn't provide Parts via context as expected?)

I'm happy to look at a minimal reproduction at some point if you have one, but I don't think there's much more I can say than the above for now.

[SoapyDev]

Good day,

Here is a functional version of what I am attempting to do with leptos, but solely in Axum.
Frankly, this is mostly also what I am doing in leptos but with more complexity around (state, middlewears) and the routes being created from App.

To take note that the handler is using Extension as a parameter here, in place of using the extract::<Extension>() utility.

From what I can gather, you suggest that I implement FromRequestParts for User ?

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

// Required to be passed by Extension
#[derive(Clone)]
struct User(&'static str);

// Middleware doing some authentication
async fn auth(mut request: Request, next: Next) -> Result<Response, StatusCode>{
    // Passing the user to the handler
    request.extensions_mut().insert(User("current user"));
    Ok(next.run(request).await)
}

async fn handler(
    // Getting the user from the middleware
    Extension(current_user): Extension<User>,
) {
    println!("Hello, {:?}!", current_user.0);
}

#[tokio::main]
async fn main() {
    
    let app = Router::new()
        .route("/", get(handler))
        .route_layer(middleware::from_fn(auth));
    
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app.into_make_service()).await.unwrap();
}

Again, thank you for your time and no worries for the delays .

[gbj]

Sorry, what I was asking about was an example of it not working, using Leptos, with about the same size/scope of the example you're giving here in which it does work.

[SoapyDev]

Hey, sorry for the wait. It seems this example works actually, so I will have to reexamine why my fully fleshed out solution does not. Thanks for your time.

use leptos::*;

#[derive(Clone)]
struct User(&'static str);

#[cfg(feature = "ssr")]
pub mod ssr {
    use super::User;
    use axum::extract::FromRef;
    use axum::extract::Request;
    use axum::http::StatusCode;
    use axum::middleware::Next;
    use axum::response::Response;
    use leptos::LeptosOptions;

    #[derive(Debug, Clone, FromRef)]
    pub struct AppState {
        pub leptos_options: LeptosOptions,
        // Other states ...
    }

    pub(crate) async fn auth(mut request: Request, next: Next) -> Result<Response, StatusCode> {
        // Passing the user to the handler
        request.extensions_mut().insert(User("current user"));
        Ok(next.run(request).await)
    }
}

#[server(GetUserName)]
async fn get_user_name() -> Result<String, ServerFnError> {

    use axum::extract::Extension;
    use leptos_axum::extract;

    let Extension(user) : Extension<User> = extract()
        .await
        .map_err(|_| ServerFnError::new("User not found".to_string()))?;


    println!("user: {}", user.0);

    Ok(user.0.to_string())
}

#[cfg(feature = "ssr")]
#[tokio::main]
async fn main() {
    use axum::{middleware, Router};
    use crate::{ssr::{auth, AppState}, App};
    use leptos_axum::{generate_route_list, LeptosRoutes};

    let conf = get_configuration(None).await.expect("Could not get leptos server configuration");

    let routes = generate_route_list(App);
    let app_state = AppState {
        leptos_options: conf.leptos_options
    };

    let app = Router::new()
        .leptos_routes(&app_state, routes, App)
        .layer(middleware::from_fn_with_state(
            app_state.clone(),
            auth,
        ))
        .with_state(app_state);

    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app.into_make_service()).await.unwrap();
}

#[cfg(feature = "hydrate")]
#[wasm_bindgen::prelude::wasm_bindgen]
pub fn hydrate() {
    leptos::mount_to_body(App);
}

#[component]
pub fn App() -> impl IntoView {

    let user_name_res = Resource::new(
        move || {},
        move |_| async move {
            get_user_name().await.unwrap_or_default()
        },
    );

    view! {
        <h1>"Hello there"</h1>
    }
}


#[cfg(feature = "hydrate")]
#[wasm_bindgen::prelude::wasm_bindgen]
pub fn hydrate() {
    leptos::mount_to_body(App);
}