itsi 0.1.13 → 0.1.18

data/crates/itsi_server/src/server/middleware_stack/middlewares/cors.rs

@@ -1,8 +1,9 @@
 use super::{FromValue, MiddlewareLayer};
-use crate::server::{
-    itsi_service::RequestContext,
-    types::{HttpRequest, HttpResponse, RequestExt},
+use crate::{
+    server::http_message_types::{HttpRequest, HttpResponse, RequestExt},
+    services::itsi_http_service::HttpRequestContext,
 };
+
 use async_trait::async_trait;
 use http::{HeaderMap, Method, Response};
 use http_body_util::{combinators::BoxBody, Empty};
@@ -69,14 +70,14 @@ impl Cors {
     fn cors_headers(&self, origin: &str) -> Result<HeaderMap> {
         let mut headers = HeaderMap::new();
 
-        headers.insert("Vary", "Origin".parse().map_err(ItsiError::default)?);
+        headers.insert("Vary", "Origin".parse().map_err(ItsiError::new)?);
 
         if origin.is_empty() {
             // When credentials are allowed, you cannot return "*".
             if !self.allow_credentials {
                 headers.insert(
                     "Access-Control-Allow-Origin",
-                    "*".parse().map_err(ItsiError::default)?,
+                    "*".parse().map_err(ItsiError::new)?,
                 );
             }
             return Ok(headers);
@@ -97,7 +98,7 @@ impl Cors {
             };
             headers.insert(
                 "Access-Control-Allow-Origin",
-                value.parse().map_err(ItsiError::default)?,
+                value.parse().map_err(ItsiError::new)?,
             );
         }
 
@@ -110,7 +111,7 @@ impl Cors {
                     .collect::<Vec<&str>>()
                     .join(", ")
                     .parse()
-                    .map_err(ItsiError::default)?,
+                    .map_err(ItsiError::new)?,
             );
         }
         if !self.allowed_headers.is_empty() {
@@ -119,19 +120,19 @@ impl Cors {
                 self.allowed_headers
                     .join(", ")
                     .parse()
-                    .map_err(ItsiError::default)?,
+                    .map_err(ItsiError::new)?,
             );
         }
         if self.allow_credentials {
             headers.insert(
                 "Access-Control-Allow-Credentials",
-                "true".parse().map_err(ItsiError::default)?,
+                "true".parse().map_err(ItsiError::new)?,
             );
         }
         if let Some(max_age) = self.max_age {
             headers.insert(
                 "Access-Control-Max-Age",
-                max_age.to_string().parse().map_err(ItsiError::default)?,
+                max_age.to_string().parse().map_err(ItsiError::new)?,
             );
         }
         if !self.exposed_headers.is_empty() {
@@ -140,7 +141,7 @@ impl Cors {
                 self.exposed_headers
                     .join(", ")
                     .parse()
-                    .map_err(ItsiError::default)?,
+                    .map_err(ItsiError::new)?,
             );
         }
         Ok(headers)
@@ -154,7 +155,7 @@ impl Cors {
     ) -> Result<HeaderMap> {
         let mut headers = HeaderMap::new();
 
-        headers.insert("Vary", "Origin".parse().map_err(ItsiError::default)?);
+        headers.insert("Vary", "Origin".parse().map_err(ItsiError::new)?);
 
         let origin = match origin {
             Some(o) if !o.is_empty() => o,
@@ -208,25 +209,25 @@ impl Cors {
                 .collect::<Vec<&str>>()
                 .join(", ")
                 .parse()
-                .map_err(ItsiError::default)?,
+                .map_err(ItsiError::new)?,
         );
         headers.insert(
             "Access-Control-Allow-Headers",
             self.allowed_headers
                 .join(", ")
                 .parse()
-                .map_err(ItsiError::default)?,
+                .map_err(ItsiError::new)?,
         );
         if self.allow_credentials {
             headers.insert(
                 "Access-Control-Allow-Credentials",
-                "true".parse().map_err(ItsiError::default)?,
+                "true".parse().map_err(ItsiError::new)?,
             );
         }
         if let Some(max_age) = self.max_age {
             headers.insert(
                 "Access-Control-Max-Age",
-                max_age.to_string().parse().map_err(ItsiError::default)?,
+                max_age.to_string().parse().map_err(ItsiError::new)?,
             );
         }
         if !self.exposed_headers.is_empty() {
@@ -235,7 +236,7 @@ impl Cors {
                 self.exposed_headers
                     .join(", ")
                     .parse()
-                    .map_err(ItsiError::default)?,
+                    .map_err(ItsiError::new)?,
             );
         }
 
@@ -253,7 +254,7 @@ impl MiddlewareLayer for Cors {
     async fn before(
         &self,
         req: HttpRequest,
-        context: &mut RequestContext,
+        context: &mut HttpRequestContext,
     ) -> Result<either::Either<HttpRequest, HttpResponse>> {
         let origin = req.header("Origin");
         if req.method() == Method::OPTIONS {
@@ -265,7 +266,7 @@ impl MiddlewareLayer for Cors {
             *response_builder.headers_mut().unwrap() = headers;
             let response = response_builder
                 .body(BoxBody::new(Empty::new()))
-                .map_err(ItsiError::default)?;
+                .map_err(ItsiError::new)?;
             return Ok(either::Either::Right(response));
         }
         context.set_origin(origin.map(|s| s.to_string()));
@@ -273,7 +274,11 @@ impl MiddlewareLayer for Cors {
     }
 
     // The after hook can be used to inject CORS headers into non-preflight responses.
-    async fn after(&self, mut resp: HttpResponse, context: &mut RequestContext) -> HttpResponse {
+    async fn after(
+        &self,
+        mut resp: HttpResponse,
+        context: &mut HttpRequestContext,
+    ) -> HttpResponse {
         if let Some(Some(origin)) = context.origin.get() {
             if let Ok(cors_headers) = self.cors_headers(origin) {
                 for (key, value) in cors_headers.iter() {

data/crates/itsi_server/src/server/middleware_stack/middlewares/deny_list.rs

@@ -1,6 +1,6 @@
-use crate::server::{
-    itsi_service::RequestContext,
-    types::{HttpRequest, HttpResponse},
+use crate::{
+    server::http_message_types::{HttpRequest, HttpResponse, RequestExt},
+    services::itsi_http_service::HttpRequestContext,
 };
 
 use super::{ErrorResponse, FromValue, MiddlewareLayer};
@@ -17,28 +17,35 @@ pub struct DenyList {
     #[serde(skip_deserializing)]
     pub denied_ips: OnceLock<RegexSet>,
     pub denied_patterns: Vec<String>,
+    #[serde(default = "forbidden_error_response")]
     pub error_response: ErrorResponse,
 }
 
+fn forbidden_error_response() -> ErrorResponse {
+    ErrorResponse::forbidden()
+}
+
 #[async_trait]
 impl MiddlewareLayer for DenyList {
     async fn initialize(&self) -> Result<()> {
-        let denied_ips = RegexSet::new(&self.denied_patterns).map_err(ItsiError::default)?;
+        let denied_ips = RegexSet::new(&self.denied_patterns).map_err(ItsiError::new)?;
         self.denied_ips
             .set(denied_ips)
-            .map_err(|e| ItsiError::default(format!("Failed to set allowed IPs: {:?}", e)))?;
+            .map_err(|e| ItsiError::new(format!("Failed to set allowed IPs: {:?}", e)))?;
         Ok(())
     }
 
     async fn before(
         &self,
         req: HttpRequest,
-        context: &mut RequestContext,
+        context: &mut HttpRequestContext,
     ) -> Result<Either<HttpRequest, HttpResponse>> {
         if let Some(denied_ips) = self.denied_ips.get() {
             if denied_ips.is_match(&context.addr) {
                 return Ok(Either::Right(
-                    self.error_response.to_http_response(&req).await,
+                    self.error_response
+                        .to_http_response(req.accept().into())
+                        .await,
                 ));
             }
         }

data/crates/itsi_server/src/server/middleware_stack/middlewares/error_response/default_responses.rs

@@ -0,0 +1,190 @@
+use std::convert::Infallible;
+
+use bytes::Bytes;
+use http_body_util::{combinators::BoxBody, Full};
+
+use crate::server::http_message_types::ResponseFormat;
+
+use super::{ContentSource, DefaultFormat, ErrorResponse};
+
+impl DefaultFormat {
+    pub fn response_for_code(&self, code: u16) -> ContentSource {
+        match self {
+            DefaultFormat::Plaintext => match code {
+                500 => ContentSource::Inline("500 Internal Error".to_owned()),
+                404 => ContentSource::Inline("404 Not Found".to_owned()),
+                401 => ContentSource::Inline("401 Unauthorized".to_owned()),
+                403 => ContentSource::Inline("403 Forbidden".to_owned()),
+                413 => ContentSource::Inline("413 Payload Too Large".to_owned()),
+                429 => ContentSource::Inline("429 Too Many Requests".to_owned()),
+                502 => ContentSource::Inline("502 Bad Gateway".to_owned()),
+                503 => ContentSource::Inline("503 Service Unavailable".to_owned()),
+                504 => ContentSource::Inline("504 Gateway Timeout".to_owned()),
+                _ => ContentSource::Inline("Unexpected Error".to_owned()),
+            },
+            DefaultFormat::Html => match code {
+                500 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/500.html").to_owned(),
+                ),
+                404 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/404.html").to_owned(),
+                ),
+                401 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/401.html").to_owned(),
+                ),
+                403 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/403.html").to_owned(),
+                ),
+                413 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/413.html").to_owned(),
+                ),
+                429 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/429.html").to_owned(),
+                ),
+                502 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/502.html").to_owned(),
+                ),
+                503 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/503.html").to_owned(),
+                ),
+                504 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/html/504.html").to_owned(),
+                ),
+                _ => ContentSource::Inline("Unexpected Error".to_owned()),
+            },
+            DefaultFormat::Json => match code {
+                500 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/500.json").to_owned(),
+                ),
+                404 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/404.json").to_owned(),
+                ),
+                401 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/401.json").to_owned(),
+                ),
+                403 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/403.json").to_owned(),
+                ),
+                413 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/413.json").to_owned(),
+                ),
+                429 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/429.json").to_owned(),
+                ),
+                502 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/502.json").to_owned(),
+                ),
+                503 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/503.json").to_owned(),
+                ),
+                504 => ContentSource::Inline(
+                    include_str!("../../../../default_responses/json/504.json").to_owned(),
+                ),
+                _ => ContentSource::Inline("Unexpected Error".to_owned()),
+            },
+        }
+    }
+}
+impl ErrorResponse {
+    pub fn fallback_body_for(code: u16, accept: ResponseFormat) -> BoxBody<Bytes, Infallible> {
+        let source = match accept {
+            ResponseFormat::TEXT => DefaultFormat::Plaintext.response_for_code(code),
+            ResponseFormat::HTML => DefaultFormat::Html.response_for_code(code),
+            ResponseFormat::JSON => DefaultFormat::Json.response_for_code(code),
+            ResponseFormat::UNKNOWN => ContentSource::Inline("Unexpected Error".to_owned()),
+        };
+        match source {
+            ContentSource::Inline(bytes) => BoxBody::new(Full::new(Bytes::from(bytes))),
+            ContentSource::File(_) => BoxBody::new(Full::new(Bytes::from("Unexpected error"))),
+        }
+    }
+    pub fn internal_server_error() -> Self {
+        ErrorResponse {
+            code: 500,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(500)),
+            html: Some(DefaultFormat::Html.response_for_code(500)),
+            json: Some(DefaultFormat::Json.response_for_code(500)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn not_found() -> Self {
+        ErrorResponse {
+            code: 404,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(404)),
+            html: Some(DefaultFormat::Html.response_for_code(404)),
+            json: Some(DefaultFormat::Json.response_for_code(404)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn unauthorized() -> Self {
+        ErrorResponse {
+            code: 401,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(401)),
+            html: Some(DefaultFormat::Html.response_for_code(401)),
+            json: Some(DefaultFormat::Json.response_for_code(401)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn forbidden() -> Self {
+        ErrorResponse {
+            code: 403,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(403)),
+            html: Some(DefaultFormat::Html.response_for_code(403)),
+            json: Some(DefaultFormat::Json.response_for_code(403)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn payload_too_large() -> Self {
+        ErrorResponse {
+            code: 413,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(413)),
+            html: Some(DefaultFormat::Html.response_for_code(413)),
+            json: Some(DefaultFormat::Json.response_for_code(413)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn too_many_requests() -> Self {
+        ErrorResponse {
+            code: 429,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(429)),
+            html: Some(DefaultFormat::Html.response_for_code(429)),
+            json: Some(DefaultFormat::Json.response_for_code(429)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn bad_gateway() -> Self {
+        ErrorResponse {
+            code: 502,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(502)),
+            html: Some(DefaultFormat::Html.response_for_code(502)),
+            json: Some(DefaultFormat::Json.response_for_code(502)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn service_unavailable() -> Self {
+        ErrorResponse {
+            code: 503,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(503)),
+            html: Some(DefaultFormat::Html.response_for_code(503)),
+            json: Some(DefaultFormat::Json.response_for_code(503)),
+            default: DefaultFormat::Html,
+        }
+    }
+
+    pub fn gateway_timeout() -> Self {
+        ErrorResponse {
+            code: 504,
+            plaintext: Some(DefaultFormat::Plaintext.response_for_code(504)),
+            html: Some(DefaultFormat::Html.response_for_code(504)),
+            json: Some(DefaultFormat::Json.response_for_code(504)),
+            default: DefaultFormat::Html,
+        }
+    }
+}

data/crates/itsi_server/src/server/middleware_stack/middlewares/error_response.rs

@@ -1,127 +1,157 @@
-use crate::server::static_file_server::ROOT_STATIC_FILE_SERVER;
-use crate::server::types::RequestExt;
-use crate::server::{
-    itsi_service::RequestContext,
-    types::{HttpRequest, HttpResponse},
-};
-
 use bytes::Bytes;
-use either::Either;
+use http::header::CONTENT_TYPE;
 use http::Response;
 use http_body_util::{combinators::BoxBody, Full};
-use itsi_error::ItsiError;
-use serde::Deserialize;
-use std::path::{Path, PathBuf};
+use serde::{Deserialize, Deserializer};
+use std::convert::Infallible;
+use std::path::PathBuf;
+
+use crate::server::http_message_types::{HttpResponse, ResponseFormat};
+use crate::services::static_file_server::ROOT_STATIC_FILE_SERVER;
+mod default_responses;
 
 #[derive(Debug, Clone, Deserialize)]
-/// Filters can each have a customizable error response.
-/// They can:
-/// * Return Plain-text
-/// * Return HTML
-/// * Return JSON
-pub struct ErrorResponse {
-    code: u16,
-    plaintext: Option<String>,
-    html: Option<PathBuf>,
-    json: Option<serde_json::Value>,
-    default: ErrorFormat,
+pub enum ContentSource {
+    #[serde(rename(deserialize = "inline"))]
+    Inline(String),
+    #[serde(rename(deserialize = "file"))]
+    File(PathBuf),
 }
 
 #[derive(Debug, Clone, Deserialize, Default)]
-enum ErrorFormat {
-    #[default]
+pub enum DefaultFormat {
     #[serde(rename(deserialize = "plaintext"))]
     Plaintext,
+    #[default]
     #[serde(rename(deserialize = "html"))]
     Html,
     #[serde(rename(deserialize = "json"))]
     Json,
 }
 
-impl Default for ErrorResponse {
-    fn default() -> Self {
-        ErrorResponse {
-            code: 500,
-            plaintext: Some("Error".to_owned()),
-            html: None,
-            json: None,
-            default: ErrorFormat::Plaintext,
+#[derive(Debug, Clone)]
+pub struct ErrorResponse {
+    pub code: u16,
+    pub plaintext: Option<ContentSource>,
+    pub html: Option<ContentSource>,
+    pub json: Option<ContentSource>,
+    pub default: DefaultFormat, // must match one of the provided fields
+}
+
+impl<'de> Deserialize<'de> for ErrorResponse {
+    fn deserialize<D>(deserializer: D) -> Result<ErrorResponse, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let def = ErrorResponseDef::deserialize(deserializer)?;
+        Ok(def.into())
+    }
+}
+
+/// An untagged enum to support two input formats:
+/// - A detailed struct with all fields.
+/// - A string with the name of a default error response.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(untagged)]
+pub enum ErrorResponseDef {
+    Detailed {
+        code: u16,
+        plaintext: Option<ContentSource>,
+        html: Option<ContentSource>,
+        json: Option<ContentSource>,
+        default: DefaultFormat,
+    },
+    Named(String),
+}
+
+impl From<ErrorResponseDef> for ErrorResponse {
+    fn from(def: ErrorResponseDef) -> Self {
+        match def {
+            ErrorResponseDef::Detailed {
+                code,
+                plaintext,
+                html,
+                json,
+                default,
+            } => ErrorResponse {
+                code,
+                plaintext,
+                html,
+                json,
+                default,
+            },
+            ErrorResponseDef::Named(name) => match name.as_str() {
+                "internal_server_error" => ErrorResponse::internal_server_error(),
+                "not_found" => ErrorResponse::not_found(),
+                "unauthorized" => ErrorResponse::unauthorized(),
+                "forbidden" => ErrorResponse::forbidden(),
+                "payload_too_large" => ErrorResponse::payload_too_large(),
+                "too_many_requests" => ErrorResponse::too_many_requests(),
+                "bad_gateway" => ErrorResponse::bad_gateway(),
+                "service_unavailable" => ErrorResponse::service_unavailable(),
+                "gateway_timeout" => ErrorResponse::gateway_timeout(),
+                _ => panic!("Unknown error response name: {}", name),
+            },
         }
     }
 }
 
 impl ErrorResponse {
-    pub(crate) async fn to_http_response(&self, request: &HttpRequest) -> HttpResponse {
-        let accept = request.accept();
-        let body = match accept {
-            Some(accept) if accept.contains("text/plain") => BoxBody::new(Full::new(Bytes::from(
-                self.plaintext.clone().unwrap_or_else(|| "Error".to_owned()),
-            ))),
-            Some(accept) if accept.contains("text/html") => {
-                if let Some(path) = &self.html {
-                    let path = path.to_str().unwrap();
-                    let response = ROOT_STATIC_FILE_SERVER.serve_single(path).await;
-
-                    if response.status().is_success() {
-                        response.into_body()
-                    } else {
-                        BoxBody::new(Full::new(Bytes::from("Error")))
-                    }
-                } else {
-                    BoxBody::new(Full::new(Bytes::from("Error")))
-                }
+    pub(crate) async fn to_http_response(&self, accept: ResponseFormat) -> HttpResponse {
+        let mut resp = Response::builder().status(self.code);
+        let response = match accept {
+            ResponseFormat::TEXT => {
+                resp = resp.header(CONTENT_TYPE, "text/plain");
+                resp.body(Self::get_response_body(self.code, &self.plaintext, accept).await)
             }
-            Some(accept) if accept.contains("application/json") => {
-                BoxBody::new(Full::new(Bytes::from(
-                    self.json
-                        .as_ref()
-                        .map(|json| json.to_string())
-                        .unwrap_or_else(|| "Error".to_owned()),
-                )))
+            ResponseFormat::HTML => {
+                resp = resp.header(CONTENT_TYPE, "text/html");
+                resp.body(Self::get_response_body(self.code, &self.html, accept).await)
             }
-            _ => match self.default {
-                ErrorFormat::Plaintext => BoxBody::new(Full::new(Bytes::from(
-                    self.plaintext.clone().unwrap_or_else(|| "Error".to_owned()),
-                ))),
-                ErrorFormat::Html => {
-                    if let Some(path) = &self.html {
-                        let path = path.to_str().unwrap();
-                        let response = ROOT_STATIC_FILE_SERVER.serve_single(path).await;
-
-                        if response.status().is_success() {
-                            response.into_body()
-                        } else {
-                            BoxBody::new(Full::new(Bytes::from("Error")))
-                        }
-                    } else {
-                        BoxBody::new(Full::new(Bytes::from("Error")))
-                    }
+            ResponseFormat::JSON => {
+                resp = resp.header(CONTENT_TYPE, "application/json");
+                resp.body(Self::get_response_body(self.code, &self.json, accept).await)
+            }
+            ResponseFormat::UNKNOWN => match self.default {
+                DefaultFormat::Plaintext => {
+                    resp = resp.header(CONTENT_TYPE, "text/plain");
+                    resp.body(Self::get_response_body(self.code, &self.plaintext, accept).await)
+                }
+                DefaultFormat::Html => {
+                    resp = resp.header(CONTENT_TYPE, "text/html");
+                    resp.body(Self::get_response_body(self.code, &self.html, accept).await)
+                }
+                DefaultFormat::Json => {
+                    resp = resp.header(CONTENT_TYPE, "application/json");
+                    resp.body(Self::get_response_body(self.code, &self.json, accept).await)
                 }
-                ErrorFormat::Json => BoxBody::new(Full::new(Bytes::from(
-                    self.json
-                        .as_ref()
-                        .map(|json| json.to_string())
-                        .unwrap_or_else(|| "Error".to_owned()),
-                ))),
             },
         };
-
-        Response::builder().status(self.code).body(body).unwrap()
+        response.unwrap()
     }
 
-    pub async fn before(
-        &self,
-        req: HttpRequest,
-        _context: &mut RequestContext,
-    ) -> Result<Either<HttpRequest, HttpResponse>, ItsiError> {
-        if let Some(path) = req.uri().path().strip_prefix("/error/") {
-            let path = Path::new(path);
-            if path.exists() {
-                let path = path.to_str().unwrap();
-                let response = ROOT_STATIC_FILE_SERVER.serve_single(path).await;
-                return Ok(Either::Right(response));
+    async fn get_response_body(
+        code: u16,
+        source: &Option<ContentSource>,
+        accept: ResponseFormat,
+    ) -> BoxBody<Bytes, Infallible> {
+        match source {
+            Some(ContentSource::Inline(text)) => {
+                return BoxBody::new(Full::new(Bytes::from(text.clone())));
+            }
+            Some(ContentSource::File(path)) => {
+                // Convert the PathBuf to a &str (assumes valid UTF-8).
+                if let Some(path_str) = path.to_str() {
+                    let response = ROOT_STATIC_FILE_SERVER
+                        .serve_single(path_str, accept.clone(), &[])
+                        .await;
+                    if response.status().is_success() {
+                        return response.into_body();
+                    }
+                }
             }
+            None => {}
         }
-        Ok(Either::Left(req))
+        ErrorResponse::fallback_body_for(code, accept)
     }
 }