Enum RepositoryError 

#[non_exhaustive]
pub enum RepositoryError {
    LockPoisoned(&'static str),
    Lock(LockError),
    ConcurrentWrite {
        id: String,
        expected: u64,
        actual: u64,
    },
    DuplicateStreamInBatch {
        id: String,
    },
    DuplicateOutboxMessageInBatch {
        id: String,
    },
    DuplicateInboxReceipt {
        consumer: String,
        message_id: String,
    },
    InvalidInboxReceipt {
        consumer: String,
        message_id: String,
    },
    CausalWriteRequired {
        table: String,
    },
    InvalidStreamIdentity {
        aggregate_type: String,
        aggregate_id: String,
        reason: String,
    },
    NotFound {
        id: String,
    },
    InvalidState {
        id: String,
        expected: &'static str,
        actual: String,
    },
    Replay(String),
    Model(String),
    Storage {
        operation: String,
        retryable: bool,
        source: Option<Box<dyn Error + Send + Sync>>,
    },
}

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.

LockPoisoned(&'static str)

Lock(LockError)

ConcurrentWrite

Fields

id: String

expected: u64

actual: u64

DuplicateStreamInBatch

Fields

id: String

DuplicateOutboxMessageInBatch

Fields

id: String

DuplicateInboxReceipt

A consumer inbox receipt (consumer, message_id) was already recorded. The commit is rolled back so the consumer’s effects are not double-applied; the message has already been processed (an at-least-once replay).

Fields

consumer: String

message_id: String

InvalidInboxReceipt

A consumer inbox receipt had an empty consumer or message_id. Rejected uniformly across backends before any write (the relational CHECK constraints are a defense-in-depth backstop).

Fields

consumer: String

message_id: String

CausalWriteRequired

A raw/legacy repository batch targeted a causal-owned read-model table.

Fields

table: String

InvalidStreamIdentity

Fields

aggregate_type: String

aggregate_id: String

reason: String

NotFound

Fields

id: String

InvalidState

Fields

id: String

expected: &'static str

actual: String

Replay(String)

Model(String)

Storage

A storage backend (event store, read model, snapshot store) failed to complete an operation. Unlike RepositoryError::Model — a deterministic modeling/decoding fault — this carries an explicit retry classification so callers can distinguish a transient outage (connection refused, pool timeout, SQLITE_BUSY) from a deterministic failure (constraint violation, malformed row) without string-sniffing the message.

The optional source preserves the underlying error for diagnostics and dead-letter metadata; it is exposed through Error::source.

Fields

operation: String

The operation that failed (e.g. "sqlite insert event").

retryable: bool

Whether retrying the same operation may succeed.

source: Option<Box<dyn Error + Send + Sync>>

The underlying backend error, if available.

Implementations

impl RepositoryError

pub fn retryable_storage( operation: impl Into<String>, source: impl Error + Send + Sync + 'static, ) -> Self

Construct a retryable storage failure carrying its source.

pub fn permanent_storage( operation: impl Into<String>, source: impl Error + Send + Sync + 'static, ) -> Self

Construct a permanent storage failure carrying its source.

pub fn kind(&self) -> RetryClass

Classify this error for retry purposes.

The contract a runner relies on: a retryable error should be redelivered (a later attempt may succeed); a permanent error should not, because re-running the identical operation cannot change a deterministic outcome.

• Storage { retryable, .. } reports the classification captured when the backend error was mapped (connection/pool/timeout → retryable; constraint/decode → permanent).
• Lock defers to LockError::kind.
• ConcurrentWrite is retryable: an optimistic-concurrency conflict means another writer won the race; reloading and reapplying typically succeeds. This preserves the prior behavior where it fell into the retryable bucket.
• NotFound is retryable: under at-least-once delivery it is usually an out-of-order race a later redelivery resolves.
• The deterministic faults (Model, Replay, invalid identity/receipt, InvalidState, duplicate-in-batch, LockPoisoned) are permanent.

pub fn is_retryable(&self) -> bool

Whether this error is retryable.

Trait Implementations

impl Debug for RepositoryError

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

Formats the value using the given formatter.

impl Display for RepositoryError

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

Formats the value using the given formatter.

impl Error for RepositoryError

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 From<EventRecordError> for RepositoryError

fn from(err: EventRecordError) -> Self

Converts to this type from the input type.

impl From<LockError> for RepositoryError

fn from(err: LockError) -> Self

Converts to this type from the input type.

impl From<RepositoryError> for HandlerError

fn from(err: RepositoryError) -> Self

Converts to this type from the input type.

impl From<RepositoryError> for TransportError

Repository/store failures (lock contention, storage hiccups, stale-claim conflicts) are retryable: usually transient, resolved by a later re-claim. This conversion lives with the outbox bridge — which legitimately knows both the store and the bus — so bus core stays free of RepositoryError.

fn from(error: RepositoryError) -> Self

Converts to this type from the input type.

impl From<RepositoryError> for ProjectionProtocolError

fn from(error: RepositoryError) -> Self

Converts to this type from the input type.

impl From<TableStoreError> for RepositoryError

fn from(err: TableStoreError) -> Self

Converts to this type from the input type.