editoast: forward core error type

editoast/src/core/mod.rs

@@ -9,9 +9,10 @@ pub mod simulation;
 pub mod stdcm;
 pub mod version;
 
-use std::marker::PhantomData;
+use std::{marker::PhantomData, collections::HashMap, fmt::Display};
 
 use crate::error::{InternalError, Result};
+use actix_http::StatusCode;
 use async_trait::async_trait;
 use colored::{ColoredString, Colorize};
 use editoast_derive::EditoastError;
@@ -20,6 +21,7 @@ use log::info;
 use reqwest::Url;
 use serde::{de::DeserializeOwned, Serialize};
 use serde_derive::Deserialize;
+use serde_json::Value;
 use thiserror::Error;
 
 const MAX_RETRIES: u8 = 5;
@@ -108,8 +110,9 @@ impl CoreClient {
 
                 log::error!(target: "editoast::coreclient", "{method_s} {path} {status}", status = status.to_string().bold().red());
 
-                // We try to deserialize the response as an InternalError in order to retain the context of the core error
-                if let Ok(mut internal_error) = <Json<InternalError>>::from_bytes(bytes.as_ref()) {
+                // We try to deserialize the response as an StandardCoreError in order to retain the context of the core error
+                if let Ok(core_error) = <Json<StandardCoreError>>::from_bytes(bytes.as_ref()) {
+                    let mut internal_error: InternalError = core_error.into(); 
                     internal_error.set_status(status);
                     return Err(internal_error);
                 }
@@ -316,6 +319,40 @@ enum CoreError {
     NoResponseContent,
 }
 
+#[derive(Debug, Deserialize)]
+pub struct StandardCoreError {
+    #[serde(skip)]
+    status: StatusCode,
+    #[serde(rename = "type")]
+    error_type: Value,
+    context: HashMap<String, Value>,
+    message: String,
+}
+
+impl crate::error::EditoastError for StandardCoreError {
+    fn get_type(&self) -> &'static str {
+        "forwarded_core_error"
+    }
+
+    fn get_status(&self) -> StatusCode {
+        self.status
+    }
+
+    fn context(&self) -> HashMap<String, Value> {
+        let mut context_with_type = self.context.clone();
+        context_with_type.insert("type".to_owned(), self.error_type.clone());
+        context_with_type
+    }
+}
+
+impl std::error::Error for StandardCoreError {}
+
+impl Display for StandardCoreError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.message)
+    }
+}
+
 impl From<reqwest::Error> for CoreError {
     fn from(value: reqwest::Error) -> Self {
         // Since we should retry the request it's useful to have its own kind of error.