States and projections

Justfile

@@ -1,11 +1,11 @@
-axium: 
+axum: 
     cd clients/axum && cargo watch -x run
 
 yew: 
     cd clients/yew && trunk serve
 
 test:
-    cargo test
+    cargo test -- --nocapture
 
 deps:
     cargo +nightly udeps

application/src/command.rs

@@ -0,0 +1,55 @@
+use crate::port::{TodoListRepository, TodoListStore};
+use domain::todolist_message::TodoListMessage;
+use framework::*;
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+pub enum Command {
+    AddTask { name: String },
+    RemoveTask { index: usize },
+    CompleteTask { index: usize },
+}
+
+#[derive(Debug, Error)]
+pub enum CommandError {
+    #[error("Task name cannot be empty")]
+    TaskNameCannotBeEmpty,
+}
+
+impl TryInto<TodoListMessage> for &Command {
+    type Error = CommandError;
+
+    fn try_into(self) -> Result<TodoListMessage, Self::Error> {
+        Ok(match self {
+            Command::AddTask { name } => TodoListMessage::AddTask(
+                name.clone()
+                    .try_into()
+                    .map_err(|_| CommandError::TaskNameCannotBeEmpty)?,
+            ),
+            Command::RemoveTask { index } => TodoListMessage::RemoveTask((*index).into()),
+            Command::CompleteTask { index } => TodoListMessage::CompleteTask((*index).into()),
+        })
+    }
+}
+
+#[async_trait]
+impl<R> Execute<R> for Command
+where
+    R: TodoListRepository + TodoListStore + Send + Sync,
+{
+    async fn execute(&self, runtime: &R) -> AnyResult<()> {
+        let message = self.try_into()?;
+
+        // Pull the current state and apply the message
+        let todolist = TodoListStore::pull(runtime).await?;
+        let new_events = todolist.send(&message)?;
+        TodoListStore::push(runtime, &new_events).await?;
+
+        // Save the projection
+        let mut projection = TodoListRepository::fetch(runtime).await?;
+        projection.apply(&new_events);
+        TodoListRepository::save(runtime, &projection).await?;
+
+        Ok(())
+    }
+}

application/src/lib.rs

@@ -1,4 +1,4 @@
-pub mod commands;
-pub mod ports;
-pub mod projections;
-pub mod queries;
+pub mod command;
+pub mod port;
+pub mod projection;
+pub mod query;

application/src/ports.rs → application/src/port.rs

@@ -1,5 +1,5 @@
-pub use crate::projections::TodoListProjection;
-pub use domain::{todolist::TodoList, todolist_event::TodoListEvent};
+pub use crate::projection::TodoListProjection;
+pub use domain::{todolist_event::TodoListEvent, todolist_state::TodoList};
 use framework::*;
 
 #[async_trait]

application/src/projection.rs

@@ -0,0 +1,34 @@
+use domain::todolist_event::TodoListEvent;
+use framework::*;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
+pub struct TodoListProjection {
+    pub in_progress: HashMap<usize, String>,
+    pub completed: HashMap<usize, String>,
+}
+
+impl Projection for TodoListProjection {
+    type Event = TodoListEvent;
+
+    fn apply(&mut self, events: &[Self::Event]) {
+        for event in events {
+            match event {
+                TodoListEvent::TaskAdded(index, name) => {
+                    self.in_progress
+                        .insert((*index).into(), name.clone().into());
+                }
+                TodoListEvent::TaskCompleted(index) => {
+                    self.completed.insert(
+                        (*index).into(),
+                        self.in_progress.remove(&(*index).into()).unwrap(),
+                    );
+                }
+                TodoListEvent::TaskRemoved(index) => {
+                    self.in_progress.remove(&(*index).into());
+                }
+            }
+        }
+    }
+}

application/src/queries.rs → application/src/query.rs

@@ -1,12 +1,12 @@
-use crate::{ports::TodoListRepository, projections::TodoListProjection};
+use crate::{port::TodoListRepository, projection::TodoListProjection};
 use framework::*;
 use serde::Deserialize;
 
 #[derive(Deserialize)]
 pub struct GetTodoListQuery {}
 
 #[async_trait]
-impl<R> Query<R> for GetTodoListQuery
+impl<R> Execute<R> for GetTodoListQuery
 where
     R: TodoListRepository + Send + Sync,
 {

clients/axum/examples.http

@@ -0,0 +1,32 @@
+### Retrieve all todolist
+GET http://localhost:3000/todolist HTTP/1.1
+
+### Create a new task
+POST http://localhost:3000/todolist HTTP/1.1
+content-type: application/json
+
+{
+    "AddTask": {
+        "name": "Some task"
+    }
+}
+
+### Complete a task
+POST http://localhost:3000/todolist HTTP/1.1
+content-type: application/json
+
+{
+    "CompleteTask": {
+        "index": 0
+    }
+}
+
+### Remove a task
+POST http://localhost:3000/todolist HTTP/1.1
+content-type: application/json
+
+{
+    "RemoveTask": {
+        "index": 0
+    }
+}

clients/axum/src/main.rs

@@ -1,12 +1,10 @@
 mod runtime;
 
-use application::{
-    commands::{AddTaskCommand, CompleteTaskCommand, RemoveTaskCommand},
-    ports::*,
-    queries::GetTodoListQuery,
-};
+use application::{command::Command, port::*, query::GetTodoListQuery};
 use axum::{
     extract::State,
+    http::StatusCode,
+    response::{IntoResponse, Response},
     routing::{get, post},
     Json, Router,
 };
@@ -22,15 +20,7 @@ async fn main() {
 
     let app = Router::new()
         .route("/todolist", get(get_todolist))
-        .route("/todolist/add", post(handle_command::<AddTaskCommand>))
-        .route(
-            "/todolist/remove",
-            post(handle_command::<RemoveTaskCommand>),
-        )
-        .route(
-            "/todolist/complete",
-            post(handle_command::<CompleteTaskCommand>),
-        )
+        .route("/todolist", post(handle_command))
         .with_state(runtime);
 
     let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
@@ -48,15 +38,27 @@ async fn get_todolist(
         .map_err(|err| err.to_string())
 }
 
-async fn handle_command<T>(
+async fn handle_command(
     State(state): State<Arc<Runtime>>,
-    Json(command): Json<T>,
-) -> Result<(), String>
+    Json(command): Json<Command>,
+) -> Result<(), AppError> {
+    command.execute(state.as_ref()).await?;
+    Ok(())
+}
+
+struct AppError(AnyError);
+
+impl IntoResponse for AppError {
+    fn into_response(self) -> Response {
+        (StatusCode::BAD_REQUEST, self.0.to_string()).into_response()
+    }
+}
+
+impl<E> From<E> for AppError
 where
-    T: Command<Runtime>,
+    E: Into<AnyError>,
 {
-    command
-        .execute(state.as_ref())
-        .await
-        .map_err(|err| err.to_string())
+    fn from(err: E) -> Self {
+        Self(err.into())
+    }
 }