Struct Saga

pub struct Saga<'a, AR: 'a, A: 'a> {
    pub react: ReactFunction<'a, AR, A>,
}

Saga is a datatype that represents the central point of control, deciding what to execute next (A), based on the action result (AR). It has two generic parameters AR/Action Result, A/Action , representing the type of the values that Saga may contain or use. 'a is used as a lifetime parameter, indicating that all references contained within the struct (e.g., references within the function closures) must have a lifetime that is at least as long as ’a.

It is common to consider Event as Action Result, and Command as Action, but it is not mandatory. For example, Action Result can be a request response from a remote service.

Example

use fmodel_rust::saga::Saga;

fn saga<'a>() -> Saga<'a, OrderEvent, ShipmentCommand> {
    Saga {
        react: Box::new(|event| match event {
            OrderEvent::Created(created_event) => {
                vec![ShipmentCommand::Create(CreateShipmentCommand {
                    shipment_id: created_event.order_id,
                    order_id: created_event.order_id,
                    customer_name: created_event.customer_name.to_owned(),
                    items: created_event.items.to_owned(),
                })]
            }
            OrderEvent::Updated(_updated_event) => {
                vec![]
            }
            OrderEvent::Cancelled(_cancelled_event) => {
                vec![]
            }
        }),
    }
}

#[derive(Debug, PartialEq)]
#[allow(dead_code)]
pub enum ShipmentCommand {
    Create(CreateShipmentCommand),
}

#[derive(Debug, PartialEq)]
pub struct CreateShipmentCommand {
    pub shipment_id: u32,
    pub order_id: u32,
    pub customer_name: String,
    pub items: Vec<String>,
}

#[derive(Debug)]
pub enum OrderEvent {
    Created(OrderCreatedEvent),
    Updated(OrderUpdatedEvent),
    Cancelled(OrderCancelledEvent),
}

#[derive(Debug)]
pub struct OrderCreatedEvent {
    pub order_id: u32,
    pub customer_name: String,
    pub items: Vec<String>,
}

#[derive(Debug)]
pub struct OrderUpdatedEvent {
    pub order_id: u32,
    pub updated_items: Vec<String>,
}

#[derive(Debug)]
pub struct OrderCancelledEvent {
    pub order_id: u32,
}

let saga: Saga<OrderEvent, ShipmentCommand> = saga();
let order_created_event = OrderEvent::Created(OrderCreatedEvent {
        order_id: 1,
        customer_name: "John Doe".to_string(),
        items: vec!["Item 1".to_string(), "Item 2".to_string()],
    });

let commands = (saga.react)(&order_created_event);

Fields

react: ReactFunction<'a, AR, A>

The react function is driving the next action based on the action result.

Implementations

impl<'a, AR, A> Saga<'a, AR, A>

pub fn map_action<A2, F>(self, f: &'a F) -> Saga<'a, AR, A2>

where F: Fn(&A) -> A2 + Send + Sync,

Maps the Saga over the A/Action type parameter. Creates a new instance of Saga<AR, A2>.

pub fn map_action_result<AR2, F>(self, f: &'a F) -> Saga<'a, AR2, A>

where F: Fn(&AR2) -> AR + Send + Sync,

Maps the Saga over the AR/ActionResult type parameter. Creates a new instance of Saga<AR2, A>.

pub fn combine<AR2, A2>( self, saga2: Saga<'a, AR2, A2>, ) -> Saga<'a, Sum<AR, AR2>, Sum<A2, A>>

👎Deprecated since 0.8.0: Use the merge function instead. This ensures all your sagas can subscribe to all Event/E in the system.

Combines two sagas into one. Creates a new instance of a Saga by combining two sagas of type AR, A and AR2, A2 into a new saga of type Sum<AR, AR2>, Sum<A2, A>

pub fn merge<A2>(self, saga2: Saga<'a, AR, A2>) -> Saga<'a, AR, Sum<A2, A>>

Merges two sagas into one. Creates a new instance of a Saga by merging two sagas of type AR, A and AR, A2 into a new saga of type AR, Sum<A, A2> Similar to combine, but the event type is the same for both sagas. This ensures all your sagas can subscribe to all Event/E in the system.

pub fn merge3<A2, A3>( self, saga2: Saga<'a, AR, A2>, saga3: Saga<'a, AR, A3>, ) -> Saga<'a, AR, Sum3<A, A2, A3>>

where A: Clone, A2: Clone, A3: Clone,

Merges three sagas into one.

pub fn merge4<A2, A3, A4>( self, saga2: Saga<'a, AR, A2>, saga3: Saga<'a, AR, A3>, saga4: Saga<'a, AR, A4>, ) -> Saga<'a, AR, Sum4<A, A2, A3, A4>>

where A: Clone, A2: Clone, A3: Clone, A4: Clone,

Merges four sagas into one.

pub fn merge5<A2, A3, A4, A5>( self, saga2: Saga<'a, AR, A2>, saga3: Saga<'a, AR, A3>, saga4: Saga<'a, AR, A4>, saga5: Saga<'a, AR, A5>, ) -> Saga<'a, AR, Sum5<A, A2, A3, A4, A5>>

where A: Clone, A2: Clone, A3: Clone, A4: Clone, A5: Clone,

Merges five sagas into one.

pub fn merge6<A2, A3, A4, A5, A6>( self, saga2: Saga<'a, AR, A2>, saga3: Saga<'a, AR, A3>, saga4: Saga<'a, AR, A4>, saga5: Saga<'a, AR, A5>, saga6: Saga<'a, AR, A6>, ) -> Saga<'a, AR, Sum6<A, A2, A3, A4, A5, A6>>

where A: Clone, A2: Clone, A3: Clone, A4: Clone, A5: Clone, A6: Clone,

Merges six sagas into one.

Trait Implementations

impl<AR, A> ActionComputation<AR, A> for Saga<'_, AR, A>

fn compute_new_actions(&self, event: &AR) -> Vec<A>

Computes new commands/actions based on the event/action_result.