Error Handling in Handlers

use axum::{http::StatusCode, response::IntoResponse, Json};
use thiserror::Error;
 
#[derive(Error, Debug)]
enum AppError {
    #[error("not found")] NotFound,
    #[error("{0}")] BadRequest(String),
}
 
impl IntoResponse for AppError {
    fn into_response(self) -> axum::response::Response {
        let (status, msg) = match self {
            AppError::NotFound => (StatusCode::NOT_FOUND, self.to_string()),
            AppError::BadRequest(m) => (StatusCode::BAD_REQUEST, m),
        };
        (status, Json(serde_json::json!({ "error": msg }))).into_response()
    }
}
 
async fn handler() -> Result<Json<Data>, AppError> { /* ... */ }

use axum::{http::StatusCode, response::IntoResponse, routing::get, Json, Router};
use serde::Serialize;
use thiserror::Error;
 
#[derive(Serialize)]
struct ErrorBody { code: &'static str, message: String }
 
#[derive(Error, Debug)]
enum ApiError {
    #[error("item not found")] NotFound,
    #[error("invalid id: {0}")] InvalidId(String),
    #[error(transparent)] Db(#[from] sqlx::Error),
}
 
impl IntoResponse for ApiError {
    fn into_response(self) -> axum::response::Response {
        let (status, code, message) = match &self {
            ApiError::NotFound => (StatusCode::NOT_FOUND, "not_found", self.to_string()),
            ApiError::InvalidId(_) => (StatusCode::BAD_REQUEST, "invalid_id", self.to_string()),
            ApiError::Db(_) => (StatusCode::INTERNAL_SERVER_ERROR, "db_error", "internal error".into()),
        };
        (status, Json(ErrorBody { code, message })).into_response()
    }
}
 
async fn get_item(axum::extract::Path(id): axum::extract::Path<String>) -> Result<Json<serde_json::Value>, ApiError> {
    if id.is_empty() {
        return Err(ApiError::InvalidId(id));
    }
    if id == "missing" {
        return Err(ApiError::NotFound);
    }
    Ok(Json(serde_json::json!({ "id": id })))
}
 
#[tokio::main]
async fn main() {
    let app = Router::new().route("/items/:id", get(get_item));
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

// Axum 0.8: map error types with From
impl From<validator::ValidationErrors> for ApiError {
    fn from(e: validator::ValidationErrors) -> Self {
        ApiError::BadRequest(e.to_string())
    }
}