Simple Todo API using actix-web and sqlx with postgresql database (#303)

* Simple Todo application using Actix-web with SQLx and PostgreSQL

* fix issue with not matching project name

* remove comment

* - downgrade on actix-web 2.0.0
- fixed typo
- renamed .env-example to .env.example
- removed comments

sqlx_todo/src/main.rs

@@ -0,0 +1,59 @@
+#[macro_use]
+extern crate log;
+
+use dotenv::dotenv;
+use listenfd::ListenFd;
+use std::env;
+use actix_web::{web, App, HttpResponse, HttpServer, Responder};
+use sqlx::PgPool;
+use anyhow::Result;
+
+// import todo module (routes and model)
+mod todo;
+
+// default / handler
+async fn index() -> impl Responder {
+    HttpResponse::Ok().body(r#"
+        Welcome to Actix-web with SQLx Todos example.
+        Available routes:
+        GET /todos -> list of all todos
+        POST /todo -> create new todo, example: { "description": "learn actix and sqlx", "done": false }
+        GET /todo/{id} -> show one todo with requested id
+        PUT /todo/{id} -> update todo with requested id, example: { "description": "learn actix and sqlx", "done": true }
+        DELETE /todo/{id} -> delete todo with requested id
+    "#
+    )
+}
+
+#[actix_rt::main]
+async fn main() -> Result<()> {
+    dotenv().ok();
+    env_logger::init();
+
+    // this will enable us to keep application running during recompile: systemfd --no-pid -s http::5000 -- cargo watch -x run
+    let mut listenfd = ListenFd::from_env();
+
+    let database_url = env::var("DATABASE_URL").expect("DATABASE_URL is not set in .env file");
+    let db_pool = PgPool::new(&database_url).await?;
+
+    let mut server = HttpServer::new(move || {
+        App::new()
+            .data(db_pool.clone()) // pass database pool to application so we can access it inside handlers
+            .route("/", web::get().to(index))
+            .configure(todo::init) // init todo routes
+    });
+
+    server = match listenfd.take_tcp_listener(0)? {
+        Some(listener) => server.listen(listener)?,
+        None => {
+            let host = env::var("HOST").expect("HOST is not set in .env file");
+            let port = env::var("PORT").expect("PORT is not set in .env file");
+            server.bind(format!("{}:{}", host, port))?
+        }
+    };
+
+    info!("Starting server");
+    server.run().await?;
+
+    Ok(())
+}

sqlx_todo/src/todo/mod.rs

@@ -0,0 +1,5 @@
+mod model;
+mod routes;
+
+pub use model::*;
+pub use routes::init;

sqlx_todo/src/todo/model.rs

@@ -0,0 +1,130 @@
+use serde::{Serialize, Deserialize};
+use actix_web::{HttpResponse, HttpRequest, Responder, Error};
+use futures::future::{ready, Ready};
+use sqlx::{PgPool, FromRow, Row};
+use sqlx::postgres::PgRow;
+use anyhow::Result;
+
+// this struct will use to receive user input
+#[derive(Serialize, Deserialize)]
+pub struct TodoRequest {
+    pub description: String,
+    pub done: bool
+}
+
+// this struct will be used to represent database record
+#[derive(Serialize, FromRow)]
+pub struct Todo {
+    pub id: i32,
+    pub description: String,
+    pub done: bool,
+}
+
+// implementation of Actix Responder for Todo struct so we can return Todo from action handler
+impl Responder for Todo {
+    type Error = Error;
+    type Future = Ready<Result<HttpResponse, Error>>;
+
+    fn respond_to(self, _req: &HttpRequest) -> Self::Future {
+        let body = serde_json::to_string(&self).unwrap();
+        // create response and set content type
+        ready(Ok(
+            HttpResponse::Ok()
+                .content_type("application/json")
+                .body(body)
+        ))
+    }
+}
+
+// Implementation for Todo struct, functions for read/write/update and delete todo from database
+impl Todo {
+    pub async fn find_all(pool: &PgPool) -> Result<Vec<Todo>> {
+        let mut todos = vec![];
+        let recs = sqlx::query!(
+            r#"
+                SELECT id, description, done
+                    FROM todos
+                ORDER BY id
+            "#
+        )
+            .fetch_all(pool)
+            .await?;
+
+        for rec in recs {
+            todos.push(Todo {
+                id: rec.id,
+                description: rec.description,
+                done: rec.done
+            });
+        }
+
+        Ok(todos)
+    }
+
+    pub async fn find_by_id(id: i32, pool: &PgPool) -> Result<Todo> {
+        let rec = sqlx::query!(
+                r#"
+                    SELECT * FROM todos WHERE id = $1
+                "#,
+                id
+            )
+            .fetch_one(&*pool)
+            .await?;
+
+        Ok(Todo {
+            id: rec.id,
+            description: rec.description,
+            done: rec.done
+        })
+    }
+
+    pub async fn create(todo: TodoRequest, pool: &PgPool) -> Result<Todo> {
+        let mut tx = pool.begin().await?;
+        let todo = sqlx::query("INSERT INTO todos (description, done) VALUES ($1, $2) RETURNING id, description, done")
+            .bind(&todo.description)
+            .bind(todo.done)
+            .map(|row: PgRow| {
+                Todo {
+                    id: row.get(0),
+                    description: row.get(1),
+                    done: row.get(2)
+                }
+            })
+            .fetch_one(&mut tx)
+            .await?;
+
+        tx.commit().await?;
+        Ok(todo)
+    }
+
+    pub async fn update(id: i32, todo: TodoRequest, pool: &PgPool) -> Result<Todo> {
+        let mut tx = pool.begin().await.unwrap();
+        let todo = sqlx::query("UPDATE todos SET description = $1, done = $2 WHERE id = $3 RETURNING id, description, done")
+            .bind(&todo.description)
+            .bind(todo.done)
+            .bind(id)
+            .map(|row: PgRow| {
+                Todo {
+                    id: row.get(0),
+                    description: row.get(1),
+                    done: row.get(2)
+                }
+            })
+            .fetch_one(&mut tx)
+            .await?;
+
+        tx.commit().await.unwrap();
+        Ok(todo)
+    }
+
+    pub async fn delete(id: i32, pool: &PgPool) -> Result<u64> {
+        let mut tx = pool.begin().await?;
+        let deleted = sqlx::query("DELETE FROM todos WHERE id = $1")
+            .bind(id)
+            .execute(&mut tx)
+            .await?;
+
+        tx.commit().await?;
+        Ok(deleted)
+    }
+}

sqlx_todo/src/todo/routes.rs

@@ -0,0 +1,63 @@
+use crate::todo::{Todo, TodoRequest};
+use actix_web::{delete, get, post, put, web, HttpResponse, Responder};
+use sqlx::PgPool;
+
+#[get("/todos")]
+async fn find_all(db_pool: web::Data<PgPool>) -> impl Responder {
+    let result = Todo::find_all(db_pool.get_ref()).await;
+    match result {
+        Ok(todos) => HttpResponse::Ok().json(todos),
+        _ => HttpResponse::BadRequest().body("Error trying to read all todos from database")
+    }
+}
+
+#[get("/todo/{id}")]
+async fn find(id: web::Path<i32>, db_pool: web::Data<PgPool>) -> impl Responder {
+    let result = Todo::find_by_id(id.into_inner(), db_pool.get_ref()).await;
+    match result {
+        Ok(todo) => HttpResponse::Ok().json(todo),
+        _ => HttpResponse::BadRequest().body("Todo not found")
+    }
+}
+
+#[post("/todo")]
+async fn create(todo: web::Json<TodoRequest>, db_pool: web::Data<PgPool>) -> impl Responder {
+    let result = Todo::create(todo.into_inner(), db_pool.get_ref()).await;
+    match result {
+        Ok(todo) => HttpResponse::Ok().json(todo),
+        _ => HttpResponse::BadRequest().body("Error trying to create new todo")
+    }
+}
+
+#[put("/todo/{id}")]
+async fn update(id: web::Path<i32>, todo: web::Json<TodoRequest>, db_pool: web::Data<PgPool>) -> impl Responder {
+    let result = Todo::update(id.into_inner(), todo.into_inner(),db_pool.get_ref()).await;
+    match result {
+        Ok(todo) => HttpResponse::Ok().json(todo),
+        _ => HttpResponse::BadRequest().body("Todo not found")
+    }
+}
+
+#[delete("/todo/{id}")]
+async fn delete(id: web::Path<i32>, db_pool: web::Data<PgPool>) -> impl Responder {
+    let result = Todo::delete(id.into_inner(), db_pool.get_ref()).await;
+    match result {
+        Ok(rows) => {
+            if rows > 0 {
+                HttpResponse::Ok().body(format!("Successfully deleted {} record(s)", rows))
+            } else {
+                HttpResponse::BadRequest().body("Todo not found")
+            }
+        },
+        _ => HttpResponse::BadRequest().body("Todo not found")
+    }
+}
+
+// function that will be called on new Application to configure routes for this module
+pub fn init(cfg: &mut web::ServiceConfig) {
+    cfg.service(find_all);
+    cfg.service(find);
+    cfg.service(create);
+    cfg.service(update);
+    cfg.service(delete);
+}