How do you do pooling properly?

[Alfredoes234]

Summary

I have been stuck on how to do pooling correctly, using with_state(). I am struggling how to fix the issue, but it is in my case to do with the types of my function I think.

axum version

0.7.3

[Alfredoes234]

I have tried to piece it together but it would be useful to have an example for pooling with Axum.

[davidpdrsn]

You make it sound like "pooling" requires something special, that is not the case. axum's state handling is generic.

Please post an actual snipprt of code, not just a screenshot. The error message covers a bunch of important code.

[Alfredoes234]

use axum::{
    debug_handler,
    extract::{Extension, Path, Query, State},
    http::StatusCode,
    middleware,
    response::{Html, Response},
    routing::{get, post},
    Json, Router,
};
use dotenv::dotenv;
use serde::Deserialize;
use serde_json::{json, Value};
use sqlx::mysql::MySqlPoolOptions;
use sqlx::MySqlPool;
use std::env;

struct AppState {
    pool: MySqlPool,
}

#[tokio::main]
async fn main() -> Result<(), sqlx::Error> {
    dotenv().ok();
    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL not set");
    let pool = MySqlPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await
        .unwrap();
    // build our application with a route
    let app = Router::new()
        .route("/", get(index))
        .route("/api/user_a", post(add_user))
        .layer(middleware::map_response(main_response_mapper))
        .with_state(pool);
    // run it
    let listener = tokio::net::TcpListener::bind("localhost:8080")
        .await
        .unwrap();
    println!("listening on http://{}", listener.local_addr().unwrap());
    axum::serve(listener, app).await.unwrap();

    // Queries
    Ok(())
}

async fn main_response_mapper(res: Response) -> Response {
    println!("{:<12} - main_response_mapper", "RES_MAPPER");
    println!("{res:?}");
    res
}

#[derive(serde::Serialize, serde::Deserialize)]
struct UserBody<T> {
    user: T,
}

#[derive(serde::Serialize, serde::Deserialize)]
struct User {
    name: Option<String>,
    email: String,
    password: String,
}

#[derive(Debug, Deserialize)]
struct NewUser {
    name: Option<String>,
    email: String,
    password: String,
}

async fn add_user(
    State(state): State<AppState>,
    Json(params): Json<NewUser>,
) -> Json<UserBody<User>> {
    println!("{params:?}");
    let result = sqlx::query(
        "
        INSERT INTO Users(name, email, password)
        VALUES (?, ?, ?);
        ",
    )
    .bind(&params.name)
    .bind(&params.email)
    .bind(&params.password)
    .execute(&pool)
    .await;

    match result {
        Ok(_) => Json(UserBody {
            user: User {
                name: params.name,
                email: params.email,
                password: params.password,
            },
        }),
        Err(_) => panic!(),
    }
}

async fn index() -> Html<&'static str> {
    println!("{:<12} - main_Site", "HANDLER");
    Html("<p>Pirate</p>")
}

[Alfredoes234]

For reference

[davidpdrsn]

Here you're setting the state to pool:

.with_state(pool)

and here you're asking for an AppState

State(state): State<AppState>,

those are not the same type

[Alfredoes234]

What I changed to make it work was.

#[derive(Clone)]
struct AppState {
    pool: MySqlPool,
}



let pool = MySqlPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await
        .unwrap();
    let state = AppState { pool };
    let app = Router::new()
        .route("/", get(index))
        .route("/api/user_a", post(add_user))
        .layer(middleware::map_response(main_response_mapper))
        .with_state(state);


async fn add_user(
    State(pool): State<AppState>,
    Json(params): Json<NewUser>,
) -> Json<UserBody<User>> {
    println!("{params:?}");
    let result = sqlx::query!(
        r#"
        INSERT INTO Users(name, email, password)
        VALUES (?, ?, ?);
        "#,
        params.name, params.email, params.password,
    )
    .execute(&pool.pool)
    .await;



    match result {
        Ok(_) => Json(UserBody {
            user: User {
                name: params.name,
                email: params.email,
                password: params.password,
            },
        }),
        Err(e) => panic!("{e:?}"),
    }
}