Enum ErrorKind 

#[non_exhaustive]
pub enum ErrorKind {
    InvalidValue,
    InvalidState,
    InvalidCommand,
    NotFound,
    Conflict,
    Unauthorized,
    Internal,
}

Error category enum.

Used for unified handling: mapping to HTTP status codes, deciding whether to retry, choosing log levels, and so on.

Examples

use eventide_domain::error::ErrorKind;

let kind = ErrorKind::NotFound;
assert_eq!(kind.http_status(), 404);
assert_eq!(kind.default_code(), "NOT_FOUND");
assert!(!kind.is_retryable());

let conflict = ErrorKind::Conflict;
assert!(conflict.is_retryable());

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.

InvalidValue

Value-object validation failed (for example: a negative amount, a malformed email).

InvalidState

The aggregate’s current state forbids the operation (for example: trying to modify a closed order).

InvalidCommand

Command parameters or preconditions are not satisfied (for example: insufficient stock).

NotFound

The requested resource does not exist (for example: user / order not found).

Conflict

Optimistic-locking / version conflict (callers may retry).

Unauthorized

Unauthorised access.

Internal

Internal error (database, serialization, and other infrastructure failures).

Implementations

impl ErrorKind

pub const fn http_status(self) -> u16

Map the error kind to its HTTP status code.

ErrorKind	HTTP Status
InvalidValue	400
InvalidCommand	400
Unauthorized	401
NotFound	404
Conflict	409
InvalidState	422
Internal	500

pub const fn default_code(self) -> &'static str

Return the default error code for this category.

Codes are upper-snake-case strings such as "NOT_FOUND" or "INVALID_VALUE".

pub const fn is_retryable(self) -> bool

Whether the error is safe to retry.

Currently only ErrorKind::Conflict returns true, indicating that an optimistic-locking conflict can be retried.

pub const fn default_message(self) -> &'static str

Default user-facing message used by DomainError when no explicit message has been attached.

Trait Implementations

impl Clone for ErrorKind

fn clone(&self) -> ErrorKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ErrorKind

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

Formats the value using the given formatter.

impl Display for ErrorKind

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

Formats the value using the given formatter.

impl From<ErrorKind> for DomainError

fn from(kind: ErrorKind) -> Self

Converts to this type from the input type.

impl Hash for ErrorKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ErrorKind

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ErrorKind

impl Eq for ErrorKind

impl StructuralPartialEq for ErrorKind