Error the trait Handler<_, _, _> is not implemented for fn item

[uselessscat]

Hello, Im having the following error which I dont know what it means (Im new to rust and axum):

error[E0277]: the trait bound `fn(axum::extract::State<Pool<Postgres>>, Session) -> impl Future<Output = Result<axum::Json<GetUserResponse>, application::errors::Error>> {get_user_by_username}: Handler<_, _, _>` is 
not satisfied
   --> src\drivers\web\app.rs:17:29
    |
17  |         .route("/user", get(users_routes::get_user_by_username))
    |                         --- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Handler<_, _, _>` is not implemented for fn item `fn(axum::extract::State<Pool<Postgres>>, Session) -> impl Future<Output = Result<axum::Json<GetUserResponse>, application::errors::Error>> {get_user_by_username}`
    |                         |
    |                         required by a bound introduced by this call
    |
    = help: the trait `Handler<T, S, B2>` is implemented for `Layered<L, H, T, S, B, B2>`
note: required by a bound in `axum::routing::get`
   --> C:\Users\Ariel\.cargo\registry\src\github.com-1ecc6299db9ec823\axum-0.6.4\src\routing\method_routing.rs:403:1
    |
403 | top_level_handler_fn!(get, GET);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `axum::routing::get`
    = note: this error originates in the macro `top_level_handler_fn` (in Nightly builds, run with -Z macro-backtrace for more info)

Here is the important part of the code:

// user-service/src/drivers/web/app.rs
pub async fn run_web_server() {
    let connection_pool: Pool<Postgres> = connection::get_connection_pool().await;

    let router: Router = Router::new()
        .route("/user", get(users_routes::get_user_by_username)) // here is the error
        .with_state(connection_pool);

    let addr = SocketAddr::from(([0, 0, 0, 0], 8000));

    axum::Server::bind(&addr)
        .serve(router.into_make_service())
        .await
        .unwrap();
}

// user-service/src/drivers/web/user/routes.rs
use axum::{extract::State, Json};
use sqlx::PgPool;

use crate::{
    application::users::{
        entities::User, services::UserService,
    },
    drivers::{
        db::users::repository::UserRepository,
        web::{
            auth::jwt::Session,
            errors::Error,
            user::{mappers::UserApiMapper, schemas::GetUserResponse},
        },
    },
};

pub async fn get_user_by_username(
    State(pool): State<PgPool>,
    session: Session,
) -> Result<Json<GetUserResponse>, Error> {
    let user: User = UserService::new(&UserRepository::new(pool))
        .get_user_by_id(session.user_id)
        .await?;

    Ok(Json(UserApiMapper::to_response(user)))
}

// user-service/src/application/users/services.rs
use crate::application::{
    errors::Error,
    users::{entities::User, repositories::AbstractUserRepository},
};

pub struct UserService<'a> {
    user_repository: &'a dyn AbstractUserRepository,
}

impl<'a> UserService<'a> {
    pub fn new(user_repository: &'a impl AbstractUserRepository) -> Self {
        UserService { user_repository }
    }

    pub async fn get_user_by_id(&self, id: i32) -> Result<User, Error> {
        let user = self.user_repository.get_user_by_id(id).await?;

        Ok(user)
    }
}

// user-service/src/drivers/db/users/repository.rs
use async_trait::async_trait;
use sqlx::{Error as SqlxError, Pool, Postgres};

use crate::{
    application::{
        errors::Error,
        users::{entities::User, repositories::AbstractUserRepository},
    },
    drivers::db::users::{mappers::UserDbMapper, models::UserModel},
};

pub struct UserRepository {
    pub db_connection: Pool<Postgres>,
}

impl UserRepository {
    pub fn new(connection: Pool<Postgres>) -> UserRepository {
        UserRepository {
            db_connection: connection,
        }
    }
}

#[async_trait]
impl AbstractUserRepository for UserRepository {
    async fn get_user_by_username(&self, username: &str) -> Result<User, Error> {
        let result = sqlx::query_as::<_, UserModel>("SELECT * FROM users WHERE username = $1")
            .bind(username)
            .fetch_one(&self.db_connection)
            .await;

        match result {
            Ok(user) => Ok(UserDbMapper::to_entity(user)),
            Err(e) => match e {
                SqlxError::RowNotFound => {
                    Err(Error::EntityNotFound(String::from("User not found.")))
                }
                _ => Err(Error::UnknownError(String::from("Unknown error."))),
            },
        }
    }
}

// user-service/src/drivers/web/errors.rs
use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
    Json,
};
use serde_json::json;

pub use crate::application::errors::Error;

impl IntoResponse for Error {
    fn into_response(self) -> Response {
        let (status, error_message) = match self {
            Error::WrongCredentials(s) => (StatusCode::UNAUTHORIZED, s),
            Error::MissingCredentials(s) => (StatusCode::BAD_REQUEST, s),
            Error::SessionCreation(s) => (StatusCode::INTERNAL_SERVER_ERROR, s),
            Error::InvalidSession(s) => (StatusCode::BAD_REQUEST, s),
            Error::EntityNotFound(s) => (StatusCode::NOT_FOUND, s),
            Error::UnknownError(s) => (StatusCode::INTERNAL_SERVER_ERROR, s),
        };

        let body = Json(json!({
            "error": error_message,
        }));

        (status, body).into_response()
    }
}

Im not sure how to debug or how to fix this, thanks in advance!

[davidpdrsn]

Have you tried https://docs.rs/axum/latest/axum/attr.debug_handler.html?

[uselessscat]

I got a new error

error: future cannot be sent between threads safely
  --> src\drivers\web\user\routes.rs:17:1
   |
17 | pub async fn get_user_by_username(
   | ^^^ future returned by `get_user_by_username` is not `Send`
   |
   = help: the trait `Sync` is not implemented for `dyn AbstractUserRepository`
note: future is not `Send` as this value is used across an await
  --> src\drivers\web\user\routes.rs:24:47
   |
22 |     let user = UserService::new(&repository);
   |         ---- has type `UserService<'_>` which is not `Send`
23 |
24 |     match user.get_user_by_id(session.user_id).await {
   |                                               ^^^^^^ await occurs here, with `user` maybe used later
...
28 | }
   | - `user` is later dropped here
note: required by a bound in `__axum_macros_check_get_user_by_username_future::check`
  --> src\drivers\web\user\routes.rs:17:1
   |
17 | pub async fn get_user_by_username(
   | ^^^ required by this bound in `__axum_macros_check_get_user_by_username_future::check`

[davidpdrsn]

Well there you go 😊 The error says UserService needs to be Send. Try changing it to

pub struct UserService<'a> {
    user_repository: &'a dyn AbstractUserRepository + Send + Sync,
}

[uselessscat]

Thanks!!

It only requires the parentheses

pub struct UserService<'a> {
    user_repository: &'a (dyn AbstractUserRepository + Send + Sync),
}

[thanhtschoepe]

@davidpdrsn This solved my problem. Thank you

[peschu123]

Thanks a lot for the hint to the macro :)

i had my function signature like this

pub async fn register(
    Json(credentials): Json<models::auth::User>,
    Extension(pool): Extension<SqlitePool>,
) -> Result<Json<Value>, AppError> {

I didn't understand the error msg.

error[E0277]: the trait bound `fn(axum::Json<User>, Extension<Pool<Sqlite>>) -> impl Future<Output = Result<axum::Json<JsonValue>, AppError>> {controllers::auth::register}: Handler<_, _, _>` is not satisfied
   --> src/main.rs:78:34
    |
78  |         .route("/register", post(controllers::auth::register))
    |                             ---- ^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Handler<_, _, _>` is not implemented for fn item `fn(axum::Json<User>, Extension<Pool<Sqlite>>) -> impl Future<Output = Result<axum::Json<JsonValue>, AppError>> {controllers::auth::register}`

with the macro it was clear(just a stupid mistake):

error: `Json<_>` consumes the request body and thus must be the last argument to the handler function
  --> src/controllers/auth.rs:59:24
   |
59 |     Json(credentials): Json<models::auth::User>,
   |                        ^^^^

correct function signature

pub async fn register(
    Extension(pool): Extension<SqlitePool>,
    Json(credentials): Json<models::auth::User>,
) -> Result<Json<Value>, AppError> {

[lucas-bernardino]

This solved my problem: #438