commerce-theory 0.1.2

Runtime Rust mirror of the CommerceTheory Lean package
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

use crate::event_sourcing::*;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum OrderEventSymbol {
    OrderPlaced,
    PaymentCaptured,
    RefundIssued,
    StockReserved,
    OrderShipped,
    Other,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum OrderEventValidationState {
    Start,
    Placed,
    Captured,
    Refunded,
    Shipped,
    Invalid,
}

#[must_use]
pub const fn domain_event_symbol(event: &DomainEvent) -> OrderEventSymbol {
    match event {
        DomainEvent::OrderPlaced(_, _) => OrderEventSymbol::OrderPlaced,
        DomainEvent::PaymentCaptured(_, _) => OrderEventSymbol::PaymentCaptured,
        DomainEvent::RefundIssued(_, _) => OrderEventSymbol::RefundIssued,
        DomainEvent::StockReserved(_, _) => OrderEventSymbol::StockReserved,
        DomainEvent::OrderShipped(_) => OrderEventSymbol::OrderShipped,
        DomainEvent::ReservationReleased(_, _)
        | DomainEvent::ReservedShipmentConfirmed(_, _)
        | DomainEvent::TaxLiabilityRecorded(_, _)
        | DomainEvent::LeadConverted(_, _)
        | DomainEvent::SupportCaseOpened(_, _)
        | DomainEvent::ShipmentPlanned(_, _)
        | DomainEvent::ShipmentDelivered(_)
        | DomainEvent::ReturnApproved(_, _, _) => OrderEventSymbol::Other,
    }
}

pub fn domain_event_symbols(events: &[DomainEvent]) -> Vec<OrderEventSymbol> {
    events.iter().map(domain_event_symbol).collect()
}

#[must_use]
pub const fn order_event_validation_step(
    state: OrderEventValidationState,
    symbol: OrderEventSymbol,
) -> OrderEventValidationState {
    match (state, symbol) {
        (OrderEventValidationState::Start, OrderEventSymbol::OrderPlaced)
        | (OrderEventValidationState::Placed, OrderEventSymbol::StockReserved) => {
            OrderEventValidationState::Placed
        }
        (OrderEventValidationState::Placed, OrderEventSymbol::PaymentCaptured)
        | (OrderEventValidationState::Captured, OrderEventSymbol::StockReserved) => {
            OrderEventValidationState::Captured
        }
        (OrderEventValidationState::Captured, OrderEventSymbol::RefundIssued) => {
            OrderEventValidationState::Refunded
        }
        (OrderEventValidationState::Captured, OrderEventSymbol::OrderShipped) => {
            OrderEventValidationState::Shipped
        }
        (state, OrderEventSymbol::Other) => state,
        _ => OrderEventValidationState::Invalid,
    }
}

pub fn validate_order_event_symbols(symbols: &[OrderEventSymbol]) -> OrderEventValidationState {
    symbols.iter().copied().fold(
        OrderEventValidationState::Start,
        order_event_validation_step,
    )
}

#[must_use]
pub fn order_event_word_accepted(symbols: &[OrderEventSymbol]) -> bool {
    matches!(
        validate_order_event_symbols(symbols),
        OrderEventValidationState::Shipped | OrderEventValidationState::Refunded
    )
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct OrderEventValidator;

impl OrderEventValidator {
    #[must_use]
    pub const fn start(self) -> OrderEventValidationState {
        OrderEventValidationState::Start
    }

    #[must_use]
    pub const fn step(
        self,
        state: OrderEventValidationState,
        symbol: OrderEventSymbol,
    ) -> OrderEventValidationState {
        order_event_validation_step(state, symbol)
    }

    #[must_use]
    pub fn run(self, symbols: &[OrderEventSymbol]) -> OrderEventValidationState {
        validate_order_event_symbols(symbols)
    }

    #[must_use]
    pub fn accepts(self, symbols: &[OrderEventSymbol]) -> bool {
        order_event_word_accepted(symbols)
    }
}

#[must_use]
pub const fn order_event_validator() -> OrderEventValidator {
    OrderEventValidator
}