Restructure folders (#411)

database_interactions/diesel/src/actions.rs

@@ -0,0 +1,40 @@
+use diesel::prelude::*;
+use uuid::Uuid;
+
+use crate::models;
+
+/// Run query using Diesel to find user by uid and return it.
+pub fn find_user_by_uid(
+    uid: Uuid,
+    conn: &SqliteConnection,
+) -> Result<Option<models::User>, diesel::result::Error> {
+    use crate::schema::users::dsl::*;
+
+    let user = users
+        .filter(id.eq(uid.to_string()))
+        .first::<models::User>(conn)
+        .optional()?;
+
+    Ok(user)
+}
+
+/// Run query using Diesel to insert a new database row and return the result.
+pub fn insert_new_user(
+    // prevent collision with `name` column imported inside the function
+    nm: &str,
+    conn: &SqliteConnection,
+) -> Result<models::User, diesel::result::Error> {
+    // It is common when using Diesel with Actix web to import schema-related
+    // modules inside a function's scope (rather than the normal module's scope)
+    // to prevent import collisions and namespace pollution.
+    use crate::schema::users::dsl::*;
+
+    let new_user = models::User {
+        id: Uuid::new_v4().to_string(),
+        name: nm.to_owned(),
+    };
+
+    diesel::insert_into(users).values(&new_user).execute(conn)?;
+
+    Ok(new_user)
+}

database_interactions/diesel/src/main.rs

@@ -0,0 +1,94 @@
+//! Actix web Diesel integration example
+//!
+//! Diesel does not support tokio, so we have to run it in separate threads using the web::block
+//! function which offloads blocking code (like Diesel's) in order to not block the server's thread.
+
+#[macro_use]
+extern crate diesel;
+
+use actix_web::{get, middleware, post, web, App, Error, HttpResponse, HttpServer};
+use diesel::prelude::*;
+use diesel::r2d2::{self, ConnectionManager};
+use uuid::Uuid;
+
+mod actions;
+mod models;
+mod schema;
+
+type DbPool = r2d2::Pool<ConnectionManager<SqliteConnection>>;
+
+/// Finds user by UID.
+#[get("/user/{user_id}")]
+async fn get_user(
+    pool: web::Data<DbPool>,
+    user_uid: web::Path<Uuid>,
+) -> Result<HttpResponse, Error> {
+    let user_uid = user_uid.into_inner();
+    let conn = pool.get().expect("couldn't get db connection from pool");
+
+    // use web::block to offload blocking Diesel code without blocking server thread
+    let user = web::block(move || actions::find_user_by_uid(user_uid, &conn))
+        .await
+        .map_err(|e| {
+            eprintln!("{}", e);
+            HttpResponse::InternalServerError().finish()
+        })?;
+
+    if let Some(user) = user {
+        Ok(HttpResponse::Ok().json(user))
+    } else {
+        let res = HttpResponse::NotFound()
+            .body(format!("No user found with uid: {}", user_uid));
+        Ok(res)
+    }
+}
+
+/// Inserts new user with name defined in form.
+#[post("/user")]
+async fn add_user(
+    pool: web::Data<DbPool>,
+    form: web::Json<models::NewUser>,
+) -> Result<HttpResponse, Error> {
+    let conn = pool.get().expect("couldn't get db connection from pool");
+
+    // use web::block to offload blocking Diesel code without blocking server thread
+    let user = web::block(move || actions::insert_new_user(&form.name, &conn))
+        .await
+        .map_err(|e| {
+            eprintln!("{}", e);
+            HttpResponse::InternalServerError().finish()
+        })?;
+
+    Ok(HttpResponse::Ok().json(user))
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    std::env::set_var("RUST_LOG", "actix_web=info");
+    env_logger::init();
+    dotenv::dotenv().ok();
+
+    // set up database connection pool
+    let connspec = std::env::var("DATABASE_URL").expect("DATABASE_URL");
+    let manager = ConnectionManager::<SqliteConnection>::new(connspec);
+    let pool = r2d2::Pool::builder()
+        .build(manager)
+        .expect("Failed to create pool.");
+
+    let bind = "127.0.0.1:8080";
+
+    println!("Starting server at: {}", &bind);
+
+    // Start HTTP server
+    HttpServer::new(move || {
+        App::new()
+            // set up DB pool to be used with web::Data<Pool> extractor
+            .data(pool.clone())
+            .wrap(middleware::Logger::default())
+            .service(get_user)
+            .service(add_user)
+    })
+    .bind(&bind)?
+    .run()
+    .await
+}

database_interactions/diesel/src/models.rs

@@ -0,0 +1,14 @@
+use serde::{Deserialize, Serialize};
+
+use crate::schema::users;
+
+#[derive(Debug, Clone, Serialize, Queryable, Insertable)]
+pub struct User {
+    pub id: String,
+    pub name: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct NewUser {
+    pub name: String,
+}

database_interactions/diesel/src/schema.rs

@@ -0,0 +1,6 @@
+table! {
+    users (id) {
+        id -> Text,
+        name -> Text,
+    }
+}