Enum ReceiptEvent 

pub enum ReceiptEvent<E> {
    Committed(CommittedEvent<E>),
    Redacted(RedactedEvent),
}

One event as offered to WorkflowDefinition::receipts: its payload is either still in the ledger or has been erased.

A domain matches on this rather than on a payload that failed to deserialize, which is the difference between a receipt that says something honest about an erased event and a turn that renders as though the data were still there.

It is deliberately not #[non_exhaustive]

A payload is present or it is not; there is no third case, and the exhaustive match is the mechanism. A wildcard arm here is exactly the arm that would render an erased event as though nothing had happened, so a future variant — if one is ever justified — must break the domains that render receipts rather than fall silently into their catch-all.

Variants

Committed(CommittedEvent<E>)

The payload is in the ledger; the receipt may say what changed.

Redacted(RedactedEvent)

The payload was erased; the receipt may say that it happened, and that the detail is gone.

Implementations

impl<E> ReceiptEvent<E>

pub fn event_id(&self) -> EventId

Identifier in the ledger, whether or not the payload survived.

pub fn event_type(&self) -> &str

Stable event type label, whether or not the payload survived.

pub fn occurred_at(&self) -> DateTime<Utc>

When the event was committed, whether or not the payload survived.

pub fn event_ref(&self) -> EventRef

Reference without payload, which is all a receipt cites.

pub fn payload(&self) -> Option<&E>

The payload, or None when it was erased.

pub fn redaction(&self) -> Option<&EventRedaction>

The erasure record, or None while the payload is still there.

pub fn is_redacted(&self) -> bool

Returns true when the payload was erased.

pub fn try_map_payload_ref<F, Err>( &self, f: impl FnOnce(&E) -> Result<F, Err>, ) -> Result<ReceiptEvent<F>, Err>

Transforms the payload by reference, keeping identity and timestamp.

A redacted event passes through untouched: there is nothing to convert, which is why the type-erasure boundary can hand a domain an erased event without ever trying — and failing — to deserialize an empty payload.

Errors

Whatever f returns for a payload that is still present.

Trait Implementations

impl<E: Clone> Clone for ReceiptEvent<E>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<E: Debug> Debug for ReceiptEvent<E>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<E: Eq> Eq for ReceiptEvent<E>

impl<E> From<CommittedEvent<E>> for ReceiptEvent<E>

fn from(event: CommittedEvent<E>) -> Self

Converts to this type from the input type.

impl<E> From<RedactedEvent> for ReceiptEvent<E>

fn from(event: RedactedEvent) -> Self

Converts to this type from the input type.

impl<E: PartialEq> PartialEq for ReceiptEvent<E>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<E: PartialEq> StructuralPartialEq for ReceiptEvent<E>