Enum Error 

#[non_exhaustive]
pub enum Error {
    Http(String),
    Database(String),
    Serialization(String),
    Validation(String),
    Authentication(String),
    Authorization(String),
    NotFound(String),
    TemplateNotFound(String),
    MethodNotAllowed(String),
    Conflict(String),
    Internal(String),
    ImproperlyConfigured(String),
    BodyAlreadyConsumed,
    ParseError(String),
    MissingContentType,
    InvalidPage(String),
    InvalidCursor(String),
    InvalidLimit(String),
    MissingParameter(String),
    ParamValidation(Box<ParamErrorContext>),
    Other(Error),
}

Available on crate feature core and non-WebAssembly only.

The main error type for the Reinhardt framework.

This enum represents all possible errors that can occur within the Reinhardt ecosystem. Each variant corresponds to a specific error category with an associated HTTP status code.

Examples

use reinhardt_core::exception::Error;

// Create an HTTP error
let http_err = Error::Http("Invalid request format".to_string());
assert_eq!(http_err.to_string(), "HTTP error: Invalid request format");
assert_eq!(http_err.status_code(), 400);

// Create a database error
let db_err = Error::Database("Connection timeout".to_string());
assert_eq!(db_err.status_code(), 500);

// Create an authentication error
let auth_err = Error::Authentication("Invalid token".to_string());
assert_eq!(auth_err.status_code(), 401);

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.

Http(String)

HTTP-related errors (status code: 400)

Examples

use reinhardt_core::exception::Error;

let error = Error::Http("Malformed request body".to_string());
assert_eq!(error.status_code(), 400);
assert!(error.to_string().contains("HTTP error"));

Database(String)

Database-related errors (status code: 500)

Examples

use reinhardt_core::exception::Error;

let error = Error::Database("Query execution failed".to_string());
assert_eq!(error.status_code(), 500);
assert!(error.to_string().contains("Database error"));

Serialization(String)

Serialization/deserialization errors (status code: 400)

Examples

use reinhardt_core::exception::Error;

let error = Error::Serialization("Invalid JSON format".to_string());
assert_eq!(error.status_code(), 400);
assert!(error.to_string().contains("Serialization error"));

Validation(String)

Validation errors (status code: 400)

Examples

use reinhardt_core::exception::Error;

let error = Error::Validation("Email format is invalid".to_string());
assert_eq!(error.status_code(), 400);
assert!(error.to_string().contains("Validation error"));

Authentication(String)

Authentication errors (status code: 401)

Examples

use reinhardt_core::exception::Error;

let error = Error::Authentication("Invalid credentials".to_string());
assert_eq!(error.status_code(), 401);
assert!(error.to_string().contains("Authentication error"));

Authorization(String)

Authorization errors (status code: 403)

Examples

use reinhardt_core::exception::Error;

let error = Error::Authorization("Insufficient permissions".to_string());
assert_eq!(error.status_code(), 403);
assert!(error.to_string().contains("Authorization error"));

NotFound(String)

Resource not found errors (status code: 404)

Examples

use reinhardt_core::exception::Error;

let error = Error::NotFound("User with ID 123 not found".to_string());
assert_eq!(error.status_code(), 404);
assert!(error.to_string().contains("Not found"));

TemplateNotFound(String)

Template not found errors (status code: 404)

MethodNotAllowed(String)

Method not allowed errors (status code: 405)

This error occurs when the HTTP method used is not supported for the requested resource, even though the resource exists.

Examples

use reinhardt_core::exception::Error;

let error = Error::MethodNotAllowed("Method PATCH not allowed for /api/articles/1".to_string());
assert_eq!(error.status_code(), 405);
assert!(error.to_string().contains("Method not allowed"));

Conflict(String)

Conflict errors (status code: 409)

This error occurs when the request could not be completed due to a conflict with the current state of the resource. Commonly used for duplicate resources or conflicting operations.

Examples

use reinhardt_core::exception::Error;

let error = Error::Conflict("User with this email already exists".to_string());
assert_eq!(error.status_code(), 409);
assert!(error.to_string().contains("Conflict"));

Internal(String)

Internal server errors (status code: 500)

Examples

use reinhardt_core::exception::Error;

let error = Error::Internal("Unexpected server error".to_string());
assert_eq!(error.status_code(), 500);
assert!(error.to_string().contains("Internal server error"));

ImproperlyConfigured(String)

Configuration errors (status code: 500)

Examples

use reinhardt_core::exception::Error;

let error = Error::ImproperlyConfigured("Missing DATABASE_URL".to_string());
assert_eq!(error.status_code(), 500);
assert!(error.to_string().contains("Improperly configured"));

BodyAlreadyConsumed

Body already consumed error (status code: 400)

This error occurs when attempting to read a request body that has already been consumed.

Examples

use reinhardt_core::exception::Error;

let error = Error::BodyAlreadyConsumed;
assert_eq!(error.status_code(), 400);
assert_eq!(error.to_string(), "Body already consumed");

ParseError(String)

Parse errors (status code: 400)

Examples

use reinhardt_core::exception::Error;

let error = Error::ParseError("Invalid integer value".to_string());
assert_eq!(error.status_code(), 400);
assert!(error.to_string().contains("Parse error"));

MissingContentType

Missing Content-Type header

InvalidPage(String)

Invalid page error for pagination (status code: 400)

InvalidCursor(String)

Invalid cursor error for pagination (status code: 400)

InvalidLimit(String)

Invalid limit error for pagination (status code: 400)

MissingParameter(String)

Missing parameter error for URL reverse (status code: 400)

ParamValidation(Box<ParamErrorContext>)

Parameter validation errors with detailed context (status code: 400)

This variant provides structured error information for HTTP parameter extraction failures, including field names, expected types, and raw values.

Examples

use reinhardt_core::exception::{Error, ParamErrorContext, ParamType};

let ctx = ParamErrorContext::new(ParamType::Json, "missing field 'email'")
    .with_field("email")
    .with_expected_type::<String>();
let error = Error::ParamValidation(Box::new(ctx));
assert_eq!(error.status_code(), 400);

Other(Error)

Wraps any other error type using anyhow::Error (status code: 500)

Examples

use reinhardt_core::exception::Error;
use anyhow::anyhow;

let other_error = anyhow!("Something went wrong");
let error: Error = other_error.into();
assert_eq!(error.status_code(), 500);

Implementations

impl Error

pub fn status_code(&self) -> u16

Returns the HTTP status code associated with this error.

Each error variant maps to an appropriate HTTP status code that can be used when converting errors to HTTP responses.

Status Code Mapping

• Http, Serialization, Validation, BodyAlreadyConsumed, ParseError: 400 (Bad Request)
• Authentication: 401 (Unauthorized)
• Authorization: 403 (Forbidden)
• NotFound, TemplateNotFound: 404 (Not Found)
• MethodNotAllowed: 405 (Method Not Allowed)
• Conflict: 409 (Conflict)
• Database, Internal, ImproperlyConfigured, Other: 500 (Internal Server Error)

Examples

use reinhardt_core::exception::Error;

// Client errors (4xx)
assert_eq!(Error::Http("Bad request".to_string()).status_code(), 400);
assert_eq!(Error::Validation("Invalid input".to_string()).status_code(), 400);
assert_eq!(Error::Authentication("No token".to_string()).status_code(), 401);
assert_eq!(Error::Authorization("No access".to_string()).status_code(), 403);
assert_eq!(Error::NotFound("Resource missing".to_string()).status_code(), 404);

// Server errors (5xx)
assert_eq!(Error::Database("Connection failed".to_string()).status_code(), 500);
assert_eq!(Error::Internal("Crash".to_string()).status_code(), 500);
assert_eq!(Error::ImproperlyConfigured("Bad config".to_string()).status_code(), 500);

// Edge cases
assert_eq!(Error::BodyAlreadyConsumed.status_code(), 400);
assert_eq!(Error::ParseError("Invalid data".to_string()).status_code(), 400);

Using with anyhow errors

use reinhardt_core::exception::Error;
use anyhow::anyhow;

let anyhow_error = anyhow!("Unexpected error");
let error: Error = anyhow_error.into();
assert_eq!(error.status_code(), 500);

pub fn kind(&self) -> ErrorKind

Returns the categorical ErrorKind for this error.

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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<&str> for Error

fn from(msg: &str) -> Error

Converts to this type from the input type.

impl From<AdminError> for Error

Convert AdminError to reinhardt_core::exception::Error for seamless error handling

fn from(err: AdminError) -> Error

Converts to this type from the input type.

impl From<AdminError> for Error

fn from(err: AdminError) -> Error

Converts to this type from the input type.

impl From<DatabaseValidatorError> for Error

fn from(err: DatabaseValidatorError) -> Error

Converts to this type from the input type.

impl From<DiError> for Error

fn from(err: DiError) -> Error

Converts to this type from the input type.

impl From<Error> for Error

fn from(source: Error) -> Error

Converts to this type from the input type.

impl From<Error> for Error

fn from(err: Error) -> Error

Converts to this type from the input type.

impl From<Error> for Error

fn from(err: Error) -> Error

Converts to this type from the input type.

impl From<Error> for Error

fn from(err: Error) -> Error

Converts to this type from the input type.

impl From<Error> for Response

fn from(error: Error) -> Response

Converts to this type from the input type.

impl From<ParamError> for Error

fn from(err: ParamError) -> Error

Converts to this type from the input type.

impl From<String> for Error

fn from(msg: String) -> Error

Converts to this type from the input type.

impl From<ValidationErrors> for Error

fn from(err: ValidationErrors) -> Error

Converts to this type from the input type.