fmodel-rust 0.9.1

Accelerate development of compositional, safe, and ergonomic applications/information systems by effectively implementing Event Sourcing and CQRS patterns in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use derive_more::Display;
use fmodel_rust::{Identifier, Sum};
use std::error::Error;

use crate::api::{
    CancelOrderCommand, CreateOrderCommand, CreateShipmentCommand, OrderCancelledEvent,
    OrderCommand, OrderCreatedEvent, OrderEvent, OrderUpdatedEvent, ShipmentCommand,
    ShipmentCreatedEvent, ShipmentEvent, UpdateOrderCommand,
};

/// The command enum for all the domain commands (shipment and order)
/// It is convenient to have a single enum for all the command variants in your system to make it easy to combine all deciders into a single decider
/// Consider exposing this API to the outside world, instead of exposing the Order or Shipment commands individually. It is on you!
#[derive(Debug, PartialEq, Clone)]
#[allow(dead_code)]
pub enum Command {
    ShipmentCreate(CreateShipmentCommand),
    OrderCreate(CreateOrderCommand),
    OrderUpdate(UpdateOrderCommand),
    OrderCancel(CancelOrderCommand),
}

/// A mapping function to contra map the domain command to the inconvenient Sum<OrderCommand, ShipmentCommand>
#[allow(dead_code)]
pub fn command_from_sum(command: &Command) -> Sum<OrderCommand, ShipmentCommand> {
    match command {
        Command::ShipmentCreate(c) => Sum::Second(ShipmentCommand::Create(c.to_owned())),
        Command::OrderCreate(c) => Sum::First(OrderCommand::Create(c.to_owned())),
        Command::OrderUpdate(c) => Sum::First(OrderCommand::Update(c.to_owned())),
        Command::OrderCancel(c) => Sum::First(OrderCommand::Cancel(c.to_owned())),
    }
}
/// A mapping function to map the inconvenient Sum<OrderCommand, ShipmentCommand> to the domain command
#[allow(dead_code)]
pub fn sum_to_command(command: &Sum<OrderCommand, ShipmentCommand>) -> Command {
    match command {
        Sum::First(c) => match c {
            OrderCommand::Create(c) => Command::OrderCreate(c.to_owned()),
            OrderCommand::Update(c) => Command::OrderUpdate(c.to_owned()),
            OrderCommand::Cancel(c) => Command::OrderCancel(c.to_owned()),
        },
        Sum::Second(c) => match c {
            ShipmentCommand::Create(c) => Command::ShipmentCreate(c.to_owned()),
        },
    }
}
#[allow(dead_code)]
pub fn sum_to_command2(command: &Sum<ShipmentCommand, OrderCommand>) -> Command {
    match command {
        Sum::First(c) => match c {
            ShipmentCommand::Create(c) => Command::ShipmentCreate(c.to_owned()),
        },
        Sum::Second(c) => match c {
            OrderCommand::Create(c) => Command::OrderCreate(c.to_owned()),
            OrderCommand::Update(c) => Command::OrderUpdate(c.to_owned()),
            OrderCommand::Cancel(c) => Command::OrderCancel(c.to_owned()),
        },
    }
}

/// The event enum for all the domain events (shipment and order)
/// It is convenient to have a single enum for all the event variants in your system to make it easy to combine all deciders/sagas/views into a single decider/saga/view
/// Consider exposing this API to the outside world, instead of exposing the Order or Shipment events individually. It is on you!
#[derive(Debug, PartialEq, Clone)]
#[allow(dead_code)]
pub enum Event {
    ShipmentCreated(ShipmentCreatedEvent),
    OrderCreated(OrderCreatedEvent),
    OrderUpdated(OrderUpdatedEvent),
    OrderCancelled(OrderCancelledEvent),
}

/// A mapping function to contra map the domain event to the inconvenient Sum<OrderEvent, ShipmentEvent>
#[allow(dead_code)]
pub fn event_from_sum(event: &Event) -> Sum<OrderEvent, ShipmentEvent> {
    match event {
        Event::ShipmentCreated(c) => Sum::Second(ShipmentEvent::Created(c.to_owned())),
        Event::OrderCreated(c) => Sum::First(OrderEvent::Created(c.to_owned())),
        Event::OrderUpdated(c) => Sum::First(OrderEvent::Updated(c.to_owned())),
        Event::OrderCancelled(c) => Sum::First(OrderEvent::Cancelled(c.to_owned())),
    }
}
#[allow(dead_code)]
pub fn event_from_sum2(event: &Event) -> Sum<ShipmentEvent, OrderEvent> {
    match event {
        Event::ShipmentCreated(c) => Sum::First(ShipmentEvent::Created(c.to_owned())),
        Event::OrderCreated(c) => Sum::Second(OrderEvent::Created(c.to_owned())),
        Event::OrderUpdated(c) => Sum::Second(OrderEvent::Updated(c.to_owned())),
        Event::OrderCancelled(c) => Sum::Second(OrderEvent::Cancelled(c.to_owned())),
    }
}
/// A mapping function to map the inconvenient Sum<OrderEvent, ShipmentEvent> to the domain event
#[allow(dead_code)]
pub fn sum_to_event(event: &Sum<OrderEvent, ShipmentEvent>) -> Event {
    match event {
        Sum::First(e) => match e {
            OrderEvent::Created(c) => Event::OrderCreated(c.to_owned()),
            OrderEvent::Updated(c) => Event::OrderUpdated(c.to_owned()),
            OrderEvent::Cancelled(c) => Event::OrderCancelled(c.to_owned()),
        },
        Sum::Second(e) => match e {
            ShipmentEvent::Created(c) => Event::ShipmentCreated(c.to_owned()),
        },
    }
}

impl Identifier for Event {
    fn identifier(&self) -> String {
        match self {
            Event::ShipmentCreated(evt) => evt.shipment_id.to_string(),
            Event::OrderCreated(evt) => evt.order_id.to_string(),
            Event::OrderUpdated(evt) => evt.order_id.to_string(),
            Event::OrderCancelled(evt) => evt.order_id.to_string(),
        }
    }
}

impl Identifier for Command {
    fn identifier(&self) -> String {
        match self {
            Command::OrderCreate(cmd) => cmd.order_id.to_string(),
            Command::OrderUpdate(cmd) => cmd.order_id.to_string(),
            Command::OrderCancel(cmd) => cmd.order_id.to_string(),
            Command::ShipmentCreate(cmd) => cmd.shipment_id.to_string(),
        }
    }
}

/// Error type for the application/aggregate
#[derive(Debug, Display)]
#[allow(dead_code)]
pub enum AggregateError {
    DomainError(String),
    FetchEvents(String),
    SaveEvents(String),
    FetchState(String),
    SaveState(String),
}

impl Error for AggregateError {}

/// Error type for the application/materialized view
#[derive(Debug, Display)]
#[allow(dead_code)]
pub enum MaterializedViewError {
    FetchState(String),
    SaveState(String),
}

impl Error for MaterializedViewError {}

/// Error type for the saga manager
#[derive(Debug, Display)]
#[allow(dead_code)]
pub enum SagaManagerError {
    PublishAction(String),
}

impl Error for SagaManagerError {}