Struct DomainError

pub struct DomainError {
    pub output: HttpError,
    pub source: Option<Box<dyn StdError + Send + Sync>>,
}

Wrapper for errors that are not a Fault. It is used as the explicit_error::Error::Domain variant generic type.

It is highly recommended to implement the derive HttpError which generates the boilerplate for your domain errors. Otherwise you can implement the ToDomainError trait.

Error implements From<DomainError>, use ? and .into() in functions and closures to convert to the Error::Domain variant.

Examples

DomainError can be generated because of a predicate

use explicit_error_http::{HttpError, Result, derive::HttpError};

#[derive(Debug, HttpError)]
enum MyError {
    Domain,
}

impl From<&MyError> for HttpError {
    fn from(value: &MyError) -> Self {
        HttpError::new(
            StatusCode::BAD_REQUEST,
            "My domain error"
        )
    }
}

fn business_logic() -> Result<()> {
    if 1 < 2 {
        Err(MyError::Domain)?;
    }
     
    if true {
        Err(HttpError::new(StatusCode::FORBIDDEN, "")
            .with_context("Usefull context to debug or monitor"))?;
    }
}

Or from a Result

use explicit_error_http::{Error, prelude::*, derive::HttpError, HttpError};

#[derive(HttpError, Debug)]
 enum NotFoundError {
    Bar(String)
 }

 impl From<&NotFoundError> for HttpError {
    fn from(value: &NotFoundError) -> Self {
        let (label, id) = match value {
            NotFoundError::Bar(public_identifier) => ("Bar", public_identifier)
        };

        HttpError::new(
            StatusCode::NOT_FOUND,
            ProblemDetails::new()
                .with_type(Uri::from_static("/errors/not-found"))
                .with_title("Not found")
                .with_detail(format!("Unknown {label} with identifier {id}."))
        )
    }
}

fn business_logic(public_identifier: &str) -> Result<(), Error> {     
    let entity = fetch_bar(&public_identifier).map_err_or_fault(|e|
        match e {
            sqlx::Error::RowNotFound => Ok(
                NotFoundError::Bar(public_identifier.to_string())),
            _ => Err(e),
        }
    )?;

    Ok(entity)
}

fn fetch_bar(public_identifier: &str) -> Result<(), sqlx::Error> {
    Err(sqlx::Error::RowNotFound)
}

Or an Option

Some(12).ok_or(HttpError::new(StatusCode::FORBIDDEN, ""))?;

Fields

output: HttpError

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

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<'s>(&'s self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Domain for DomainError

fn into_source(self) -> Option<Box<dyn Error + Send + Sync>>

fn context(&self) -> Option<&str>

fn with_context(self, context: impl Display) -> Self

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 From<DomainError> for Error<DomainError>

fn from(value: DomainError) -> Self

Converts to this type from the input type.

impl Serialize for DomainError

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.