Enum StoreError 

#[non_exhaustive]
pub enum StoreError<A, EncErr, DecErr> {
    Conflict {
        stream_id: ErrorId,
        expected: Option<Version>,
        actual: Option<Version>,
    },
    StreamNotFound {
        stream_id: ErrorId,
    },
    Adapter(A),
    Encode(EncErr),
    Decode(DecErr),
    Kernel(KernelError),
    VersionOverflow,
    EnvelopeSynthesis(ForDecodeError),
    Envelope(EnvelopeError),
}

Errors from the event store layer.

Generic over adapter (A), encode (EncErr), and decode (DecErr) error types — zero allocation, no Box<dyn Error>.

EncErr and DecErr are independent so write-only and read-only codecs can each set the unused side to Infallible. For the common case where a single underlying format powers both directions, the implementor picks the same Error associated type on both Encode and Decode impls and EncErr == DecErr falls out without a where-clause.

Upcast errors are not part of this type — the no-upcaster load / save path can’t produce them. When the user calls EventStore::load_with (passing an upcast function), the result wraps StoreError in LoadWithError alongside the user’s upcast error type.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Conflict

Optimistic concurrency conflict.

Fields

stream_id: ErrorId

expected: Option<Version>

actual: Option<Version>

StreamNotFound

Stream not found.

Fields

stream_id: ErrorId

Adapter(A)

Database adapter failure.

Encode(EncErr)

Serialization failure on the write path.

Decode(DecErr)

Deserialization failure on the read path.

Kernel(KernelError)

Kernel error during replay (e.g. version mismatch, rehydration limit).

VersionOverflow

Version overflow: cannot advance past u64::MAX.

EnvelopeSynthesis(ForDecodeError)

Failure while synthesizing a fresh envelope for codec decode.

Reachable only from upcaster-driven paths (EventStore::load_with): after the user’s upcast transforms the event, a fresh aligned envelope is built from the transformed event_type + payload via PersistedEnvelope::for_decode. The build can fail at the value-newtype boundary (oversize event_type/payload), the wire encode (FrameLengthOverflow), or the envelope construction (range invariants).

Envelope(EnvelopeError)

Envelope construction rejected user-supplied bytes (payload exceeded its size cap, or another value-newtype invariant).

Raised on the save path when an encoded payload violates the invariants enforced by the PendingEnvelope builder. The schema-version-zero case is not reachable from the typed-repository save path because SchemaVersion is constructed from NonZeroU32.

Implementations

impl<A, EncErr, DecErr> StoreError<A, EncErr, DecErr>

pub const fn is_conflict(&self) -> bool

Returns true if this is an optimistic-concurrency Conflict.

Conflict is the one error the store can assert a semantic fact about that the consumer cannot infer otherwise: the expected version was stale, so reloading the aggregate and re-running the (pure, side-effect-free) decision will likely succeed. It is the natural predicate for a consumer-owned retry loop — e.g. a supervising actor retrying load → handle → save, or a tower::retry::Policy / backon .when(|e| e.is_conflict()).

mnesis deliberately ships no retry machinery: classifying other errors as retryable (transient adapter I/O, say) needs context only the consumer has, and the loop, backoff, and sleep are runtime concerns. This predicate is the entire retry-facing surface.

Trait Implementations

impl<A, EncErr, DecErr> ConflictPredicate for StoreError<A, EncErr, DecErr>

fn is_conflict(&self) -> bool

true iff this error is an optimistic-concurrency conflict.

impl<A: Debug, EncErr: Debug, DecErr: Debug> Debug for StoreError<A, EncErr, DecErr>

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

Formats the value using the given formatter.

impl<A, EncErr, DecErr> Display for StoreError<A, EncErr, DecErr>

where A: Display, EncErr: Display, DecErr: Display,

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

Formats the value using the given formatter.

impl<A, EncErr, DecErr> Error for StoreError<A, EncErr, DecErr>

where A: Error + 'static, EncErr: Error + 'static, DecErr: Error + 'static, Self: Debug + Display,

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl<A, EncErr, DecErr> From<EnvelopeError> for StoreError<A, EncErr, DecErr>

fn from(source: EnvelopeError) -> Self

Converts to this type from the input type.

impl<A, EncErr, DecErr> From<KernelError> for StoreError<A, EncErr, DecErr>

fn from(source: KernelError) -> Self

Converts to this type from the input type.

impl<A, EncErr, DecErr, UpErr> From<StoreError<A, EncErr, DecErr>> for LoadWithError<A, EncErr, DecErr, UpErr>

fn from(source: StoreError<A, EncErr, DecErr>) -> Self

Converts to this type from the input type.