taler-rust

error.rs (7721B)

---

 /*
   This file is part of TALER
   Copyright (C) 2024, 2025, 2026 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.
 
   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
 
   You should have received a copy of the GNU Affero General Public License along with
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use std::fmt::Display;
 
 use axum::{
     Json,
     extract::{path::ErrorKind, rejection::PathRejection},
     http::{HeaderMap, HeaderValue, StatusCode, header::IntoHeaderName},
     response::{IntoResponse, Response},
 };
 use taler_common::{
     api::{ErrorDetail, params::ParamsErr},
     error_code::ErrorCode,
     types::payto::PaytoErr,
 };
 
 pub type ApiResult<T> = Result<T, ApiError>;
 
 #[derive(Debug, thiserror::Error)]
 pub struct ApiError {
     code: ErrorCode,
     hint: Option<Box<str>>,
     log: Option<Box<str>>,
     status: Option<StatusCode>,
     path: Option<Box<str>>,
     headers: Option<Box<HeaderMap>>,
 }
 
 impl Display for ApiError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(h) = &self.hint {
             f.write_str(h)
         } else {
             f.write_str(self.code.description())
         }
     }
 }
 
 impl ApiError {
     pub fn new(code: ErrorCode) -> Self {
         Self {
             code,
             hint: None,
             log: None,
             status: None,
             path: None,
             headers: None,
         }
     }
 
     pub fn with_hint(self, hint: impl Display) -> Self {
         Self {
             hint: Some(hint.to_string().into_boxed_str()),
             ..self
         }
     }
 
     pub fn with_log(self, log: impl Into<Box<str>>) -> Self {
         Self {
             log: Some(log.into()),
             ..self
         }
     }
 
     pub fn with_status(self, code: StatusCode) -> Self {
         Self {
             status: Some(code),
             ..self
         }
     }
 
     pub fn with_path(self, path: impl Display) -> Self {
         Self {
             path: Some(path.to_string().into_boxed_str()),
             ..self
         }
     }
 
     pub fn with_header(mut self, key: impl IntoHeaderName, value: HeaderValue) -> Self {
         let headers = self.headers.get_or_insert_default();
         headers.append(key, value);
         self
     }
 }
 
 impl From<sqlx::Error> for ApiError {
     fn from(value: sqlx::Error) -> Self {
         let (code, status) = match value {
             sqlx::Error::Configuration(_) => {
                 (ErrorCode::GENERIC_DB_SETUP_FAILED, StatusCode::BAD_GATEWAY)
             }
             sqlx::Error::Database(_)
             | sqlx::Error::Io(_)
             | sqlx::Error::Tls(_)
             | sqlx::Error::PoolTimedOut => {
                 (ErrorCode::GENERIC_DB_FETCH_FAILED, StatusCode::BAD_GATEWAY)
             }
             _ => (ErrorCode::GENERIC_DB_FETCH_FAILED, StatusCode::BAD_GATEWAY),
         };
         Self {
             code,
             hint: None,
             status: Some(status),
             log: Some(format!("{value}").into_boxed_str()),
             path: None,
             headers: None,
         }
     }
 }
 
 impl From<PaytoErr> for ApiError {
     fn from(value: PaytoErr) -> Self {
         failure(ErrorCode::GENERIC_PAYTO_URI_MALFORMED, value)
     }
 }
 
 impl From<ParamsErr> for ApiError {
     fn from(value: ParamsErr) -> Self {
         failure(ErrorCode::GENERIC_PARAMETER_MALFORMED, &value).with_path(value.param)
     }
 }
 
 impl From<serde_path_to_error::Error<serde_urlencoded::de::Error>> for ApiError {
     fn from(value: serde_path_to_error::Error<serde_urlencoded::de::Error>) -> Self {
         let fmt = value.to_string();
         if fmt.contains("missing") {
             failure(ErrorCode::GENERIC_PARAMETER_MISSING, value.inner())
                 .with_path(value.path().to_string())
                 .with_log(fmt)
         } else {
             failure(ErrorCode::GENERIC_PARAMETER_MALFORMED, value.inner())
                 .with_path(value.path().to_string())
                 .with_log(fmt)
         }
     }
 }
 
 impl From<serde_path_to_error::Error<serde_json::Error>> for ApiError {
     fn from(value: serde_path_to_error::Error<serde_json::Error>) -> Self {
         failure(ErrorCode::GENERIC_JSON_INVALID, value.inner())
             .with_path(value.path().to_string())
             .with_log(value.to_string())
     }
 }
 
 impl From<PathRejection> for ApiError {
     fn from(value: PathRejection) -> Self {
         match value {
             PathRejection::FailedToDeserializePathParams(err) => {
                 let kind = err.into_kind();
                 let err = failure(ErrorCode::GENERIC_PATH_SEGMENT_MALFORMED, &kind);
                 match kind {
                     ErrorKind::ParseErrorAtKey { key, .. }
                     | ErrorKind::InvalidUtf8InPathParam { key }
                     | ErrorKind::DeserializeError { key, .. } => err.with_path(key),
                     ErrorKind::ParseErrorAtIndex { index, .. } => err.with_path(index),
                     _ => err,
                 }
             }
             PathRejection::MissingPathParams(err) => {
                 failure(ErrorCode::BANK_UNMANAGED_EXCEPTION, err)
             }
             _ => failure(ErrorCode::BANK_UNMANAGED_EXCEPTION, value),
         }
     }
 }
 
 impl IntoResponse for ApiError {
     fn into_response(self) -> Response {
         let ApiError {
             code,
             hint,
             log,
             status,
             path,
             headers,
         } = self;
         let status_code = status.unwrap_or_else(|| {
             StatusCode::from_u16(code.status_code()).expect("Invalid status code")
         });
         let log = log.or(hint.clone());
 
         let mut resp = (
             status_code,
             Json(ErrorDetail {
                 code: code as u16,
                 hint,
                 detail: None,
                 parameter: None,
                 path,
                 offset: None,
                 index: None,
                 object: None,
                 currency: None,
                 type_expected: None,
                 type_actual: None,
                 extra: None,
             }),
         )
             .into_response();
         if let Some(headers) = headers {
             for (k, v) in *headers {
                 resp.headers_mut().append(k.unwrap(), v);
             }
         }
         resp.extensions_mut()
             .insert(LoggedError { code, info: log });
 
         resp
     }
 }
 
 #[derive(Debug, Clone)]
 pub struct LoggedError {
     pub code: ErrorCode,
     pub info: Option<Box<str>>,
 }
 
 pub fn failure_code(code: ErrorCode) -> ApiError {
     ApiError::new(code)
 }
 
 pub fn failure(code: ErrorCode, hint: impl Display) -> ApiError {
     ApiError::new(code).with_hint(hint)
 }
 
 pub fn failure_status(code: ErrorCode, hint: impl Display, status: StatusCode) -> ApiError {
     ApiError::new(code).with_hint(hint).with_status(status)
 }
 
 pub fn not_implemented() -> ApiError {
     ApiError::new(ErrorCode::END).with_status(StatusCode::NOT_IMPLEMENTED)
 }
 
 pub fn unauthorized(hint: impl Display) -> ApiError {
     ApiError::new(ErrorCode::GENERIC_UNAUTHORIZED).with_hint(hint)
 }
 
 pub fn forbidden(hint: impl Display) -> ApiError {
     ApiError::new(ErrorCode::GENERIC_FORBIDDEN).with_hint(hint)
 }
 
 pub fn bad_request(hint: impl Display) -> ApiError {
     ApiError::new(ErrorCode::GENERIC_JSON_INVALID).with_hint(hint)
 }