Tests added, and API simplified

Author: idugalic

README.md

@@ -50,7 +50,7 @@ Confused? Run `cargo pgrx help`
 ## The structure of the project
 
 The project is structured as follows:
-- `lib.rs` file contains the entry point of the package/crate.
+- [lib.rs](src/lib.rs) file contains the entry point of the package/crate.
 - `framework` module contains the generalized and parametrized implementation of infrastructure and application layers.
 - `domain` module contains the domain model. It is the core and pure domain logic of the application!!!
 - `application` module contains the application layer. It is the orchestration of the domain model and the infrastructure layer (empty, as it is implemented in the `framework` module).
@@ -59,6 +59,12 @@ The project is structured as follows:
 The framework module offers a generic implementation of the infrastructure and application layers, which can be reused across multiple domain models.
 Your focus should be on the `domain` module, where you can implement your unique domain model. We have provided a demo domain model of a `restaurant/order management system` to get you started.
 
+## Check the tests
+The project contains a set of tests that demonstrate how to use the domain model and the framework.
+You can find them in the root: [lib.rs](src/lib.rs).
+
+You will find a command handler function only, which can handle all the commands of the system! Simple!
+
 ## References and further reading
 - [pgrx](https://github.com/pgcentralfoundation/pgrx)
 - [fmodel-rust](https://github.com/fraktalio/fmodel-rust)

src/domain/api.rs

@@ -166,11 +166,8 @@ pub struct MarkOrderAsPrepared {
 #[serde(tag = "type")]
 pub enum RestaurantEvent {
     Created(RestaurantCreated),
-    NotCreated(RestaurantNotCreated),
     MenuChanged(RestaurantMenuChanged),
-    MenuNotChanged(RestaurantMenuNotChanged),
     OrderPlaced(OrderPlaced),
-    OrderNotPlaced(OrderNotPlaced),
 }
 
 /// Fact/Event that a restaurant was created
@@ -182,16 +179,6 @@ pub struct RestaurantCreated {
     pub r#final: bool,
 }
 
-/// Fact/Event that a restaurant was not created (with reason)
-#[derive(PostgresType, Serialize, Deserialize, Debug, PartialEq, Clone, Eq)]
-pub struct RestaurantNotCreated {
-    pub identifier: RestaurantId,
-    pub name: RestaurantName,
-    pub menu: RestaurantMenu,
-    pub reason: Reason,
-    pub r#final: bool,
-}
-
 /// Fact/Event that a restaurant's menu was changed
 #[derive(PostgresType, Serialize, Deserialize, Debug, PartialEq, Clone, Eq)]
 pub struct RestaurantMenuChanged {
@@ -200,15 +187,6 @@ pub struct RestaurantMenuChanged {
     pub r#final: bool,
 }
 
-/// Fact/Event that a restaurant's menu was not changed (with reason)
-#[derive(PostgresType, Serialize, Deserialize, Debug, PartialEq, Clone, Eq)]
-pub struct RestaurantMenuNotChanged {
-    pub identifier: RestaurantId,
-    pub menu: RestaurantMenu,
-    pub reason: Reason,
-    pub r#final: bool,
-}
-
 /// Fact/Event that an order was placed
 #[derive(PostgresType, Serialize, Deserialize, Debug, PartialEq, Clone, Eq)]
 pub struct OrderPlaced {
@@ -218,26 +196,14 @@ pub struct OrderPlaced {
     pub r#final: bool,
 }
 
-/// Fact/Event that an order was not placed (with reason)
-#[derive(PostgresType, Serialize, Deserialize, Debug, PartialEq, Clone, Eq)]
-pub struct OrderNotPlaced {
-    pub identifier: RestaurantId,
-    pub order_identifier: OrderId,
-    pub line_items: Vec<OrderLineItem>,
-    pub reason: Reason,
-    pub r#final: bool,
-}
-
 // #### ORDER ####
 
 /// All possible event variants that could be used to update an order
 #[derive(PostgresType, Serialize, Deserialize, Debug, PartialEq, Clone)]
 #[serde(tag = "type")]
 pub enum OrderEvent {
     Created(OrderCreated),
-    NotCreated(OrderNotCreated),
     Prepared(OrderPrepared),
-    NotPrepared(OrderNotPrepared),
 }
 
 /// Fact/Event that an order was created
@@ -250,28 +216,10 @@ pub struct OrderCreated {
     pub r#final: bool,
 }
 
-/// Fact/Event that an order was not created (with reason)
-#[derive(PostgresType, Serialize, Deserialize, Debug, PartialEq, Clone, Eq)]
-pub struct OrderNotCreated {
-    pub identifier: OrderId,
-    pub restaurant_identifier: RestaurantId,
-    pub line_items: Vec<OrderLineItem>,
-    pub reason: Reason,
-    pub r#final: bool,
-}
-
 /// Fact/Event that an order was prepared
 #[derive(PostgresType, Serialize, Deserialize, Debug, PartialEq, Clone, Eq)]
 pub struct OrderPrepared {
     pub identifier: OrderId,
     pub status: OrderStatus,
     pub r#final: bool,
 }
-
-/// Fact/Event that an order was not prepared (with reason)
-#[derive(PostgresType, Serialize, Deserialize, Debug, PartialEq, Clone, Eq)]
-pub struct OrderNotPrepared {
-    pub identifier: OrderId,
-    pub reason: Reason,
-    pub r#final: bool,
-}

src/domain/mod.rs

@@ -1,7 +1,6 @@
 use crate::domain::api::{
     ChangeRestaurantMenu, CreateOrder, CreateRestaurant, MarkOrderAsPrepared, OrderCommand,
-    OrderNotCreated, OrderNotPlaced, OrderNotPrepared, PlaceOrder, RestaurantCommand,
-    RestaurantMenuNotChanged, RestaurantNotCreated,
+    PlaceOrder, RestaurantCommand,
 };
 use crate::domain::order_decider::{order_decider, Order};
 use crate::domain::order_saga::order_saga;
@@ -81,15 +80,10 @@ impl Identifier for Command {
 #[serde(tag = "type")]
 pub enum Event {
     RestaurantCreated(RestaurantCreated),
-    RestaurantNotCreated(RestaurantNotCreated),
     RestaurantMenuChanged(RestaurantMenuChanged),
-    RestaurantMenuNotChanged(RestaurantMenuNotChanged),
     OrderPlaced(OrderPlaced),
-    OrderNotPlaced(OrderNotPlaced),
     OrderCreated(OrderCreated),
-    OrderNotCreated(OrderNotCreated),
     OrderPrepared(OrderPrepared),
-    OrderNotPrepared(OrderNotPrepared),
 }
 
 /// Implement the Identifier trait for the Event enum
@@ -101,11 +95,6 @@ impl Identifier for Event {
             Event::OrderPlaced(evt) => evt.identifier.0,
             Event::OrderCreated(evt) => evt.identifier.0,
             Event::OrderPrepared(evt) => evt.identifier.0,
-            Event::RestaurantNotCreated(evt) => evt.identifier.0,
-            Event::RestaurantMenuNotChanged(evt) => evt.identifier.0,
-            Event::OrderNotPlaced(evt) => evt.identifier.0,
-            Event::OrderNotCreated(evt) => evt.identifier.0,
-            Event::OrderNotPrepared(evt) => evt.identifier.0,
         }
     }
 }
@@ -119,11 +108,6 @@ impl EventType for Event {
             Event::OrderPlaced(_) => "OrderPlaced".to_string(),
             Event::OrderCreated(_) => "OrderCreated".to_string(),
             Event::OrderPrepared(_) => "OrderPrepared".to_string(),
-            Event::RestaurantNotCreated(_) => "RestaurantNotCreated".to_string(),
-            Event::RestaurantMenuNotChanged(_) => "RestaurantMenuNotChanged".to_string(),
-            Event::OrderNotPlaced(_) => "OrderNotPlaced".to_string(),
-            Event::OrderNotCreated(_) => "OrderNotCreated".to_string(),
-            Event::OrderNotPrepared(_) => "OrderNotPrepared".to_string(),
         }
     }
 }
@@ -137,11 +121,6 @@ impl IsFinal for Event {
             Event::OrderPlaced(evt) => evt.r#final,
             Event::OrderCreated(evt) => evt.r#final,
             Event::OrderPrepared(evt) => evt.r#final,
-            Event::RestaurantNotCreated(evt) => evt.r#final,
-            Event::RestaurantMenuNotChanged(evt) => evt.r#final,
-            Event::OrderNotPlaced(evt) => evt.r#final,
-            Event::OrderNotCreated(evt) => evt.r#final,
-            Event::OrderNotPrepared(evt) => evt.r#final,
         }
     }
 }
@@ -153,13 +132,8 @@ impl DeciderType for Event {
             Event::RestaurantCreated(_) => "Restaurant".to_string(),
             Event::RestaurantMenuChanged(_) => "Restaurant".to_string(),
             Event::OrderPlaced(_) => "Restaurant".to_string(),
-            Event::RestaurantNotCreated(_) => "Restaurant".to_string(),
-            Event::RestaurantMenuNotChanged(_) => "Restaurant".to_string(),
-            Event::OrderNotPlaced(_) => "Restaurant".to_string(),
             Event::OrderCreated(_) => "Order".to_string(),
             Event::OrderPrepared(_) => "Order".to_string(),
-            Event::OrderNotCreated(_) => "Order".to_string(),
-            Event::OrderNotPrepared(_) => "Order".to_string(),
         }
     }
 }
@@ -182,34 +156,20 @@ pub fn command_to_sum(command: &Command) -> Sum<RestaurantCommand, OrderCommand>
 pub fn event_to_sum(event: &Event) -> Sum<RestaurantEvent, OrderEvent> {
     match event {
         Event::RestaurantCreated(e) => Sum::First(RestaurantEvent::Created(e.to_owned())),
-        Event::RestaurantNotCreated(e) => Sum::First(RestaurantEvent::NotCreated(e.to_owned())),
         Event::RestaurantMenuChanged(e) => Sum::First(RestaurantEvent::MenuChanged(e.to_owned())),
-        Event::RestaurantMenuNotChanged(e) => {
-            Sum::First(RestaurantEvent::MenuNotChanged(e.to_owned()))
-        }
         Event::OrderPlaced(e) => Sum::First(RestaurantEvent::OrderPlaced(e.to_owned())),
-        Event::OrderNotPlaced(e) => Sum::First(RestaurantEvent::OrderNotPlaced(e.to_owned())),
         Event::OrderCreated(e) => Sum::Second(OrderEvent::Created(e.to_owned())),
-        Event::OrderNotCreated(e) => Sum::Second(OrderEvent::NotCreated(e.to_owned())),
         Event::OrderPrepared(e) => Sum::Second(OrderEvent::Prepared(e.to_owned())),
-        Event::OrderNotPrepared(e) => Sum::Second(OrderEvent::NotPrepared(e.to_owned())),
     }
 }
 
 pub fn event_to_sum2(event: &Event) -> Sum<OrderEvent, RestaurantEvent> {
     match event {
         Event::RestaurantCreated(e) => Sum::Second(RestaurantEvent::Created(e.to_owned())),
-        Event::RestaurantNotCreated(e) => Sum::Second(RestaurantEvent::NotCreated(e.to_owned())),
         Event::RestaurantMenuChanged(e) => Sum::Second(RestaurantEvent::MenuChanged(e.to_owned())),
-        Event::RestaurantMenuNotChanged(e) => {
-            Sum::Second(RestaurantEvent::MenuNotChanged(e.to_owned()))
-        }
         Event::OrderPlaced(e) => Sum::Second(RestaurantEvent::OrderPlaced(e.to_owned())),
-        Event::OrderNotPlaced(e) => Sum::Second(RestaurantEvent::OrderNotPlaced(e.to_owned())),
         Event::OrderCreated(e) => Sum::First(OrderEvent::Created(e.to_owned())),
-        Event::OrderNotCreated(e) => Sum::First(OrderEvent::NotCreated(e.to_owned())),
         Event::OrderPrepared(e) => Sum::First(OrderEvent::Prepared(e.to_owned())),
-        Event::OrderNotPrepared(e) => Sum::First(OrderEvent::NotPrepared(e.to_owned())),
     }
 }
 
@@ -231,17 +191,12 @@ pub fn sum_to_event(event: &Sum<RestaurantEvent, OrderEvent>) -> Event {
     match event {
         Sum::First(e) => match e {
             RestaurantEvent::Created(e) => Event::RestaurantCreated(e.to_owned()),
-            RestaurantEvent::NotCreated(e) => Event::RestaurantNotCreated(e.to_owned()),
             RestaurantEvent::MenuChanged(e) => Event::RestaurantMenuChanged(e.to_owned()),
-            RestaurantEvent::MenuNotChanged(e) => Event::RestaurantMenuNotChanged(e.to_owned()),
             RestaurantEvent::OrderPlaced(e) => Event::OrderPlaced(e.to_owned()),
-            RestaurantEvent::OrderNotPlaced(e) => Event::OrderNotPlaced(e.to_owned()),
         },
         Sum::Second(e) => match e {
             OrderEvent::Created(e) => Event::OrderCreated(e.to_owned()),
-            OrderEvent::NotCreated(e) => Event::OrderNotCreated(e.to_owned()),
             OrderEvent::Prepared(e) => Event::OrderPrepared(e.to_owned()),
-            OrderEvent::NotPrepared(e) => Event::OrderNotPrepared(e.to_owned()),
         },
     }
 }

src/domain/order_decider.rs

@@ -1,8 +1,9 @@
 use fmodel_rust::decider::Decider;
+use pgrx::error;
 
 use crate::domain::api::{
-    OrderCommand, OrderCreated, OrderEvent, OrderId, OrderLineItem, OrderNotCreated,
-    OrderNotPrepared, OrderPrepared, OrderStatus, Reason, RestaurantId,
+    OrderCommand, OrderCreated, OrderEvent, OrderId, OrderLineItem, OrderPrepared, OrderStatus,
+    Reason, RestaurantId,
 };
 
 /// The state of the Order is represented by this struct. It belongs to the Domain layer.
@@ -25,13 +26,7 @@ pub fn order_decider<'a>() -> OrderDecider<'a> {
         decide: Box::new(|command, state| match command {
             OrderCommand::Create(command) => {
                 if state.is_some() {
-                    vec![OrderEvent::NotCreated(OrderNotCreated {
-                        identifier: command.identifier.to_owned(),
-                        restaurant_identifier: command.restaurant_identifier.to_owned(),
-                        line_items: command.line_items.to_owned(),
-                        reason: Reason("Order already exists".to_string()),
-                        r#final: false,
-                    })]
+                    error!("Failed to create the Order. Order already exists!")
                 } else {
                     vec![OrderEvent::Created(OrderCreated {
                         identifier: command.identifier.to_owned(),
@@ -53,11 +48,7 @@ pub fn order_decider<'a>() -> OrderDecider<'a> {
                         r#final: true,
                     })]
                 } else {
-                    vec![OrderEvent::NotPrepared(OrderNotPrepared {
-                        identifier: command.identifier.to_owned(),
-                        reason: Reason("Order in the wrong status previously".to_string()),
-                        r#final: false,
-                    })]
+                    error!("Failed to mark the order as prepared. Order does not exist or is not in the correct state!");
                 }
             }
         }),
@@ -70,16 +61,12 @@ pub fn order_decider<'a>() -> OrderDecider<'a> {
                 status: event.status.to_owned(),
                 line_items: event.line_items.to_owned(),
             }),
-            // On error event we choose NOT TO change the state of the Order, for example.
-            OrderEvent::NotCreated(..) => state.clone(),
             OrderEvent::Prepared(event) => state.clone().map(|s| Order {
                 identifier: event.identifier.to_owned(),
                 restaurant_identifier: s.restaurant_identifier,
                 status: event.status.to_owned(),
                 line_items: s.line_items,
             }),
-            // On error event we choose NOT TO change the state of the Order, for example.
-            OrderEvent::NotPrepared(..) => state.clone(),
         }),
 
         // The initial state of the decider

src/domain/order_saga.rs

@@ -17,15 +17,6 @@ pub fn order_saga<'a>() -> OrderSaga<'a> {
                     line_items: event.line_items.to_owned(),
                 })]
             }
-            RestaurantEvent::OrderNotPlaced(..) => {
-                vec![]
-            }
-            RestaurantEvent::NotCreated(..) => {
-                vec![]
-            }
-            RestaurantEvent::MenuNotChanged(..) => {
-                vec![]
-            }
             RestaurantEvent::Created(..) => {
                 vec![]
             }

src/domain/order_view.rs

@@ -27,17 +27,13 @@ pub fn order_view<'a>() -> OrderView<'a> {
                 status: event.status.to_owned(),
                 line_items: event.line_items.to_owned(),
             }),
-            // On error event we choose NOT TO change the state of the Order, for example.
-            OrderEvent::NotCreated(..) => state.clone(),
 
             OrderEvent::Prepared(event) => state.clone().map(|s| OrderViewState {
                 identifier: event.identifier.to_owned(),
                 restaurant_identifier: s.restaurant_identifier,
                 status: event.status.to_owned(),
                 line_items: s.line_items,
             }),
-            // On error event we choose NOT TO change the state of the Order, for example.
-            OrderEvent::NotPrepared(..) => state.clone(),
         }),
 
         // The initial state of the decider