1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
//! Run with
//!
//! ```sh
//! export DATABASE_URL=postgres://localhost/your_db
//! diesel migration run
//! cargo run -p example-diesel-async-postgres
//! ```
//!
//! Checkout the [diesel webpage](https://diesel.rs) for
//! longer guides about diesel
//!
//! Checkout the [crates.io source code](https://github.com/rust-lang/crates.io/)
//! for a real world application using axum and diesel
use axum::{
extract::{FromRef, FromRequestParts, State},
http::{request::Parts, StatusCode},
response::Json,
routing::{get, post},
Router,
};
use diesel::prelude::*;
use diesel_async::{
pooled_connection::AsyncDieselConnectionManager, AsyncPgConnection, RunQueryDsl,
};
use std::net::SocketAddr;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
// normally part of your generated schema.rs file
table! {
users (id) {
id -> Integer,
name -> Text,
hair_color -> Nullable<Text>,
}
}
#[derive(serde::Serialize, Selectable, Queryable)]
struct User {
id: i32,
name: String,
hair_color: Option<String>,
}
#[derive(serde::Deserialize, Insertable)]
#[diesel(table_name = users)]
struct NewUser {
name: String,
hair_color: Option<String>,
}
type Pool = bb8::Pool<AsyncDieselConnectionManager<AsyncPgConnection>>;
#[tokio::main]
async fn main() {
tracing_subscriber::registry()
.with(
tracing_subscriber::EnvFilter::try_from_default_env()
.unwrap_or_else(|_| format!("{}=debug", env!("CARGO_CRATE_NAME")).into()),
)
.with(tracing_subscriber::fmt::layer())
.init();
let db_url = std::env::var("DATABASE_URL").unwrap();
// set up connection pool
let config = AsyncDieselConnectionManager::<diesel_async::AsyncPgConnection>::new(db_url);
let pool = bb8::Pool::builder().build(config).await.unwrap();
// build our application with some routes
let app = Router::new()
.route("/user/list", get(list_users))
.route("/user/create", post(create_user))
.with_state(pool);
// run it with hyper
let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
tracing::debug!("listening on {addr}");
let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
axum::serve(listener, app).await.unwrap();
}
async fn create_user(
State(pool): State<Pool>,
Json(new_user): Json<NewUser>,
) -> Result<Json<User>, (StatusCode, String)> {
let mut conn = pool.get().await.map_err(internal_error)?;
let res = diesel::insert_into(users::table)
.values(new_user)
.returning(User::as_returning())
.get_result(&mut conn)
.await
.map_err(internal_error)?;
Ok(Json(res))
}
// we can also write a custom extractor that grabs a connection from the pool
// which setup is appropriate depends on your application
struct DatabaseConnection(
bb8::PooledConnection<'static, AsyncDieselConnectionManager<AsyncPgConnection>>,
);
impl<S> FromRequestParts<S> for DatabaseConnection
where
S: Send + Sync,
Pool: FromRef<S>,
{
type Rejection = (StatusCode, String);
async fn from_request_parts(_parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
let pool = Pool::from_ref(state);
let conn = pool.get_owned().await.map_err(internal_error)?;
Ok(Self(conn))
}
}
async fn list_users(
DatabaseConnection(mut conn): DatabaseConnection,
) -> Result<Json<Vec<User>>, (StatusCode, String)> {
let res = users::table
.select(User::as_select())
.load(&mut conn)
.await
.map_err(internal_error)?;
Ok(Json(res))
}
/// Utility function for mapping any error into a `500 Internal Server Error`
/// response.
fn internal_error<E>(err: E) -> (StatusCode, String)
where
E: std::error::Error,
{
(StatusCode::INTERNAL_SERVER_ERROR, err.to_string())
}
|
