fbc_starter/

error.rs

use axum::{
    http::StatusCode,
    response::{IntoResponse, Response},
    Json,
};
use serde_json::json;
use thiserror::Error;

/// 应用错误类型
#[derive(Error, Debug)]
pub enum AppError {
    #[error("内部服务器错误: {0}")]
    Internal(#[from] anyhow::Error),

    #[error("未找到资源")]
    NotFound,

    #[error("未授权访问")]
    Unauthorized,

    #[error("禁止访问")]
    Forbidden,

    #[error("请求参数错误: {0}")]
    BadRequest(String),

    #[error("配置错误: {0}")]
    Config(#[from] config::ConfigError),

    /// 数据库错误（需要启用 mysql/postgres/sqlite 任一特性）
    #[cfg(any(feature = "mysql", feature = "postgres", feature = "sqlite"))]
    #[error("数据库错误: {0}")]
    Database(#[from] sqlx::Error),

    /// 数据库连接池未初始化错误
    #[cfg(any(feature = "mysql", feature = "postgres", feature = "sqlite"))]
    #[error("数据库连接池未初始化")]
    DatabaseNotInitialized,

    /// Redis 错误（需要启用 redis 特性）
    #[cfg(feature = "redis")]
    #[error("Redis 错误: {0}")]
    Redis(#[from] redis::RedisError),

    /// Redis 客户端未初始化错误
    #[cfg(feature = "redis")]
    #[error("Redis 客户端未初始化")]
    RedisNotInitialized,

    /// 业务错误
    ///
    /// # 参数
    /// - `status`: HTTP 状态码
    /// - `message`: 错误消息
    #[error("业务错误: {1}")]
    BizError(i32, String),

    /// 通用错误
    ///
    /// # 参数
    /// - `status`: HTTP 状态码
    /// - `message`: 错误消息
    #[error("通用错误: {1}")]
    CommonError(i32, String),

    /// 自定义错误
    ///
    /// # 参数
    /// - `status`: HTTP 状态码
    /// - `message`: 错误消息
    #[error("自定义错误: {1}")]
    CustomerError(i32, String),

    /// IO 错误
    #[error("IO 错误: {0}")]
    Io(#[from] std::io::Error),

    /// 地址解析错误
    #[error("地址解析错误: {0}")]
    Addr(#[from] std::net::AddrParseError),

    /// Redis 连接池错误
    #[cfg(feature = "redis")]
    #[error("Redis 连接池错误: {0}")]
    RedisPool(#[from] deadpool_redis::PoolError),

    /// Kafka 错误
    #[cfg(feature = "kafka")]
    #[error("Kafka 错误: {0}")]
    Kafka(#[from] rdkafka::error::KafkaError),
}

/// 应用结果类型
pub type AppResult<T> = Result<T, AppError>;

impl AppError {
    /// 创建业务错误
    ///
    /// # 参数
    /// - `status`: HTTP 状态码
    /// - `message`: 错误消息
    ///
    /// # 示例
    /// ```rust,no_run
    /// use fbc_starter::error::{AppError, AppResult};
    /// use axum::http::StatusCode;
    ///
    /// fn example() -> AppResult<()> {
    ///     Err(AppError::biz_error(StatusCode::BAD_REQUEST, "业务逻辑错误".to_string()))
    /// }
    /// ```
    pub fn biz_error(status: i32, message: String) -> Self {
        Self::BizError(status, message)
    }

    /// 创建通用错误
    ///
    /// # 参数
    /// - `status`: HTTP 状态码
    /// - `message`: 错误消息
    ///
    /// # 示例
    /// ```rust,no_run
    /// use fbc_starter::error::{AppError, AppResult};
    /// use axum::http::StatusCode;
    ///
    /// fn example() -> AppResult<()> {
    ///     Err(AppError::common_error(StatusCode::INTERNAL_SERVER_ERROR, "通用错误".to_string()))
    /// }
    /// ```
    pub fn common_error(status: i32, message: String) -> Self {
        Self::CommonError(status, message)
    }

    /// 创建自定义错误
    ///
    /// # 参数
    /// - `status`: HTTP 状态码
    /// - `message`: 错误消息
    ///
    /// # 示例
    /// ```rust,no_run
    /// use fbc_starter::error::{AppError, AppResult};
    /// use axum::http::StatusCode;
    ///
    /// fn example() -> AppResult<()> {
    ///     Err(AppError::customer_error(StatusCode::FORBIDDEN, "自定义错误".to_string()))
    /// }
    /// ```
    pub fn customer_error(status: i32, message: String) -> Self {
        Self::CustomerError(status, message)
    }
}

impl IntoResponse for AppError {
    fn into_response(self) -> Response {
        let (status, error_message) = match self {
            AppError::NotFound => (StatusCode::NOT_FOUND, self.to_string()),
            AppError::Unauthorized => (StatusCode::UNAUTHORIZED, self.to_string()),
            AppError::Forbidden => (StatusCode::FORBIDDEN, self.to_string()),
            AppError::BadRequest(msg) => (StatusCode::BAD_REQUEST, msg),
            AppError::Config(e) => (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()),
            #[cfg(any(feature = "mysql", feature = "postgres", feature = "sqlite"))]
            AppError::Database(e) => {
                tracing::error!("数据库错误: {:?}", e);
                (
                    StatusCode::INTERNAL_SERVER_ERROR,
                    format!("数据库错误: {}", e),
                )
            }
            #[cfg(any(feature = "mysql", feature = "postgres", feature = "sqlite"))]
            AppError::DatabaseNotInitialized => {
                tracing::error!("数据库连接池未初始化");
                (
                    StatusCode::INTERNAL_SERVER_ERROR,
                    "数据库连接池未初始化".to_string(),
                )
            }
            #[cfg(feature = "redis")]
            AppError::Redis(e) => {
                tracing::error!("Redis 错误: {:?}", e);
                (
                    StatusCode::INTERNAL_SERVER_ERROR,
                    format!("Redis 错误: {}", e),
                )
            }
            #[cfg(feature = "redis")]
            AppError::RedisNotInitialized => {
                tracing::error!("Redis 客户端未初始化");
                (
                    StatusCode::INTERNAL_SERVER_ERROR,
                    "Redis 客户端未初始化".to_string(),
                )
            }
            AppError::Internal(e) => {
                tracing::error!("内部错误: {:?}", e);
                (
                    StatusCode::INTERNAL_SERVER_ERROR,
                    "内部服务器错误".to_string(),
                )
            }
            AppError::BizError(status, msg) => {
                let msg = format!("业务错误: [{}] {}", status, msg);
                tracing::warn!(msg);
                (StatusCode::OK, msg)
            }
            AppError::CommonError(status, msg) => {
                let msg = format!("通用错误: [{}] {}", status, msg);
                tracing::warn!(msg);
                (StatusCode::OK, msg)
            }
            AppError::CustomerError(status, msg) => {
                let msg = format!("自定义错误: [{}] {}", status, msg);
                tracing::warn!(msg);
                (StatusCode::OK, msg)
            }
            AppError::Io(e) => {
                tracing::error!("IO 错误: {:?}", e);
                (StatusCode::INTERNAL_SERVER_ERROR, format!("IO 错误: {}", e))
            }
            AppError::Addr(e) => {
                tracing::error!("地址解析错误: {:?}", e);
                (StatusCode::BAD_REQUEST, format!("地址解析错误: {}", e))
            }
            #[cfg(feature = "redis")]
            AppError::RedisPool(e) => {
                tracing::error!("Redis 连接池错误: {:?}", e);
                (
                    StatusCode::INTERNAL_SERVER_ERROR,
                    format!("Redis 连接池错误: {}", e),
                )
            }
            #[cfg(feature = "kafka")]
            AppError::Kafka(e) => {
                tracing::error!("Kafka 错误: {:?}", e);
                (
                    StatusCode::INTERNAL_SERVER_ERROR,
                    format!("Kafka 错误: {}", e),
                )
            }
        };

        let body = Json(json!({
            "error": error_message,
            "status": status.as_u16(),
        }));

        (status, body).into_response()
    }
}