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/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);
+}