I cannot figure out this Handler error

[Luni-4]

Summary

I'm not an axum expert, so I could have done something wrong. Below the relevant piece of code. Thanks in advance for answering my question!

#[derive(Serialize, Deserialize)]
struct Payload(Option<serde_json::Value>);

impl Payload {
    fn new(value: impl Serialize) -> core::result::Result<Self, InternalError> {
        serde_json::to_value(value)
            .map(|value| Self(Some(value)))
            .map_err(|_| InternalError::new("Error"))
    }
}

impl IntoResponse for Payload {
    fn into_response(self) -> Response {
        (StatusCode::OK, Json(self.0)).into_response()
    }
}

#[derive(Serialize, Deserialize)]
struct InternalError(&'static str);

impl InternalError {
    pub fn new(info: &'static str) -> Self {
        Self(info)
    }
}

impl IntoResponse for InternalError {
    fn into_response(self) -> Response {
        (StatusCode::INTERNAL_SERVER_ERROR, Json(self.0)).into_response()
    }
}

#[derive(Clone, Default)]
struct MyState(Arc<Mutex<DummyStruct>>);

#[derive(Serialize)]
struct Response1 {
    parameter1: f64,
    parameter2: bool,
}

async fn first(
    Path((parameter1, parameter2)): Path<(f64, bool)>,
    Extension(state): Extension<MyState>,
) -> Result<Payload, Internalerror> {
    let a = state.0.lock().await;

    Err(InternalError::new("Error"))
}

#[derive(Deserialize)]
struct Inputs {
    parameter1: f64,
    #[serde(rename = "my-name")]
    parameter2: bool,
}

async fn second(
    Json(input): Json<Inputs>,
    Extension(state): Extension<MyState>,
) -> Result<Payload, InternalError> {
    let a = state.0.lock().await;

    Payload::new(Response1 {
        parameter1: input.parameter1,
        parameter2: input.parameter2,
    })
}

#[tokio::main]
async fn main() {
    let first_router: Router = Router::new().route("/first", post(first));

    let second_router: Router = Router::new().route("/second", post(second));
}

I get the following error:

error[E0277]: the trait bound `fn(axum::extract::Path<(f64, bool)>, Extension<MyState>) -> impl Future<Output = Result<Payload, {type error}>> {first}: Handler<_, _>` is not satisfied
   --> src/main.rs:108:67
    |
108 |     let first_router: Router = Router::new().route("/first", post(first));
    |                                                              ---- ^^^^^ the trait `Handler<_, _>` is not implemented for fn item `fn(axum::extract::Path<(f64, bool)>, Extension<MyState>) -> impl Future<Output = Result<Payload, {type error}>> {first}`
    |                                                              |
    |                                                              required by a bound introduced by this call
    |
    = help: the following other types implement trait `Handler<T, S>`:
              <Layered<L, H, T, S> as Handler<T, S>>
              <MethodRouter<S> as Handler<(), S>>
note: required by a bound in `post`
   --> /home/.cargo/registry/src/index.crates.io-6f17d22bba15001f/axum-0.7.5/src/routing/method_routing.rs:389:1
    |
389 | top_level_handler_fn!(post, POST);
    | ^^^^^^^^^^^^^^^^^^^^^^----^^^^^^^
    | |                     |
    | |                     required by a bound in this function
    | required by this bound in `post`
    = note: this error originates in the macro `top_level_handler_fn` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0277]: the trait bound `fn(Json<Inputs>, Extension<MyState>) -> impl Future<Output = Result<Payload, InternalError>> {second}: Handler<_, _>` is not satisfied
   --> src/main.rs:110:69
    |
110 |     let second_router: Router = Router::new().route("/second", post(second));
    |                                                                ---- ^^^^^^ the trait `Handler<_, _>` is not implemented for fn item `fn(Json<Inputs>, Extension<MyState>) -> impl Future<Output = Result<Payload, InternalError>> {second}`
    |                                                                |
    |                                                                required by a bound introduced by this call
    |
    = help: the following other types implement trait `Handler<T, S>`:
              <Layered<L, H, T, S> as Handler<T, S>>
              <MethodRouter<S> as Handler<(), S>>
note: required by a bound in `post`
   --> /home/.cargo/registry/src/index.crates.io-6f17d22bba15001f/axum-0.7.5/src/routing/method_routing.rs:389:1
    |
389 | top_level_handler_fn!(post, POST);
    | ^^^^^^^^^^^^^^^^^^^^^^----^^^^^^^
    | |                     |
    | |                     required by a bound in this function
    | required by this bound in `post`
    = note: this error originates in the macro `top_level_handler_fn` (in Nightly builds, run with -Z macro-backtrace for more info)

axum version

0.7.5

[mladedav]

Try decorating the handler with #[debug_handler], that might provide you with a better error message.

[mladedav]

Looking at it more cloesly, it seems you have a typo in the return type of first: Result<Payload, Internalerror>, the e should be capitalized. Notice that rustc also calls the type Result<Payload, {type error}> since it probably didn't figure out what you meant to write.

It's weird to me though that this would emit an error about Handler not being implemented and not about an unknown type.

[Luni-4]

Thanks a lot! Fixing the typo and changing the first method so that it returns a Payload instead of an Internal error, to be more significant method, resolved the first error.

Yep, I agree, it's weird that the compiler did not raise any error for my typo.

async fn first(
    Path((parameter1, parameter2)): Path<(f64, bool)>,
    Extension(state): Extension<MyState>,
) -> Result<Payload, InternalError> {
    let a = state.0.lock().await;

    Payload::new(Response1 {
        parameter1,
        parameter2,
    })
}

But the second error remains:

error[E0277]: the trait bound `fn(Json<Inputs>, Extension<MyState>) -> impl Future<Output = Result<Payload, InternalError>> {second}: Handler<_, _>` is not satisfied
   --> src/main.rs:113:69
    |
113 |     let second_router: Router = Router::new().route("/second", post(second));
    |                                                                ---- ^^^^^^ the trait `Handler<_, _>` is not implemented for fn item `fn(Json<Inputs>, Extension<MyState>) -> impl Future<Output = Result<Payload, InternalError>> {second}`
    |                                                                |
    |                                                                required by a bound introduced by this call
    |
    = help: the following other types implement trait `Handler<T, S>`:
              <Layered<L, H, T, S> as Handler<T, S>>
              <MethodRouter<S> as Handler<(), S>>
note: required by a bound in `post`
   --> /home/.cargo/registry/src/index.crates.io-6f17d22bba15001f/axum-0.7.5/src/routing/method_routing.rs:389:1
    |
389 | top_level_handler_fn!(post, POST);
    | ^^^^^^^^^^^^^^^^^^^^^^----^^^^^^^
    | |                     |
    | |                     required by a bound in this function
    | required by this bound in `post`
    = note: this error originates in the macro `top_level_handler_fn` (in Nightly builds, run with -Z macro-backtrace for more info)

Some errors have detailed explanations: E0277, E0425.
For more information about an error, try `rustc --explain E0277`.

[Luni-4]

When I use #[debug_handler] I get the following error.

error: `Json<_>` consumes the request body and thus must be the last argument to the handler function
   --> src/main.rs:101:18
    |
101 |     Json(input): Json<Inputs>,

If I follow the advice, everything works correctly

#[debug_handler]
async fn second(
    Extension(state): Extension<MyState>,
    Json(input): Json<Inputs>,
) -> Result<Payload, InternalError> {
    let a = state.0.lock().await;

    Payload::new(Response1 {
        parameter1: input.parameter1,
        parameter2: input.parameter2,
    })
}

Can this error message be shown without using #[debug_handler] ?

[mladedav]

Sadly, no. That's the reason it exists in the first place.

[Luni-4]

I see, thanks a lot for your help!

[sondt]

Try

async fn second(
     Extension(state): Extension<MyState>,
    Json(input): Json<Inputs>
   
) -> Result<Payload, InternalError> {
    let a = state.0.lock().await;

    Payload::new(Response1 {
        parameter1: input.parameter1,
        parameter2: input.parameter2,
    })
}