Skip to main content

datum_persistence/serialization/
adapter.rs

1use crate::PersistenceResult;
2
3/// Converts domain events to and from their journal representation.
4///
5/// Writes are always one-to-one. Recovery defaults to one-to-one through
6/// [`Self::from_journal`], while [`Self::from_journal_events`] can widen one
7/// stored event to zero or more domain events for schema evolution.
8pub trait EventAdapter<D, J>: Send + Sync + 'static {
9    /// Adapts one domain event and returns its durable adapter manifest.
10    fn to_journal(&self, event: &D) -> PersistenceResult<(String, J)>;
11
12    /// Adapts one stored journal event during recovery.
13    #[allow(clippy::wrong_self_convention)]
14    fn from_journal(&self, adapter_manifest: &str, event: J) -> PersistenceResult<D>;
15
16    /// Adapts one stored journal event to zero or more recovery-only domain events.
17    ///
18    /// The default preserves the original one-to-one adapter contract. Override
19    /// this method to filter an obsolete event or expand one historical event
20    /// into multiple current-domain transitions.
21    #[allow(clippy::wrong_self_convention)]
22    fn from_journal_events(&self, adapter_manifest: &str, event: J) -> PersistenceResult<Vec<D>> {
23        self.from_journal(adapter_manifest, event)
24            .map(|event| vec![event])
25    }
26}
27
28/// Converts domain state to and from its snapshot or durable-state representation.
29pub trait StateAdapter<S, J>: Send + Sync + 'static {
30    /// Adapts one domain state and returns its durable adapter manifest.
31    fn to_journal(&self, state: &S) -> PersistenceResult<(String, J)>;
32
33    /// Adapts one stored journal state during recovery.
34    #[allow(clippy::wrong_self_convention)]
35    fn from_journal(&self, adapter_manifest: &str, state: J) -> PersistenceResult<S>;
36}
37
38/// Identity event/state adapter for cases where domain and journal types match.
39#[derive(Debug, Clone, Copy, Default)]
40pub struct IdentityAdapter;
41
42impl<T> EventAdapter<T, T> for IdentityAdapter
43where
44    T: Clone,
45{
46    fn to_journal(&self, event: &T) -> PersistenceResult<(String, T)> {
47        Ok((String::new(), event.clone()))
48    }
49
50    fn from_journal(&self, _adapter_manifest: &str, event: T) -> PersistenceResult<T> {
51        Ok(event)
52    }
53}
54
55impl<T> StateAdapter<T, T> for IdentityAdapter
56where
57    T: Clone,
58{
59    fn to_journal(&self, state: &T) -> PersistenceResult<(String, T)> {
60        Ok((String::new(), state.clone()))
61    }
62
63    fn from_journal(&self, _adapter_manifest: &str, state: T) -> PersistenceResult<T> {
64        Ok(state)
65    }
66}
67
68#[cfg(test)]
69mod tests {
70    use super::*;
71
72    #[test]
73    fn identity_adapter_preserves_events_and_state() {
74        let adapter = IdentityAdapter;
75
76        let (event_manifest, event) =
77            EventAdapter::to_journal(&adapter, &"event".to_owned()).unwrap();
78        assert_eq!(event_manifest, "");
79        assert_eq!(
80            EventAdapter::from_journal(&adapter, &event_manifest, event).unwrap(),
81            "event"
82        );
83
84        let (state_manifest, state) = StateAdapter::to_journal(&adapter, &42_u64).unwrap();
85        assert_eq!(state_manifest, "");
86        assert_eq!(
87            StateAdapter::from_journal(&adapter, &state_manifest, state).unwrap(),
88            42
89        );
90    }
91}