rakka-persistence-mongodb 0.2.1

MongoDB journal and snapshot store for rakka — indexed collections, atomic multi-document inserts, BSON payloads.
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

//! BSON-friendly document shapes. `payload` is stored as raw bytes
//! via BSON `Binary`.

use mongodb::bson::{spec::BinarySubtype, Binary};
use rakka_persistence::{PersistentRepr, SnapshotMetadata};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EventDoc {
    pub persistence_id: String,
    pub sequence_nr: i64,
    pub payload: Binary,
    pub manifest: String,
    pub writer_uuid: String,
    pub deleted: bool,
    pub tags: Vec<String>,
    pub created_at: i64,
}

impl EventDoc {
    pub fn from_repr(r: &PersistentRepr, created_at: i64) -> Self {
        Self {
            persistence_id: r.persistence_id.clone(),
            sequence_nr: r.sequence_nr as i64,
            payload: Binary { subtype: BinarySubtype::Generic, bytes: r.payload.clone() },
            manifest: r.manifest.clone(),
            writer_uuid: r.writer_uuid.clone(),
            deleted: r.deleted,
            tags: r.tags.clone(),
            created_at,
        }
    }

    pub fn into_repr(self) -> PersistentRepr {
        PersistentRepr {
            persistence_id: self.persistence_id,
            sequence_nr: self.sequence_nr as u64,
            payload: self.payload.bytes,
            manifest: self.manifest,
            writer_uuid: self.writer_uuid,
            deleted: self.deleted,
            tags: self.tags,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SnapshotDoc {
    pub persistence_id: String,
    pub sequence_nr: i64,
    pub payload: Binary,
    pub timestamp: i64,
    pub created_at: i64,
}

impl SnapshotDoc {
    pub fn from_meta(meta: &SnapshotMetadata, payload: Vec<u8>, created_at: i64) -> Self {
        Self {
            persistence_id: meta.persistence_id.clone(),
            sequence_nr: meta.sequence_nr as i64,
            payload: Binary { subtype: BinarySubtype::Generic, bytes: payload },
            timestamp: meta.timestamp as i64,
            created_at,
        }
    }

    pub fn into_parts(self) -> (SnapshotMetadata, Vec<u8>) {
        (
            SnapshotMetadata {
                persistence_id: self.persistence_id,
                sequence_nr: self.sequence_nr as u64,
                timestamp: self.timestamp as u64,
            },
            self.payload.bytes,
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn event_round_trip() {
        let original = PersistentRepr {
            persistence_id: "p".into(),
            sequence_nr: 3,
            payload: vec![1, 2, 3],
            manifest: "m".into(),
            writer_uuid: "w".into(),
            deleted: false,
            tags: vec!["x".into()],
        };
        let doc = EventDoc::from_repr(&original, 100);
        let back = doc.into_repr();
        assert_eq!(back.payload, original.payload);
        assert_eq!(back.tags, original.tags);
    }
}