Struct AutumnError 

pub struct AutumnError { /* private fields */ }

Framework error type wrapping any error with an HTTP status code.

Usage

The ? operator converts any std::error::Error into an AutumnError with status 500 Internal Server Error:

use autumn_web::prelude::*;

#[get("/")]
async fn handler() -> AutumnResult<&'static str> {
    autumn_web::reexports::tokio::fs::read_to_string("missing.txt").await?; // becomes 500 on error
    Ok("ok")
}

For expected errors, use a status refinement constructor:

use autumn_web::prelude::*;

#[get("/users/{id}")]
async fn get_user(axum::extract::Path(id): axum::extract::Path<i32>) -> AutumnResult<String> {
    if id < 0 {
        return Err(AutumnError::bad_request(
            std::io::Error::other("id must be positive"),
        ));
    }
    Ok(format!("user {id}"))
}

Why no Error impl

AutumnError intentionally does not implement std::error::Error. Doing so would conflict with the blanket From<E: Error> impl (the reflexive From<T> for T would overlap). This type is a response wrapper, not a propagatable error.

Implementations

impl AutumnError

pub const fn with_status(self, status: StatusCode) -> Self

Override the HTTP status code.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err: AutumnError = std::io::Error::other("forbidden").into();
let err = err.with_status(StatusCode::FORBIDDEN);
assert_eq!(err.status(), StatusCode::FORBIDDEN);

pub fn internal_server_error(err: impl Error + Send + Sync + 'static) -> Self

Create a 500 Internal Server Error.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::internal_server_error(std::io::Error::other("boom"));
assert_eq!(err.status(), StatusCode::INTERNAL_SERVER_ERROR);

pub fn not_found(err: impl Error + Send + Sync + 'static) -> Self

Create a 404 Not Found error.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::not_found(std::io::Error::other("no such user"));
assert_eq!(err.status(), StatusCode::NOT_FOUND);

pub fn bad_request(err: impl Error + Send + Sync + 'static) -> Self

Create a 400 Bad Request error.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::bad_request(std::io::Error::other("invalid input"));
assert_eq!(err.status(), StatusCode::BAD_REQUEST);

pub fn unprocessable(err: impl Error + Send + Sync + 'static) -> Self

Create a 422 Unprocessable Entity error.

Use this for validation failures where the request is syntactically valid but semantically incorrect.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::unprocessable(std::io::Error::other("age must be positive"));
assert_eq!(err.status(), StatusCode::UNPROCESSABLE_ENTITY);

pub fn service_unavailable(err: impl Error + Send + Sync + 'static) -> Self

Create a 503 Service Unavailable error.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::service_unavailable(std::io::Error::other("pool exhausted"));
assert_eq!(err.status(), StatusCode::SERVICE_UNAVAILABLE);

pub fn unauthorized(err: impl Error + Send + Sync + 'static) -> Self

Create a 401 Unauthorized error.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::unauthorized(std::io::Error::other("not logged in"));
assert_eq!(err.status(), StatusCode::UNAUTHORIZED);

pub fn forbidden(err: impl Error + Send + Sync + 'static) -> Self

Create a 403 Forbidden error.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::forbidden(std::io::Error::other("not allowed"));
assert_eq!(err.status(), StatusCode::FORBIDDEN);

pub fn validation(details: HashMap<String, Vec<String>>) -> Self

Create a 422 Unprocessable Entity error with field-level validation details.

Use this when a request fails multiple field-specific validation rules (e.g., in a form submission). It attaches the details parameter, a mapping of field names to their respective error messages, so the client can display errors next to the relevant inputs.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;
use std::collections::HashMap;

let mut errors = HashMap::new();
errors.insert("username".to_string(), vec!["Username is taken".to_string()]);

let err = AutumnError::validation(errors);
assert_eq!(err.status(), StatusCode::UNPROCESSABLE_ENTITY);

pub fn internal_server_error_msg(msg: impl Into<String>) -> Self

Create a 500 Internal Server Error from a plain string message.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::internal_server_error_msg("Database explosion");
assert_eq!(err.status(), StatusCode::INTERNAL_SERVER_ERROR);

pub fn not_found_msg(msg: impl Into<String>) -> Self

Create a 404 Not Found error from a plain string message.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::not_found_msg("No such user");
assert_eq!(err.status(), StatusCode::NOT_FOUND);
assert_eq!(err.to_string(), "No such user");

pub fn bad_request_msg(msg: impl Into<String>) -> Self

Create a 400 Bad Request error from a plain string message.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::bad_request_msg("Invalid input parameter");
assert_eq!(err.status(), StatusCode::BAD_REQUEST);

pub fn unprocessable_msg(msg: impl Into<String>) -> Self

Create a 422 Unprocessable Entity error from a plain string message.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::unprocessable_msg("Title is required");
assert_eq!(err.status(), StatusCode::UNPROCESSABLE_ENTITY);

pub fn unauthorized_msg(msg: impl Into<String>) -> Self

Create a 401 Unauthorized error from a plain string message.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::unauthorized_msg("Please log in to continue");
assert_eq!(err.status(), StatusCode::UNAUTHORIZED);

pub fn forbidden_msg(msg: impl Into<String>) -> Self

Create a 403 Forbidden error from a plain string message.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::forbidden_msg("You lack admin privileges");
assert_eq!(err.status(), StatusCode::FORBIDDEN);

pub fn service_unavailable_msg(msg: impl Into<String>) -> Self

Create a 503 Service Unavailable error from a plain string message.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::service_unavailable_msg("Database connection pool exhausted");
assert_eq!(err.status(), StatusCode::SERVICE_UNAVAILABLE);

pub fn conflict(err: impl Error + Send + Sync + 'static) -> Self

Create a 409 Conflict error.

Use this for optimistic-lock conflicts surfaced by repository update calls when the client’s expected version is stale.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::conflict(std::io::Error::other("stale version"));
assert_eq!(err.status(), StatusCode::CONFLICT);

pub fn conflict_msg(msg: impl Into<String>) -> Self

Create a 409 Conflict error from a plain string message.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err = AutumnError::conflict_msg("Concurrent edit: please reload and retry");
assert_eq!(err.status(), StatusCode::CONFLICT);

pub const fn status(&self) -> StatusCode

Returns the HTTP status code associated with this error.

Examples

use autumn_web::error::AutumnError;
use http::StatusCode;

let err: AutumnError = std::io::Error::other("boom").into();
assert_eq!(err.status(), StatusCode::INTERNAL_SERVER_ERROR);

pub fn source_chain(&self) -> Vec<String>

Return the wrapped error’s source chain as displayable messages.

The top-level AutumnError display already prints the wrapped error message, so this list starts at that wrapped error’s first source.

Trait Implementations

impl Debug for AutumnError

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

Formats the value using the given formatter.

impl Display for AutumnError

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

Formats the value using the given formatter.

impl<E> From<E> for AutumnError

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

fn from(err: E) -> Self

Converts to this type from the input type.

impl IntoResponse for AutumnError

fn into_response(self) -> Response

Create a response.