Unsatisfied bound with generic router, handler, and state

[uckelman]

I'm trying to make a generic router using generic state, similar to #2184.

This doesn't compile:

use axum::{
    Router,
    extract::{FromRef, State},
    routing::get
};

trait DB: Clone + Send + Sync + 'static {
    fn value(&self) -> u32;
}

trait AppState: Clone + Send + Sync + 'static {
    type Database: DB; 
}

#[derive(Clone)]
struct DBImpl { }

impl DB for DBImpl {
    fn value(&self) -> u32 {
        5
    }
}

#[derive(Clone)]
struct AppStateImpl<D: DB> {
    database: D
}

impl<D: DB> AppState for AppStateImpl<D> {
    type Database = D;
}

impl FromRef<AppStateImpl<DBImpl>> for DBImpl {
    fn from_ref(input: &AppStateImpl<DBImpl>) -> DBImpl {
        input.database.clone()
    }
}

async fn projects_get<D: DB>(State(db): State<D>) -> u32 {
    db.value()
}

fn routes<S: AppState>() -> Router<S>
{
    Router::new()
        .route(
            "/projects",
            get(projects_get::<S::Database>)
        )
}

#[tokio::main]
async fn main() {
    let state = AppStateImpl {
        database: DBImpl { }
    };

    let app: Router<()> = routes::<AppStateImpl<DBImpl>>().with_state(state);
}

I get the following error:

   Compiling test v0.1.0 (/home/uckelman/projects/VASSAL/V4/api/test)
error[E0277]: the trait bound `fn(State<<S as AppState>::Database>) -> impl Future<Output = u32> {projects_get::<<S as AppState>::Database>}: Handler<_, _, _>` is not satisfied
   --> src/main.rs:48:17
    |
48  |             get(projects_get::<S::Database>)
    |             --- ^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Handler<_, _, _>` is not implemented for fn item `fn(State<<S as AppState>::Database>) -> impl Future<Output = u32> {projects_get::<<S as AppState>::Database>}`
    |             |
    |             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, B>`:
              <Layered<L, H, T, S, B, B2> as Handler<T, S, B2>>
              <MethodRouter<S, B> as Handler<(), S, B>>
note: required by a bound in `axum::routing::get`
   --> /home/uckelman/.cargo/registry/src/index.crates.io-6f17d22bba15001f/axum-0.6.20/src/routing/method_routing.rs:403:1
    |
403 | top_level_handler_fn!(get, GET);
    | ^^^^^^^^^^^^^^^^^^^^^^---^^^^^^
    | |                     |
    | |                     required by a bound in this function
    | required by this bound in `get`
    = note: this error originates in the macro `top_level_handler_fn` (in Nightly builds, run with -Z macro-backtrace for more info)

For more information about this error, try `rustc --explain E0277`.
error: could not compile `test` (bin "test" test) due to previous error

I can't use #[axum::debug_handler] as suggested, because that doesn't work for generic functions. What bound am I not satisfying? The error message seems not to say what it is.

[davidpdrsn]

I’m not sure and I’m currently traveling so don’t have access to a computer where I can try stuff.

I’d recommend using a trait object instead for this though. It’s probably gonna be simpler.

Try asking in discordDiscord instead.

[uckelman]

The immediate problem, suggested on Discord, was totally unrelated: u32 doesn't implmenet IntoResult. That hadn't occurred to me, because I didn't care at all about the handler return type for this example and picked u32 only because it's shorter to type than &'static str, which does implement IntoResult.

This will compile:

use axum::{
    Router,
    extract::State,
    routing::get
};

trait DB: Clone + Send + Sync {
    fn value(&self) -> &'static str;
}

#[derive(Clone)]
struct DBImpl {}

impl DB for DBImpl {
    fn value(&self) -> &'static str {
        "real"
    }
}

async fn projects_get<D: DB + 'static>(State(db): State<D>) -> &'static str {
    db.value()
}

fn routes<D: DB + 'static>() -> Router<D>
{
    Router::new()
        .route(
            "/projects",
            get(projects_get::<D>)
        )
}

#[tokio::main]
async fn main() {
    let db = DBImpl {};
    let app: Router = routes::<DBImpl>().with_state(db);
}

#[cfg(test)]
mod test {
    use super::*;

    use axum::{
        body::Body,
        http::{Method, Request, StatusCode}
    };
    use tower::ServiceExt; // for oneshot

    #[derive(Clone)]
    struct FakeDBImpl {}

    impl DB for FakeDBImpl {
         fn value(&self) -> &'static str {
            "test"
        }
    }

    #[tokio::test]
    async fn projects_get_ok() {
        let db = FakeDBImpl {};

        let app: Router = routes::<FakeDBImpl>().with_state(db);

        let response = app
            .oneshot(
                Request::builder()
                    .method(Method::GET)
                    .uri(&format!("/projects"))
                    .body(Body::empty())
                    .unwrap()
            )
            .await
            .unwrap();

        assert_eq!(response.status(), StatusCode::OK);

        let body = hyper::body::to_bytes(response.into_body()).await.unwrap();
        assert_eq!(&body[..], b"test");
    }
}

I can make my test double as I intended.

The second problem is that it seems impossible (?) to implement FromRef for a generic type, so this stops working if I want to extract anything nested.

[davidpdrsn]

The second problem is that it seems impossible (?) to implement FromRef for a generic type, so this stops working if I want to extract anything nested.

Yep that’s not possible. Would lead to overlapping impls