Some help on implementing route_service

[vibrantsparrow]

hello, I am getting the following error when trying to implement route_service and I am also new to Rust:

the trait bound impl std::future::Future<Output = Router<AppState>>: Service<axum::http::Request<axum::body::Body>> is not satisfied

code below

#[derive(Serialize, Deserialize, Clone, PartialEq, Debug, sqlx::FromRow)]
pub struct Toy {
    pub id: i32,
    pub name: String,
}

pub async fn all_toys(connection_pool: &Pool<Postgres>) -> Result<Vec<Toy>, AppError> {
    if let Ok(guns) = sqlx::query_as::<_, Toy>("SELECT * FROM toy ORDER BY id")
        .fetch_all(connection_pool)
        .await {
            Ok(guns)
        } else {
            Err(AppError::InternalServerError)   
        }
}

async fn get_all_toys(State(state): State<AppState>) -> Result<Json<Vec<Toy>>, StatusCode> {
    if let Ok(toys) = all_toys(&state.database_pool.pool).await {
        Ok(Json(toys))
    } else {
        Err(StatusCode::SERVICE_UNAVAILABLE)
    }
}

pub async fn toys_service(state: AppState) -> Router<AppState> {
    Router::new()
        .route("/", get(get_all_toys))
        .with_state(state)
}

// Configure the application router
let app = Router::new()
// the trait bound `impl std::future::Future<Output = Router<AppState>>: Service<axum::http::Request<axum::body::Body>>` is not satisfied on the toys_service call below
    .route_service("/v1/toys", toys_service(state)) 
    .route("/", get(root))
    .fallback(handler_404)
    .with_state(state);

Any help would be great.

[jplatte]

It looks like you need nest, not route_service, for your use case.

There is then also no need for you to pass the state to your function, just remove the with_state call within toys_service (leave the function signature as is!) and it should be propagated.

[vibrantsparrow]

thanks for the quick reply @jplatte

not sure if this changes your answer to instead use nest but I wanted to also add a bit more:

pub async fn toys_service(state: AppState) -> Router<AppState> {
    Router::new()
        .route("/", get(get_all_toys))
        .route("/:id", get(get_toy))
        .route("/add", post(add_toy))
        .route("/edit", put(edit_toy))
        .route("/remove/:id", delete(remove_toy))
       .with_state(state)
}

pub async fn tools_service(state: AppState) -> Router<AppState> {
    Router::new()
        .route("/", get(get_all_tools))
        .route("/:id", get(get_tool))
        .route("/add", post(add_tool))
        .route("/edit", put(edit_tool))
        .route("/remove/:id", delete(remove_tool))
       .with_state(state)
}

// Configure the application router
let app = Router::new()
    .route_service("/v1/toys", toys_service(state)) 
    .route_service("/v1/tools", tools_service(state)) 
    .route("/", get(root))
    .fallback(handler_404)
    .with_state(state);
 

So would nest still be the way to go here? FWIW, I saw route_service used in a dated YT tutorial that looked promising.

[jplatte]

Please read the API documentation for these methods, it explains all the details: https://docs.rs/axum/latest/axum/struct.Router.html

[vibrantsparrow]

Yes I have, but the tutorial that I mentioned didn't discuss using service_fn with route_service. It was likely prior to axum 0.6.0 before the State extractor was introduced; he uses the Extension extractor quite a bit in that tutorial. But all seems to compile with nest, so thanks again.