timesource 0.1.3

Event sourcing with TimescaleDb
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

#![allow(dead_code)]

use chrono::{DateTime, Utc};
use minicbor::{Decode, Encode};
use thiserror::Error;
use timesource::{Aggregate, TimesourceEvent};
use uuid::Uuid;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct UserState {
    pub name: Option<String>,
    pub surname: Option<String>,
}

#[derive(Debug)]
pub enum UserCommand {
    Create,
    SetName {
        name: String,
        surname: Option<String>,
    },
}

#[derive(Debug, Clone, PartialEq, Eq, TimesourceEvent, Decode, Encode)]
#[timesource(encoding = "cbor")]
pub enum UserEvent {
    #[b(0)]
    Created,
    #[b(1)]
    NameChanged {
        #[b(0)]
        name: String,
        #[b(2)]
        surname: Option<String>,
    },
}

#[derive(Error, Debug, Clone, PartialEq, Eq)]
pub enum UserError {
    #[error("Already created")]
    AlreadyCreated,
    #[error("Not yet created")]
    NotYetCreated,
}

#[derive(Debug, Default, Clone, Copy)]
pub struct UserAggregate;

impl Aggregate for UserAggregate {
    type State = UserState;
    type Event = UserEvent;
    type Command = UserCommand;
    type Error = UserError;

    fn apply_first(
        _: Uuid,
        event: &Self::Event,
        _: DateTime<Utc>,
        _event_id: Option<u64>,
    ) -> Result<Self::State, Self::Error> {
        if let UserEvent::Created = event {
            return Ok(UserState {
                name: None,
                surname: None,
            });
        }

        Err(UserError::NotYetCreated)
    }

    fn apply_next(
        state: &mut Self::State,
        event: &Self::Event,
        _: DateTime<Utc>,
        _event_id: Option<u64>,
    ) -> Result<(), Self::Error> {
        match event {
            UserEvent::Created { .. } => Err(UserError::AlreadyCreated),

            UserEvent::NameChanged { name, surname } => {
                state.name = Some(name.clone());
                state.surname = surname.clone();

                Ok(())
            }
        }
    }

    fn handle_first(command: Self::Command) -> Result<Vec<Self::Event>, Self::Error> {
        if let UserCommand::Create = command {
            return Ok(vec![UserEvent::Created]);
        }

        Err(UserError::NotYetCreated)
    }

    fn handle_next(
        _state: &Self::State,
        command: Self::Command,
    ) -> Result<Vec<Self::Event>, Self::Error> {
        match command {
            UserCommand::Create => Err(UserError::AlreadyCreated),
            UserCommand::SetName { name, surname } => {
                Ok(vec![UserEvent::NameChanged { name, surname }])
            }
        }
    }
}