Axum handler type mismatched when d1 is invoked

[ChihweiLHBird]

Updated question

With @mendess's suggestion, I updated my code to use the state to pass the D1Database object.

But it's still problematic when the get_user call the function that invokes the d1.

use axum::{
    extract::{Json, Query, State},
    routing::get,
    Router,
};
use wasm_bindgen::JsValue;

use serde::{Deserialize, Serialize};
use serde_json::json;
use std::sync::Arc;
use tower_service::Service;
use worker::{event, Context, D1Database, Env, HttpRequest, Result as WorkerResult};

#[derive(Deserialize, Serialize)]
pub struct User {
    pub email: String,
}

struct App {
    d1: D1Database,
}

#[derive(Deserialize)]
struct GetUserInput {
    email: String,
}

pub async fn get_user_with_email(email: &str, app: Arc<App>) -> Result<User, String> {
    let statement = app.d1.prepare("SELECT * FROM users WHERE email = ?1");
    let try_query = statement.bind(&[JsValue::from_str(email)]);

    match try_query {
        Ok(query) => {
            let result = query.first::<User>(None).await;
            match result {
                Ok(user) => match user {
                    Some(user) => Ok(user),
                    None => Err(String::from("Not found")),
                },
                Err(_) => Err(String::from("Not found")),
            }
        }
        Err(_) => Err(String::from("Not found")),
    }
}

async fn get_user(
    State(state): State<Arc<App>>,
    Query(get_user_input): Query<GetUserInput>,
) -> Json<User> {
    // not working
    let user = get_user_with_email(&get_user_input.email, Arc::clone(&state)).await;
    match user {
        Ok(user) => Json(user),
        Err(_) => Json(User {
            email: String::from("Not found"),
        }),
    }

    // working:
    // Json(User { email: String::from("Not found") })
}

fn router(d1: D1Database) -> Router {
    Router::new()
        .route("/users", get(get_user))
        .with_state(Arc::new(App { d1 }))
}

#[event(fetch)]
async fn fetch(
    req: HttpRequest,
    env: Env,
    ctx: Context,
) -> WorkerResult<axum::http::Response<axum::body::Body>> {
    let d1 = env.d1("binding")?;
    console_error_panic_hook::set_once();
    Ok(router(d1).call(req).await?)
}

Compilation error:

error[E0277]: the trait bound `fn(axum::extract::State<Arc<App>>, Query<GetUserInput>) -> impl Future<Output = axum::Json<User>> {get_user}: Handler<_, _>` is not satisfied
   --> src/lib.rs:65:30
    |
65  |         .route("/users", get(get_user))
    |                          --- ^^^^^^^^ the trait `Handler<_, _>` is not implemented for fn item `fn(axum::extract::State<Arc<App>>, Query<GetUserInput>) -> impl Future<Output = axum::Json<User>> {get_user}`
    |                          |
    |                          required by a bound introduced by this call
    |
    = note: Consider using `#[axum::debug_handler]` to improve the error messag

Note that the debug_handler mentioned here is not useful because of #485.

Removing the invocation to d1 will make it compile:

async fn get_user(
    State(state): State<Arc<App>>,
    Query(get_user_input): Query<GetUserInput>,
) -> Json<User> {
    // not working
    // let user = get_user_with_email(&get_user_input.email, Arc::clone(&state)).await;
    // match user {
    //     Ok(user) => Json(user),
    //     Err(_) => Json(User {
    //         email: String::from("Not found"),
    //     }),
    // }

    // working:
    Json(User { email: String::from("Not found") })
}

Original question

I want to pass the d1 to a request handler, but failed to do so. I am a very beginner to rust.

This is what I initially tried, and got the error borrowed data escapes outside of function d1 escapes the function body here.

async fn get_user(Query(params): Query<HashMap<String, String>>, d1: &D1Database) -> Json<User> {
    // dummy response
    Json(User {
        email: params.get("email").unwrap_or(&String::from("")).to_string(),
    })
}

fn router(d1: &D1Database) -> Router {
    Router::new()
        .route("/users", get(move |params| {get_user(params, &d1)}))
}

#[event(fetch)]
async fn fetch(
    req: HttpRequest,
    env: Env,
    ctx: Context,
) -> WorkerResult<axum::http::Response<axum::body::Body>> {
    let d1 = env.d1("binding")?;
    console_error_panic_hook::set_once();
    Ok(router(&d1).call(req).await?)
}

And then I tried to passing it by value:

async fn get_user(Query(params): Query<HashMap<String, String>>, d1: D1Database) -> Json<User> {
    // dummy response
    Json(User {
        email: params.get("email").unwrap_or(&String::from("")).to_string(),
    })
}

fn router(d1: D1Database) -> Router {
    Router::new()
        .route("/users", get(move |params| {get_user(params, d1)}))
}

#[event(fetch)]
async fn fetch(
    req: HttpRequest,
    env: Env,
    ctx: Context,
) -> WorkerResult<axum::http::Response<axum::body::Body>> {
    let d1 = env.d1("binding")?;
    console_error_panic_hook::set_once();
    Ok(router(d1).call(req).await?)
}

Now it said:

the trait bound `worker::D1Database: Clone` is not satisfied in `{closure@src/lib.rs:46:30: 46:43}`
the following other types implement trait `Handler<T, S>`:
  `Layered<L, H, T, S>` implements `Handler<T, S>`
  `MethodRouter<S>` implements `Handler<(), S>`
required for `{closure@src/lib.rs:46:30: 46:43}` to implement `Handler<(axum_core::extract::private::ViaParts, Query<HashMap<std::string::String, std::string::String>>), ()>`

Is there any other way I can pass the d1? And is the Clone a missing feature (method) of the struct?