Struct DomainError 

pub struct DomainError { /* private fields */ }

Unified error type for the domain layer.

Modelled after std::io::Error, DomainError supports three representations:

• a simple error that only carries a category;
• an error with a custom message;
• an error wrapping another error type, preserving the original concrete type so it can be downcast later.

Construction

Convenience constructors

use eventide_domain::error::DomainError;

// Invalid value
let err = DomainError::invalid_value("amount must be non-negative");

// Invalid state
let err = DomainError::invalid_state("order is closed and cannot be modified");

// Resource not found
let err = DomainError::not_found("user 123");

// Version conflict
let err = DomainError::conflict(1, 2);

Generic constructor

use eventide_domain::error::{DomainError, ErrorKind};

// Specify both category and message
let err = DomainError::new(ErrorKind::InvalidCommand, "insufficient stock");

// Custom error code
let err = DomainError::new(ErrorKind::NotFound, "user not found")
    .with_code("USER_NOT_FOUND");

Wrapping a custom error

use eventide_domain::error::{DomainError, ErrorKind, ErrorCode};
use thiserror::Error;

#[derive(Debug, Error)]
#[error("custom error")]
struct MyError;

let err = DomainError::custom(ErrorKind::Internal, MyError);

// The original error can be retrieved.
assert!(err.downcast_ref::<MyError>().is_some());

Implementations

impl DomainError

pub const fn from_kind(kind: ErrorKind) -> Self

Build a simple error from a category alone.

Examples

use eventide_domain::error::{DomainError, ErrorKind};

let err = DomainError::from_kind(ErrorKind::NotFound);
assert_eq!(err.kind(), ErrorKind::NotFound);

pub fn new(kind: ErrorKind, message: impl Into<Box<str>>) -> Self

Build an error with a human-readable message.

Examples

use eventide_domain::error::{DomainError, ErrorKind};

let err = DomainError::new(ErrorKind::InvalidValue, "amount must be positive");
assert_eq!(err.to_string(), "amount must be positive");

pub fn custom<E>(kind: ErrorKind, error: E) -> Self

where E: StdError + Send + Sync + 'static,

Wrap an existing custom error.

The original error’s concrete type is preserved and can be retrieved via DomainError::downcast_ref.

Examples

use eventide_domain::error::{DomainError, ErrorKind};
use std::io;

let io_err = io::Error::new(io::ErrorKind::NotFound, "file not found");
let err = DomainError::custom(ErrorKind::Internal, io_err);

// Retrieve the original error.
let inner = err.downcast_ref::<io::Error>().unwrap();
assert_eq!(inner.kind(), io::ErrorKind::NotFound);

pub fn with_code(self, code: &'static str) -> Self

Attach a custom error code.

Examples

use eventide_domain::error::{DomainError, ErrorKind, ErrorCode};

let err = DomainError::not_found("user 123")
    .with_code("USER_NOT_FOUND");

assert_eq!(err.code(), "USER_NOT_FOUND");

pub fn invalid_value(msg: impl Into<Box<str>>) -> Self

Create an ErrorKind::InvalidValue error.

Examples

use eventide_domain::error::{DomainError, ErrorKind, ErrorCode};

let err = DomainError::invalid_value("amount must be positive");
assert_eq!(err.kind(), ErrorKind::InvalidValue);
assert_eq!(err.http_status(), 400);

pub fn invalid_state(msg: impl Into<Box<str>>) -> Self

Create an ErrorKind::InvalidState error.

Examples

use eventide_domain::error::{DomainError, ErrorKind, ErrorCode};

let err = DomainError::invalid_state("order is closed");
assert_eq!(err.kind(), ErrorKind::InvalidState);
assert_eq!(err.http_status(), 422);

pub fn invalid_command(msg: impl Into<Box<str>>) -> Self

Create an ErrorKind::InvalidCommand error.

Examples

use eventide_domain::error::{DomainError, ErrorKind, ErrorCode};

let err = DomainError::invalid_command("insufficient stock");
assert_eq!(err.kind(), ErrorKind::InvalidCommand);
assert_eq!(err.http_status(), 400);

pub fn not_found(msg: impl Into<Box<str>>) -> Self

Create an ErrorKind::NotFound error.

Examples

use eventide_domain::error::{DomainError, ErrorKind, ErrorCode};

let err = DomainError::not_found("user 123");
assert_eq!(err.kind(), ErrorKind::NotFound);
assert_eq!(err.http_status(), 404);

pub fn conflict(expected: impl Display, actual: impl Display) -> Self

Create an ErrorKind::Conflict error.

Examples

use eventide_domain::error::DomainError;

// Accepts any `Display` types.
let err = DomainError::conflict(1_u64, 2_u64);
let err = DomainError::conflict(1_usize, 2_usize);
let err = DomainError::conflict("v1", "v2");

pub fn internal(msg: impl Into<Box<str>>) -> Self

Create an ErrorKind::Internal error.

Examples

use eventide_domain::error::{DomainError, ErrorKind, ErrorCode};

let err = DomainError::internal("database connection failed");
assert_eq!(err.kind(), ErrorKind::Internal);
assert_eq!(err.http_status(), 500);

pub fn upcast_failed( event_type: impl Into<Box<str>>, from_version: usize, stage: Option<&'static str>, reason: impl Into<Box<str>>, ) -> Self

Create an “event upcast failed” error.

pub fn type_mismatch( expected: impl Into<Box<str>>, found: impl Into<Box<str>>, ) -> Self

Create a “type mismatch” error.

pub fn event_bus(reason: impl Into<Box<str>>) -> Self

Create an “event bus” error.

pub fn kind(&self) -> ErrorKind

Return the error category.

pub fn downcast_ref<E: StdError + 'static>(&self) -> Option<&E>

Try to downcast this error into a concrete type.

Only succeeds when the error was constructed via DomainError::custom.

pub fn get_ref(&self) -> Option<&(dyn StdError + Send + Sync + 'static)>

Return a reference to the wrapped inner error, if any.

pub fn static_code(&self) -> &'static str

Return the error code as a &'static str.

Unlike ErrorCode::code this method returns &'static str, which is convenient when the code needs to be stored elsewhere without lifetime gymnastics.

pub fn matches(&self, kind: ErrorKind, code: &str) -> bool

Check whether this error matches the given category and code.

Useful in tests and conditional logic.

Examples

use eventide_domain::error::{DomainError, ErrorKind};

let err = DomainError::not_found("user").with_code("USER_NOT_FOUND");

assert!(err.matches(ErrorKind::NotFound, "USER_NOT_FOUND"));
assert!(!err.matches(ErrorKind::NotFound, "NOT_FOUND"));
assert!(!err.matches(ErrorKind::Internal, "USER_NOT_FOUND"));

Trait Implementations

impl Debug for DomainError

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

Formats the value using the given formatter.

impl Display for DomainError

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

Formats the value using the given formatter.

impl Error for DomainError

fn source(&self) -> Option<&(dyn StdError + '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 ErrorCode for DomainError

fn kind(&self) -> ErrorKind

Return the error’s category.

fn code(&self) -> &str

Return the error code (defaults to ErrorKind::default_code).

fn http_status(&self) -> u16

Return the HTTP status code (defaults to ErrorKind::http_status).

fn is_retryable(&self) -> bool

Whether the error is retryable (defaults to ErrorKind::is_retryable).

impl From<Error> for DomainError

fn from(err: Error) -> Self

Converts to this type from the input type.

impl From<Error> for DomainError

fn from(err: Error) -> Self

Converts to this type from the input type.

impl From<Error> for DomainError

fn from(err: Error) -> Self

Converts to this type from the input type.

impl From<Error> for DomainError

Available on crate feature infra-sqlx only.

fn from(err: Error) -> Self

Converts to this type from the input type.

impl From<ErrorKind> for DomainError

fn from(kind: ErrorKind) -> Self

Converts to this type from the input type.

impl From<ParseBoolError> for DomainError

fn from(err: ParseBoolError) -> Self

Converts to this type from the input type.

impl From<ParseError> for DomainError

fn from(err: ParseError) -> Self

Converts to this type from the input type.

impl From<ParseFloatError> for DomainError

fn from(err: ParseFloatError) -> Self

Converts to this type from the input type.

impl From<ParseIntError> for DomainError

fn from(err: ParseIntError) -> Self

Converts to this type from the input type.