datum-persistence 0.11.3

Event sourcing, durable state, and CQRS persistence for Datum
Documentation
use crate::PersistenceResult;

/// Converts domain events to and from their journal representation.
///
/// Writes are always one-to-one. Recovery defaults to one-to-one through
/// [`Self::from_journal`], while [`Self::from_journal_events`] can widen one
/// stored event to zero or more domain events for schema evolution.
pub trait EventAdapter<D, J>: Send + Sync + 'static {
    /// Adapts one domain event and returns its durable adapter manifest.
    fn to_journal(&self, event: &D) -> PersistenceResult<(String, J)>;

    /// Adapts one stored journal event during recovery.
    #[allow(clippy::wrong_self_convention)]
    fn from_journal(&self, adapter_manifest: &str, event: J) -> PersistenceResult<D>;

    /// Adapts one stored journal event to zero or more recovery-only domain events.
    ///
    /// The default preserves the original one-to-one adapter contract. Override
    /// this method to filter an obsolete event or expand one historical event
    /// into multiple current-domain transitions.
    #[allow(clippy::wrong_self_convention)]
    fn from_journal_events(&self, adapter_manifest: &str, event: J) -> PersistenceResult<Vec<D>> {
        self.from_journal(adapter_manifest, event)
            .map(|event| vec![event])
    }
}

/// Converts domain state to and from its snapshot or durable-state representation.
pub trait StateAdapter<S, J>: Send + Sync + 'static {
    /// Adapts one domain state and returns its durable adapter manifest.
    fn to_journal(&self, state: &S) -> PersistenceResult<(String, J)>;

    /// Adapts one stored journal state during recovery.
    #[allow(clippy::wrong_self_convention)]
    fn from_journal(&self, adapter_manifest: &str, state: J) -> PersistenceResult<S>;
}

/// Identity event/state adapter for cases where domain and journal types match.
#[derive(Debug, Clone, Copy, Default)]
pub struct IdentityAdapter;

impl<T> EventAdapter<T, T> for IdentityAdapter
where
    T: Clone,
{
    fn to_journal(&self, event: &T) -> PersistenceResult<(String, T)> {
        Ok((String::new(), event.clone()))
    }

    fn from_journal(&self, _adapter_manifest: &str, event: T) -> PersistenceResult<T> {
        Ok(event)
    }
}

impl<T> StateAdapter<T, T> for IdentityAdapter
where
    T: Clone,
{
    fn to_journal(&self, state: &T) -> PersistenceResult<(String, T)> {
        Ok((String::new(), state.clone()))
    }

    fn from_journal(&self, _adapter_manifest: &str, state: T) -> PersistenceResult<T> {
        Ok(state)
    }
}

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

    #[test]
    fn identity_adapter_preserves_events_and_state() {
        let adapter = IdentityAdapter;

        let (event_manifest, event) =
            EventAdapter::to_journal(&adapter, &"event".to_owned()).unwrap();
        assert_eq!(event_manifest, "");
        assert_eq!(
            EventAdapter::from_journal(&adapter, &event_manifest, event).unwrap(),
            "event"
        );

        let (state_manifest, state) = StateAdapter::to_journal(&adapter, &42_u64).unwrap();
        assert_eq!(state_manifest, "");
        assert_eq!(
            StateAdapter::from_journal(&adapter, &state_manifest, state).unwrap(),
            42
        );
    }
}