domain_patterns 0.2.141

Domain patterns holds patterns from the world of Domain Driven Design.
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

use domain_patterns::models::{Entity, AggregateRoot};
use domain_patterns::event::DomainEvent;
use domain_patterns::message::Message;
use chrono::Utc;
use serde::{Serialize, Deserialize};
use uuid::Uuid;
use crate::common::NaiveUser;

// This is a simple example of the struct that matches the database rows events will be stored into.
// Some data from event_data is denormalized into rows for easy querying.
pub struct UserEventRecord {
    pub id: String,
    pub aggregate_id: String,
    pub version: u64,
    pub event_data: UserEvents,
}

#[derive(Serialize, Deserialize, Clone, DomainEvent)]
pub struct UserCreatedEvent {
    pub aggregate_id: String,
    pub first_name: String,
    pub last_name: String,
    pub email: String,
    pub version: u64,
    pub id: Uuid,
    pub occurred: i64,
}

impl UserCreatedEvent {
    pub fn new(user: &NaiveUser) -> UserCreatedEvent {
        UserCreatedEvent {
            aggregate_id: user.id(),
            first_name: user.first_name().clone(),
            last_name: user.last_name().clone(),
            email: user.email().to_string(),
            version: user.version(),
            id: Uuid::new_v4(),
            occurred: Utc::now().timestamp(),
        }
    }
}

// Only making clonable for test case because we don't have a real backing database for events,
// and need to easily clone the events so we keep them in our backing hashmap and return owned
// copies back, since we will be returning owned copies when dealing with an actual datastore.
#[derive(Serialize, Deserialize, Clone, DomainEvent)]
pub struct FirstNameUpdatedEvent {
    pub id: Uuid,
    pub aggregate_id: String,
    pub first_name: String,
    pub version: u64,
    pub occurred: i64,
}

impl FirstNameUpdatedEvent {
    fn new(user: &NaiveUser) -> FirstNameUpdatedEvent {
        FirstNameUpdatedEvent {
            aggregate_id: user.id(),
            first_name: user.first_name().clone(),
            version: user.version(),
            id: Uuid::new_v4(),
            occurred: Utc::now().timestamp(),
        }
    }
}

#[derive(Clone, DomainEvents)]
pub enum UserEvents {
    UserCreated(UserCreatedEvent),
    FirstNameUpdated(FirstNameUpdatedEvent),
}

/// Note: This seems really dumb that we have to do this, but currently it seems like due to language
/// limitations regarding runtime inspection this might be the only way.
impl From<&UserEvents> for UserEventRecord {
    fn from(value: &UserEvents) -> Self {
        use UserEvents::*;
        match value {
            UserCreated(e) => {
                UserEventRecord {
                    id: e.id().to_string(),
                    aggregate_id: e.aggregate_id(),
                    version: e.version(),
                    event_data: UserCreated(e.clone()),
                }
            },
            FirstNameUpdated(e) => {
                UserEventRecord {
                    id: e.id().to_string(),
                    aggregate_id: e.aggregate_id(),
                    version: e.version(),
                    event_data: FirstNameUpdated(e.clone()),
                }
            }
        }
    }
}