Implement POST task

backend/.gitignore

@@ -1,3 +1,5 @@
-/target
+target
 
 *.db
+*.db-shm
+*.db-wal

backend/Cargo.lock

@@ -119,12 +119,47 @@ dependencies = [
  "tracing",
 ]
 
+[[package]]
+name = "axum-extra"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45bf463831f5131b7d3c756525b305d40f1185b688565648a92e1392ca35713d"
+dependencies = [
+ "axum",
+ "axum-core",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "mime",
+ "pin-project-lite",
+ "rustversion",
+ "serde",
+ "tower",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "axum-macros"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "604fde5e028fea851ce1d8570bbdc034bec850d157f7569d10f347d06808c05c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "backend"
 version = "0.1.0"
 dependencies = [
  "anyhow",
  "axum",
+ "axum-extra",
+ "axum-macros",
  "chrono",
  "serde",
  "sqlx",
@@ -222,6 +257,7 @@ dependencies = [
  "iana-time-zone",
  "js-sys",
  "num-traits",
+ "serde",
  "wasm-bindgen",
  "windows-link",
 ]
@@ -1856,6 +1892,7 @@ checksum = "f33196643e165781c20a5ead5582283a7dacbb87855d867fbc2df3f81eddc1be"
 dependencies = [
  "getrandom 0.3.3",
  "js-sys",
+ "serde",
  "wasm-bindgen",
 ]
 

backend/Cargo.toml

@@ -6,11 +6,13 @@ edition = "2024"
 [dependencies]
 anyhow = "1.0.99"
 axum = "0.8.4"
-chrono = "0.4.41"
+axum-extra = "0.10.1"
+axum-macros = "0.5.0"
+chrono = { version = "0.4.41", features = ["serde"] }
 serde = "1.0.219"
 sqlx = { version = "0.8.6", features = ["sqlite", "runtime-tokio", "uuid", "chrono"] }
 tokio = { version = "1.47.1", features = ["rt-multi-thread", "tracing"] }
 tracing = "0.1.41"
 tracing-subscriber = "0.3.19"
-uuid = { version = "1.18.0", features = ["v4"] }
+uuid = { version = "1.18.0", features = ["serde", "v4"] }
 

backend/src/database/connection.rs

@@ -2,20 +2,10 @@ use anyhow::Result;
 use sqlx::{SqlitePool, sqlite::SqliteConnectOptions};
 use std::str::FromStr;
 
-/// Database configuration
 pub struct DatabaseConfig {
     pub database_url: String,
 }
 
-impl Default for DatabaseConfig {
-    fn default() -> Self {
-        Self {
-            database_url: "sqlite:local.db".to_string(),
-        }
-    }
-}
-
-/// Create a SQLx connection pool
 pub async fn create_pool(config: &DatabaseConfig) -> Result<SqlitePool> {
     let options = SqliteConnectOptions::from_str(&config.database_url)?.create_if_missing(true);
 
@@ -26,12 +16,6 @@ pub async fn create_pool(config: &DatabaseConfig) -> Result<SqlitePool> {
     Ok(pool)
 }
 
-/// Initialize database with connection pool
-pub async fn initialize_database() -> Result<SqlitePool> {
-    let config = DatabaseConfig::default();
-    create_pool(&config).await
-}
-
 #[cfg(test)]
 pub async fn create_test_pool() -> Result<SqlitePool> {
     let options = SqliteConnectOptions::from_str("sqlite::memory:")?.create_if_missing(true);
@@ -42,4 +26,3 @@ pub async fn create_test_pool() -> Result<SqlitePool> {
 
     Ok(pool)
 }
-

backend/src/main.rs

@@ -1,13 +1,23 @@
 use axum::{Router, routing::get};
 
-mod models;
 mod database;
+mod models;
+mod services;
 
 #[tokio::main]
 async fn main() {
     tracing_subscriber::fmt::init();
 
-    let app = Router::new().route("/health", get(health));
+    let binding = database::DatabaseConfig {
+        database_url: "sqlite:local.db".to_string(),
+    };
+    let pool = database::create_pool(&binding)
+        .await
+        .expect("Failed to create database pool");
+    let app = Router::new()
+        .route("/health", get(health))
+        .nest("/api/tasks", services::create_task_router())
+        .with_state(pool);
 
     let addr = "127.0.0.1:3000";
 

backend/src/models/task.rs

@@ -13,7 +13,7 @@ pub enum TaskStatus {
     Backlog,
 }
 
-#[derive(sqlx::FromRow)]
+#[derive(sqlx::FromRow, Serialize)]
 pub struct TaskModel {
     pub id: Uuid,
     pub title: String,

backend/src/services/mod.rs

@@ -0,0 +1,49 @@
+mod tasks;
+
+use axum::{Json, extract::rejection::JsonRejection, http::StatusCode, response::IntoResponse};
+
+// AppError
+// Borrowed from example: https://github.com/tokio-rs/axum/blob/axum-v0.8.4/examples/anyhow-error-response/src/main.rs
+pub enum AppError {
+    InternalError(anyhow::Error),
+    JsonExtractError(JsonRejection),
+}
+
+#[derive(Serialize)]
+pub struct ErrorJson {
+    error: String,
+}
+
+impl IntoResponse for AppError {
+    fn into_response(self) -> axum::response::Response {
+        match self {
+            Self::InternalError(anyhow_error) => (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                format!("Something went wrong {}", anyhow_error),
+            )
+                .into_response(),
+            Self::JsonExtractError(rej) => (
+                StatusCode::UNPROCESSABLE_ENTITY,
+                Json(ErrorJson {
+                    error: rej.status().to_string(),
+                }),
+            )
+                .into_response(),
+        }
+    }
+}
+
+impl From<JsonRejection> for AppError {
+    fn from(value: JsonRejection) -> Self {
+        Self::JsonExtractError(value)
+    }
+}
+
+impl From<anyhow::Error> for AppError {
+    fn from(err: anyhow::Error) -> Self {
+        Self::InternalError(err.into())
+    }
+}
+
+use serde::Serialize;
+pub use tasks::*;

backend/src/services/tasks.rs

@@ -0,0 +1,30 @@
+use axum::{Json, Router, extract::State, http::StatusCode, routing::post};
+use axum_extra::extract::WithRejection;
+use axum_macros::debug_handler;
+use serde::Deserialize;
+use sqlx::{Pool, Sqlite};
+
+use crate::models::TaskModel;
+
+use super::AppError;
+
+pub fn create_task_router() -> Router<Pool<Sqlite>> {
+    Router::new().route("/", post(create_task))
+}
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct CreateTaskRequest {
+    title: String,
+    description: Option<String>,
+}
+
+#[debug_handler]
+pub async fn create_task(
+    State(pool): State<Pool<Sqlite>>,
+    WithRejection(Json(input), _): WithRejection<Json<CreateTaskRequest>, AppError>,
+) -> Result<(StatusCode, Json<TaskModel>), AppError> {
+    let model = TaskModel::insert(&pool, &input.title, input.description.as_deref()).await?;
+
+    Ok((StatusCode::CREATED, Json(model)))
+}

backend/tests/api/tasks.hurl

@@ -5,10 +5,7 @@ POST {{host}}/api/tasks
 Content-Type: application/json
 {
   "title": "Test task",
-  "description": "A test task for the API",
+  "description": "A test task for the API"
-  "priority": "medium",
-  "due_date": "2024-12-31",
-  "status": "todo"
 }
 
 HTTP 201
@@ -17,8 +14,6 @@ task_id: jsonpath "$.id"
 [Asserts]
 jsonpath "$.title" == "Test task"
 jsonpath "$.description" == "A test task for the API"
-jsonpath "$.priority" == "medium"
-jsonpath "$.due_date" == "2024-12-31"
 jsonpath "$.status" == "todo"
 jsonpath "$.id" exists
 jsonpath "$.created_at" exists
@@ -36,10 +31,8 @@ HTTP 201
 minimal_task_id: jsonpath "$.id"
 [Asserts]
 jsonpath "$.title" == "Minimal task"
-jsonpath "$.priority" == "medium"
 jsonpath "$.status" == "todo"
 jsonpath "$.description" == null
-jsonpath "$.due_date" == null
 
 # Test: Create task with invalid data (missing title)
 POST {{host}}/api/tasks
@@ -48,7 +41,7 @@ Content-Type: application/json
   "description": "Task without title"
 }
 
-HTTP 400
+HTTP 422
 [Asserts]
 jsonpath "$.error" exists
 
@@ -57,22 +50,10 @@ POST {{host}}/api/tasks
 Content-Type: application/json
 {
   "title": "Invalid priority task",
-  "priority": "invalid"
+  "priority": "This field does not exist."
 }
 
-HTTP 400
+HTTP 422
-[Asserts]
-jsonpath "$.error" exists
-
-# Test: Create task with invalid status
-POST {{host}}/api/tasks
-Content-Type: application/json
-{
-  "title": "Invalid status task",
-  "status": "invalid"
-}
-
-HTTP 400
 [Asserts]
 jsonpath "$.error" exists
 

justfile

@@ -46,5 +46,5 @@ test-integration:
     printf 'GET http://localhost:3000/health\nHTTP 200' | hurl --retry 30 > /dev/null
     
     echo "Running integration tests..."
-    hurl --test --variable host=http://localhost:3000 tests/api/*.hurl
+    hurl --test --error-format long --variable host=http://localhost:3000 tests/api/*.hurl