Merge pull request #9 from fraktalio/feature/upgrade

upgraded fmodel (0.8.1) and pgrx (0.16)

Author: idugalic

Cargo.toml

@@ -7,24 +7,23 @@ edition = "2021"
 crate-type = ["cdylib", "lib"]
 
 [features]
-default = ["pg15"]
-pg12 = ["pgrx/pg12", "pgrx-tests/pg12" ]
+default = ["pg16"]
 pg13 = ["pgrx/pg13", "pgrx-tests/pg13" ]
 pg14 = ["pgrx/pg14", "pgrx-tests/pg14" ]
 pg15 = ["pgrx/pg15", "pgrx-tests/pg15" ]
 pg16 = ["pgrx/pg16", "pgrx-tests/pg16" ]
 pg_test = []
 
 [dependencies]
-pgrx = "0.12.6"
-serde = { version = "1.0.210", features = ["derive"] }
-fmodel-rust = "0.7.0"
-serde_json = "1.0.131"
-uuid = { version = "1.11.0", features = ["serde", "v4"] }
-thiserror = "1.0.64"
+pgrx = "0.16.0"
+serde = { version = "1.0.217", features = ["derive"] }
+fmodel-rust = "0.8.1"
+serde_json = "1.0.138"
+uuid = { version = "1.13.1", features = ["serde", "v4"] }
+chrono = {version = "0.4.41", features = ["serde"]}
 
 [dev-dependencies]
-pgrx-tests = "0.12.6"
+pgrx-tests = "0.16.0"
 
 [profile.dev]
 panic = "unwind"
@@ -37,4 +36,4 @@ codegen-units = 1
 
 [[bin]]
 name = "pgrx_embed_fmodel_rust_postgres"
-path = "./src/bin/pgrx_embed.rs"
+path = "./src/bin/pgrx_embed.rs"

src/domain/api.rs

@@ -1,5 +1,4 @@
 use crate::framework::domain::api::Identifier;
-use pgrx::FromDatum;
 use pgrx::{PostgresEnum, PostgresType};
 use serde::{Deserialize, Serialize};
 use std::fmt;

src/domain/mod.rs

@@ -6,7 +6,7 @@ use crate::domain::order_decider::{order_decider, Order};
 use crate::domain::order_saga::order_saga;
 use crate::domain::restaurant_decider::{restaurant_decider, Restaurant};
 use crate::domain::restaurant_saga::restaurant_saga;
-use crate::framework::domain::api::{DeciderType, EventType, Identifier, IsFinal};
+use crate::framework::domain::api::{DeciderType, DomainError, EventType, Identifier, IsFinal};
 use api::{
     OrderCreated, OrderEvent, OrderPlaced, OrderPrepared, RestaurantCreated, RestaurantEvent,
     RestaurantMenuChanged,
@@ -29,7 +29,7 @@ pub mod restaurant_view;
 /// A convenient type alias for the combined Decider
 /// This decider is used to combine the Restaurant and Order deciders into a single decider that can handle both Restaurant and Order commands.
 pub type OrderAndRestaurantDecider<'a> =
-    Decider<'a, Command, (Option<Restaurant>, Option<Order>), Event>;
+    Decider<'a, Command, (Option<Restaurant>, Option<Order>), Event, DomainError>;
 
 /// A convenient type alias for the combined Saga
 /// This saga is used to combine the Restaurant and Order choreography sagas into a single orchestrating saga that can handle both Restaurant and Order events, and produce Restaurant and Order commands as a result.
@@ -39,16 +39,15 @@ pub type OrderAndRestaurantSaga<'a> = Saga<'a, Event, Command>;
 pub fn order_restaurant_decider<'a>() -> OrderAndRestaurantDecider<'a> {
     restaurant_decider()
         .combine(order_decider())
-        .map_command(&command_to_sum)
-        .map_event(&event_to_sum, &sum_to_event)
+        .map_command(command_to_sum)
+        .map_event(event_to_sum, sum_to_event)
 }
 
-/// Combined Saga, combining the Restaurant and Order choreography sagas into a single orchestrating saga that can handle both Restaurant and Order events, and produce Restaurant and Order commands as a result.
+/// Merged Saga, merging the Restaurant and Order choreography sagas into a single orchestrating saga that can handle all events, and produce Restaurant and Order commands as a result.
 pub fn order_restaurant_saga<'a>() -> OrderAndRestaurantSaga<'a> {
     restaurant_saga()
-        .combine(order_saga())
-        .map_action_result(&event_to_sum2)
-        .map_action(&sum_to_command)
+        .merge(order_saga())
+        .map_action(sum_to_command)
 }
 
 /// All possible commands in the order&restaurant domains
@@ -138,6 +137,18 @@ impl DeciderType for Event {
     }
 }
 
+impl DeciderType for Command {
+    fn decider_type(&self) -> String {
+        match self {
+            Command::PlaceOrder(_) => "Restaurant".to_string(),
+            Command::CreateOrder(_) => "Order".to_string(),
+            Command::MarkOrderAsPrepared(_) => "Order".to_string(),
+            Command::CreateRestaurant(_) => "Restaurant".to_string(),
+            Command::ChangeRestaurantMenu(_) => "Restaurant".to_string(),
+        }
+    }
+}
+
 /// Mapper functions to convert between the `FModel` Sum type and the more appropriate domain specific Command/API type
 /// This is necessary because the `FModel` Sum type is used to combine the Restaurant and Order deciders into a single decider that can handle both Restaurant and Order commands.
 /// We don't want to expose the `FModel` Sum type to the API, so we need to convert between the `FModel` Sum type and the more appropriate Command/API type.
@@ -163,16 +174,6 @@ pub fn event_to_sum(event: &Event) -> Sum<RestaurantEvent, OrderEvent> {
     }
 }
 
-pub fn event_to_sum2(event: &Event) -> Sum<OrderEvent, RestaurantEvent> {
-    match event {
-        Event::RestaurantCreated(e) => Sum::Second(RestaurantEvent::Created(e.to_owned())),
-        Event::RestaurantMenuChanged(e) => Sum::Second(RestaurantEvent::MenuChanged(e.to_owned())),
-        Event::OrderPlaced(e) => Sum::Second(RestaurantEvent::OrderPlaced(e.to_owned())),
-        Event::OrderCreated(e) => Sum::First(OrderEvent::Created(e.to_owned())),
-        Event::OrderPrepared(e) => Sum::First(OrderEvent::Prepared(e.to_owned())),
-    }
-}
-
 pub fn sum_to_command(command: &Sum<OrderCommand, RestaurantCommand>) -> Command {
     match command {
         Sum::Second(c) => match c {

src/domain/order_decider.rs

@@ -1,9 +1,11 @@
 use fmodel_rust::decider::Decider;
-use pgrx::error;
 
-use crate::domain::api::{
-    OrderCommand, OrderCreated, OrderEvent, OrderId, OrderLineItem, OrderPrepared, OrderStatus,
-    RestaurantId,
+use crate::{
+    domain::api::{
+        OrderCommand, OrderCreated, OrderEvent, OrderId, OrderLineItem, OrderPrepared, OrderStatus,
+        RestaurantId,
+    },
+    framework::domain::api::DomainError,
 };
 
 /// The state of the Order is represented by this struct. It belongs to the Domain layer.
@@ -16,7 +18,7 @@ pub struct Order {
 }
 
 /// A convenient type alias for the Order decider
-pub type OrderDecider<'a> = Decider<'a, OrderCommand, Option<Order>, OrderEvent>;
+pub type OrderDecider<'a> = Decider<'a, OrderCommand, Option<Order>, OrderEvent, DomainError>;
 
 /// Decider is a datatype/struct that represents the main decision-making algorithm. It belongs to the Domain layer.
 pub fn order_decider<'a>() -> OrderDecider<'a> {
@@ -26,29 +28,33 @@ pub fn order_decider<'a>() -> OrderDecider<'a> {
         decide: Box::new(|command, state| match command {
             OrderCommand::Create(command) => {
                 if state.is_some() {
-                    error!("Failed to create the Order. Order already exists!")
+                    Err(DomainError::OrderNotCreated(
+                        "Failed to create the Order. Order already exists!".to_string(),
+                    ))
                 } else {
-                    vec![OrderEvent::Created(OrderCreated {
+                    Ok(vec![OrderEvent::Created(OrderCreated {
                         identifier: command.identifier.to_owned(),
                         restaurant_identifier: command.restaurant_identifier.to_owned(),
                         status: OrderStatus::Created,
                         line_items: command.line_items.to_owned(),
                         r#final: false,
-                    })]
+                    })])
                 }
             }
             OrderCommand::MarkAsPrepared(command) => {
                 if state
                     .clone()
                     .is_some_and(|s| OrderStatus::Created == s.status)
                 {
-                    vec![OrderEvent::Prepared(OrderPrepared {
+                    Ok(vec![OrderEvent::Prepared(OrderPrepared {
                         identifier: command.identifier.to_owned(),
                         status: OrderStatus::Prepared,
                         r#final: true,
-                    })]
+                    })])
                 } else {
-                    error!("Failed to mark the order as prepared. Order does not exist or is not in the correct state!");
+                    Err(DomainError::OrderNotPrepared(
+                        "Failed to mark the order as prepared. Order does not exist or is not in the correct state!".to_string(),
+                    ))
                 }
             }
         }),
@@ -68,7 +74,6 @@ pub fn order_decider<'a>() -> OrderDecider<'a> {
                 line_items: s.line_items,
             }),
         }),
-
         // The initial state of the decider
         initial_state: Box::new(|| None),
     }

src/domain/order_saga.rs

@@ -1,26 +1,35 @@
 use fmodel_rust::saga::Saga;
 
-use crate::domain::api::{CreateOrder, OrderCommand, RestaurantEvent};
+use crate::domain::{
+    api::{CreateOrder, OrderCommand},
+    Event,
+};
 
 /// A convenient type alias for the Order choreography saga
-type OrderSaga<'a> = Saga<'a, RestaurantEvent, OrderCommand>;
+type OrderSaga<'a> = Saga<'a, Event, OrderCommand>;
 
 /// The Order choreography saga - represents the central point of control deciding what to execute next.
 /// It is a function that takes an event and returns a list of commands.
 pub fn order_saga<'a>() -> OrderSaga<'a> {
     Saga {
         react: Box::new(|event| match event {
-            RestaurantEvent::OrderPlaced(event) => {
+            Event::RestaurantCreated(..) => {
+                vec![]
+            }
+            Event::OrderPrepared(..) => {
+                vec![]
+            }
+            Event::OrderPlaced(event) => {
                 vec![OrderCommand::Create(CreateOrder {
                     identifier: event.order_identifier.to_owned(),
                     restaurant_identifier: event.identifier.to_owned(),
                     line_items: event.line_items.to_owned(),
                 })]
             }
-            RestaurantEvent::Created(..) => {
+            Event::RestaurantMenuChanged(..) => {
                 vec![]
             }
-            RestaurantEvent::MenuChanged(..) => {
+            Event::OrderCreated(..) => {
                 vec![]
             }
         }),

src/domain/restaurant_decider.rs

@@ -1,9 +1,11 @@
 use fmodel_rust::decider::Decider;
-use pgrx::error;
 
-use crate::domain::api::{
-    OrderPlaced, RestaurantCommand, RestaurantCreated, RestaurantEvent, RestaurantId,
-    RestaurantMenu, RestaurantMenuChanged, RestaurantName,
+use crate::{
+    domain::api::{
+        OrderPlaced, RestaurantCommand, RestaurantCreated, RestaurantEvent, RestaurantId,
+        RestaurantMenu, RestaurantMenuChanged, RestaurantName,
+    },
+    framework::domain::api::DomainError,
 };
 
 /// The state of the Restaurant is represented by this struct. It belongs to the Domain layer.
@@ -16,7 +18,7 @@ pub struct Restaurant {
 
 /// A convenient type alias for the Restaurant decider
 pub type RestaurantDecider<'a> =
-    Decider<'a, RestaurantCommand, Option<Restaurant>, RestaurantEvent>;
+    Decider<'a, RestaurantCommand, Option<Restaurant>, RestaurantEvent, DomainError>;
 
 /// Decider is a datatype/struct that represents the main decision-making algorithm. It belongs to the Domain layer.
 pub fn restaurant_decider<'a>() -> RestaurantDecider<'a> {
@@ -26,37 +28,43 @@ pub fn restaurant_decider<'a>() -> RestaurantDecider<'a> {
         decide: Box::new(|command, state| match command {
             RestaurantCommand::CreateRestaurant(command) => {
                 if state.is_some() {
-                    error!("Failed to create the Restaurant. Restaurant already exists!");
+                    Err(DomainError::RestaurantNotCreated(
+                        "Failed to create the Restaurant. Restaurant already exists!".to_string(),
+                    ))
                 } else {
-                    vec![RestaurantEvent::Created(RestaurantCreated {
+                    Ok(vec![RestaurantEvent::Created(RestaurantCreated {
                         identifier: command.identifier.to_owned(),
                         name: command.name.to_owned(),
                         menu: command.menu.to_owned(),
                         r#final: false,
-                    })]
+                    })])
                 }
             }
             RestaurantCommand::ChangeMenu(command) => {
                 if state.is_some() {
-                    vec![RestaurantEvent::MenuChanged(RestaurantMenuChanged {
+                    Ok(vec![RestaurantEvent::MenuChanged(RestaurantMenuChanged {
                         identifier: command.identifier.to_owned(),
                         menu: command.menu.to_owned(),
                         r#final: false,
-                    })]
+                    })])
                 } else {
-                    error!("Failed to change the menu. Restaurant does not exist!");
+                    Err(DomainError::RestaurantMenuNotChanged(
+                        "Failed to change the menu. Restaurant does not exist!".to_string(),
+                    ))
                 }
             }
             RestaurantCommand::PlaceOrder(command) => {
                 if state.is_some() {
-                    vec![RestaurantEvent::OrderPlaced(OrderPlaced {
+                    Ok(vec![RestaurantEvent::OrderPlaced(OrderPlaced {
                         identifier: command.identifier.to_owned(),
                         order_identifier: command.order_identifier.to_owned(),
                         line_items: command.line_items.to_owned(),
                         r#final: false,
-                    })]
+                    })])
                 } else {
-                    error!("Failed to place the order. Restaurant does not exist!");
+                    Err(DomainError::OrderNotPlaced(
+                        "Failed to place the order. Restaurant does not exist!".to_string(),
+                    ))
                 }
             }
         }),

src/domain/restaurant_saga.rs

@@ -1,20 +1,29 @@
 use fmodel_rust::saga::Saga;
 
-use crate::domain::api::{OrderEvent, RestaurantCommand};
+use crate::domain::{api::RestaurantCommand, Event};
 
 /// A convenient type alias for the Restaurant choreography saga
-type RestaurantSaga<'a> = Saga<'a, OrderEvent, RestaurantCommand>;
+type RestaurantSaga<'a> = Saga<'a, Event, RestaurantCommand>;
 
 /// The Restaurant choreography saga - represents the central point of control deciding what to execute next.
 /// It is a function that takes an event and returns a list of commands.
 /// This Saga is not doing much ;)
 pub fn restaurant_saga<'a>() -> RestaurantSaga<'a> {
     Saga {
         react: Box::new(|_event| match _event {
-            OrderEvent::Created(..) => {
+            Event::RestaurantCreated(..) => {
                 vec![]
             }
-            OrderEvent::Prepared(..) => {
+            Event::OrderPrepared(..) => {
+                vec![]
+            }
+            Event::OrderPlaced(..) => {
+                vec![]
+            }
+            Event::RestaurantMenuChanged(..) => {
+                vec![]
+            }
+            Event::OrderCreated(..) => {
                 vec![]
             }
         }),