[+] Implement api with diesel (postgres)

Author: aofdev

api-practice/src/handlers.rs

@@ -1,53 +1,38 @@
-use actix_web::{get, middleware, web, App, HttpResponse, HttpServer, Responder};
-mod handlers;
+#[macro_use]
+extern crate diesel;
 
-// #[get("/")]
-// async fn hello() -> impl Responder {
-//     HttpResponse::Ok().body("Hello rust api!")
-// }
+use actix_web::{middleware, App, HttpServer};
+use diesel::prelude::*;
+use diesel::r2d2::{self, ConnectionManager};
+
+mod schema;
+mod user;
+
+pub type Pool = r2d2::Pool<ConnectionManager<PgConnection>>;
 
 #[actix_rt::main]
 async fn main() -> std::io::Result<()> {
+    dotenv::dotenv().ok();
+
     std::env::set_var("RUST_LOG", "actix_web=debug");
     env_logger::init();
 
+    let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
+
+    // create db connection pool
+    let manager = ConnectionManager::<PgConnection>::new(database_url);
+    let pool: Pool = r2d2::Pool::builder()
+        .build(manager)
+        .expect("Failed to create pool.");
+
     // Start http server
-    HttpServer::new(|| {
+    HttpServer::new(move || {
         App::new()
             .wrap(middleware::Logger::default())
-            .route("/users", web::get().to(handlers::get_users))
-            .route("/users/{id}", web::get().to(handlers::get_user_by_id))
-            .route("/users", web::post().to(handlers::add_user))
-            .route("/users/{id}", web::delete().to(handlers::delete_user))
+            .data(pool.clone())
+            .configure(user::route)
     })
     .bind("127.0.0.1:8080")?
     .run()
     .await
 }
-
-// #[cfg(test)]
-// mod tests {
-//     use super::*;
-//     use actix_web::dev::Service;
-//     use actix_web::{http, test, App, Error};
-
-//     #[actix_rt::test]
-//     async fn test_hello() -> Result<(), Error> {
-//         let app = App::new().service(hello);
-//         let mut app = test::init_service(app).await;
-
-//         let req = test::TestRequest::get().uri("/").to_request();
-//         let resp = app.call(req).await.unwrap();
-
-//         assert_eq!(resp.status(), http::StatusCode::OK);
-
-//         let response_body = match resp.response().body().as_ref() {
-//             Some(actix_web::body::Body::Bytes(bytes)) => bytes,
-//             _ => panic!("Response error"),
-//         };
-
-//         assert_eq!(response_body, r##"Hello rust api!"##);
-
-//         Ok(())
-//     }
-// }

api-practice/src/main.rs

@@ -0,0 +1,9 @@
+table! {
+    users (id) {
+        id -> Int4,
+        first_name -> Text,
+        last_name -> Text,
+        email -> Text,
+        created_at -> Timestamp,
+    }
+}

api-practice/src/schema.rs

@@ -0,0 +1,81 @@
+use crate::diesel::QueryDsl;
+use crate::diesel::RunQueryDsl;
+use crate::schema::users::dsl::*;
+use crate::user::models::{InputUser, NewUser, User};
+use crate::Pool;
+use actix_web::{web, Error, HttpResponse};
+use diesel::dsl::{delete, insert_into};
+use std::vec::Vec;
+
+pub async fn get_users(db: web::Data<Pool>) -> Result<HttpResponse, Error> {
+    Ok(web::block(move || get_all_users(db))
+        .await
+        .map(|user| HttpResponse::Ok().json(user))
+        .map_err(|_| HttpResponse::InternalServerError())?)
+}
+
+pub async fn get_user_by_id(
+    db: web::Data<Pool>,
+    user_id: web::Path<i32>,
+) -> Result<HttpResponse, Error> {
+    Ok(
+        web::block(move || db_get_user_by_id(db, user_id.into_inner()))
+            .await
+            .map(|user| HttpResponse::Ok().json(user))
+            .map_err(|_| HttpResponse::InternalServerError())?,
+    )
+}
+
+pub async fn add_user(
+    db: web::Data<Pool>,
+    item: web::Json<InputUser>,
+) -> Result<HttpResponse, Error> {
+    Ok(web::block(move || add_single_user(db, item))
+        .await
+        .map(|user| HttpResponse::Created().json(user))
+        .map_err(|_| HttpResponse::InternalServerError())?)
+}
+
+pub async fn delete_user(
+    db: web::Data<Pool>,
+    user_id: web::Path<i32>,
+) -> Result<HttpResponse, Error> {
+    Ok(
+        web::block(move || delete_single_user(db, user_id.into_inner()))
+            .await
+            .map(|user| HttpResponse::Ok().json(user))
+            .map_err(|_| HttpResponse::InternalServerError())?,
+    )
+}
+
+fn get_all_users(pool: web::Data<Pool>) -> Result<Vec<User>, diesel::result::Error> {
+    let conn = pool.get().unwrap();
+    let items = users.load::<User>(&conn)?;
+    Ok(items)
+}
+
+fn db_get_user_by_id(pool: web::Data<Pool>, user_id: i32) -> Result<User, diesel::result::Error> {
+    let conn = pool.get().unwrap();
+    users.find(user_id).get_result::<User>(&conn)
+}
+
+fn add_single_user(
+    db: web::Data<Pool>,
+    item: web::Json<InputUser>,
+) -> Result<User, diesel::result::Error> {
+    let conn = db.get().unwrap();
+    let new_user = NewUser {
+        first_name: &item.first_name,
+        last_name: &item.last_name,
+        email: &item.email,
+        created_at: chrono::Local::now().naive_local(),
+    };
+    let res = insert_into(users).values(&new_user).get_result(&conn)?;
+    Ok(res)
+}
+
+fn delete_single_user(db: web::Data<Pool>, user_id: i32) -> Result<usize, diesel::result::Error> {
+    let conn = db.get().unwrap();
+    let count = delete(users.find(user_id)).execute(&conn)?;
+    Ok(count)
+}

api-practice/src/user/handlers.rs

@@ -0,0 +1,15 @@
+mod handlers;
+mod models;
+
+use crate::user::handlers::{add_user, delete_user, get_user_by_id, get_users};
+use actix_web::web;
+
+pub fn route(cfg: &mut web::ServiceConfig) {
+    cfg.service(
+        web::scope("/user")
+            .service(web::resource("/get-all").route(web::get().to(get_users)))
+            .service(web::resource("/get/{id}").route(web::get().to(get_user_by_id)))
+            .service(web::resource("/add").route(web::post().to(add_user)))
+            .service(web::resource("/del/{id}").route(web::delete().to(delete_user))),
+    );
+}

api-practice/src/user/mod.rs

@@ -0,0 +1,27 @@
+use crate::schema::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct InputUser {
+    pub first_name: String,
+    pub last_name: String,
+    pub email: String,
+}
+
+#[derive(Debug, Serialize, Deserialize, Queryable)]
+pub struct User {
+    pub id: i32,
+    pub first_name: String,
+    pub last_name: String,
+    pub email: String,
+    pub created_at: chrono::NaiveDateTime,
+}
+
+#[derive(Insertable, Debug)]
+#[table_name = "users"]
+pub struct NewUser<'a> {
+    pub first_name: &'a str,
+    pub last_name: &'a str,
+    pub email: &'a str,
+    pub created_at: chrono::NaiveDateTime,
+}