[Rust-Axum][Breaking Change] Implement a customizable error handler

modules/openapi-generator/src/main/resources/rust-axum/README.mustache

@@ -48,16 +48,18 @@ struct ServerImpl {
 
 #[allow(unused_variables)]
 #[async_trait]
-impl {{{packageName}}}::Api for ServerImpl {
+impl {{{externCrateName}}}::apis::default::Api for ServerImpl {
   // API implementation goes here
 }
 
+impl {{{externCrateName}}}::apis::ErrorHandler for ServerImpl {}
+
 pub async fn start_server(addr: &str) {
     // initialize tracing
     tracing_subscriber::fmt::init();
 
     // Init Axum router
-    let app = {{{packageName}}}::server::new(Arc::new(ServerImpl));
+    let app = {{{externCrateName}}}::server::new(Arc::new(ServerImpl));
 
     // Add layers to the router
     let app = app.layer(...);

modules/openapi-generator/src/main/resources/rust-axum/apis-mod.mustache

@@ -27,4 +27,17 @@ pub trait ApiKeyAuthHeader {
 }
 {{/isKeyInHeader}}
 {{/isApiKey}}
-{{/authMethods}}
+{{/authMethods}}
+
+// Error handler for unhandled errors.
+#[async_trait::async_trait]
+pub trait ErrorHandler<E: std::fmt::Debug + Send + Sync + 'static = ()> {
+    #[tracing::instrument(skip(self))]
+    async fn handle_error(&self, error: E) -> Result<axum::response::Response, http::StatusCode> {
+        tracing::error!("Unhandled error: {:?}", error);
+        axum::response::Response::builder()
+            .status(500)
+            .body(axum::body::Body::empty())
+            .map_err(|_| http::StatusCode::INTERNAL_SERVER_ERROR)
+    }
+}

modules/openapi-generator/src/main/resources/rust-axum/apis.mustache

@@ -17,9 +17,9 @@ use crate::{models, types::*};
 /// {{classnamePascalCase}}
 #[async_trait]
 #[allow(clippy::ptr_arg)]
-pub trait {{classnamePascalCase}} {
+pub trait {{classnamePascalCase}}<E: std::fmt::Debug + Send + Sync + 'static = ()>: super::ErrorHandler<E> {
 {{#havingAuthMethod}}
-  type Claims;
+    type Claims;
 
 {{/havingAuthMethod}}
 {{#operation}}
@@ -73,7 +73,7 @@ pub trait {{classnamePascalCase}} {
     {{#x-consumes-multipart-related}}
         body: axum::body::Body,
     {{/x-consumes-multipart-related}}
-    ) -> Result<{{{operationId}}}Response, ()>;
+    ) -> Result<{{{operationId}}}Response, E>;
   {{/vendorExtensions}}
   {{^-last}}
 

modules/openapi-generator/src/main/resources/rust-axum/server-operation.mustache

@@ -1,6 +1,6 @@
 /// {{{operationId}}} - {{{httpMethod}}} {{{basePathWithoutHost}}}{{{path}}}
 #[tracing::instrument(skip_all)]
-async fn {{#vendorExtensions}}{{{x-operation-id}}}{{/vendorExtensions}}<I, A{{#havingAuthMethod}}, C{{/havingAuthMethod}}>(
+async fn {{#vendorExtensions}}{{{x-operation-id}}}{{/vendorExtensions}}<I, A, E{{#havingAuthMethod}}, C{{/havingAuthMethod}}>(
   method: Method,
   host: Host,
   cookies: CookieJar,
@@ -54,8 +54,9 @@ async fn {{#vendorExtensions}}{{{x-operation-id}}}{{/vendorExtensions}}<I, A{{#h
 ) -> Result<Response, StatusCode>
 where
     I: AsRef<A> + Send + Sync,
-    A: apis::{{classFilename}}::{{classnamePascalCase}}{{#havingAuthMethod}}<Claims = C>{{/havingAuthMethod}}{{#vendorExtensions}}{{#x-has-cookie-auth-methods}}+ apis::CookieAuthentication<Claims = C>{{/x-has-cookie-auth-methods}}{{#x-has-header-auth-methods}}+ apis::ApiKeyAuthHeader<Claims = C>{{/x-has-header-auth-methods}}{{/vendorExtensions}},
-{
+    A: apis::{{classFilename}}::{{classnamePascalCase}}<E{{#havingAuthMethod}}, Claims = C{{/havingAuthMethod}}>{{#vendorExtensions}}{{#x-has-cookie-auth-methods}}+ apis::CookieAuthentication<Claims = C>{{/x-has-cookie-auth-methods}}{{#x-has-header-auth-methods}}+ apis::ApiKeyAuthHeader<Claims = C>{{/x-has-header-auth-methods}}{{/vendorExtensions}} + Send + Sync,
+    E: std::fmt::Debug + Send + Sync + 'static,
+        {
 {{#vendorExtensions}}
 {{#x-has-auth-methods}}
     // Authentication
@@ -342,10 +343,10 @@ where
                                                 },
 {{/responses}}
                                             },
-                                            Err(_) => {
+                                            Err(why) => {
                                                 // Application code returned an error. This should not happen, as the implementation should
                                                 // return a valid response.
-                                                response.status(500).body(Body::empty())
+                                                return api_impl.as_ref().handle_error(why).await;
                                             },
                                         };
 

modules/openapi-generator/src/main/resources/rust-axum/server-route.mustache

@@ -1,15 +1,16 @@
 /// Setup API Server.
-pub fn new<I, A{{#havingAuthMethods}}, C{{/havingAuthMethods}}>(api_impl: I) -> Router
+pub fn new<I, A, E{{#havingAuthMethods}}, C{{/havingAuthMethods}}>(api_impl: I) -> Router
 where
     I: AsRef<A> + Clone + Send + Sync + 'static,
-    A: {{#apiInfo}}{{#apis}}{{#operations}}apis::{{classFilename}}::{{classnamePascalCase}}{{#havingAuthMethod}}<Claims = C>{{/havingAuthMethod}} + {{/operations}}{{/apis}}{{/apiInfo}}{{#authMethods}}{{#isApiKey}}{{#isKeyInCookie}}apis::CookieAuthentication<Claims = C> + {{/isKeyInCookie}}{{#isKeyInHeader}}apis::ApiKeyAuthHeader<Claims = C> + {{/isKeyInHeader}}{{/isApiKey}}{{/authMethods}}'static,
+    A: {{#apiInfo}}{{#apis}}{{#operations}}apis::{{classFilename}}::{{classnamePascalCase}}<E{{#havingAuthMethod}}, Claims = C{{/havingAuthMethod}}> + {{/operations}}{{/apis}}{{/apiInfo}}{{#authMethods}}{{#isApiKey}}{{#isKeyInCookie}}apis::CookieAuthentication<Claims = C> + {{/isKeyInCookie}}{{#isKeyInHeader}}apis::ApiKeyAuthHeader<Claims = C> + {{/isKeyInHeader}}{{/isApiKey}}{{/authMethods}}Send + Sync + 'static,
+    E: std::fmt::Debug + Send + Sync + 'static,
     {{#havingAuthMethods}}C: Send + Sync + 'static,{{/havingAuthMethods}}
 {
     // build our application with a route
     Router::new()
         {{#pathMethodOps}}
         .route("{{{basePathWithoutHost}}}{{{path}}}",
-            {{#methodOperations}}{{{method}}}({{{operationID}}}::<I, A{{#vendorExtensions}}{{#havingAuthMethod}}, C{{/havingAuthMethod}}{{/vendorExtensions}}>){{^-last}}.{{/-last}}{{/methodOperations}}
+            {{#methodOperations}}{{{method}}}({{{operationID}}}::<I, A, E{{#vendorExtensions}}{{#havingAuthMethod}}, C{{/havingAuthMethod}}{{/vendorExtensions}}>){{^-last}}.{{/-last}}{{/methodOperations}}
         )
         {{/pathMethodOps}}
         .with_state(api_impl)

samples/server/petstore/rust-axum/output/apikey-auths/README.md

@@ -43,16 +43,18 @@ struct ServerImpl {
 
 #[allow(unused_variables)]
 #[async_trait]
-impl apikey-auths::Api for ServerImpl {
+impl apikey_auths::apis::default::Api for ServerImpl {
   // API implementation goes here
 }
 
+impl apikey_auths::apis::ErrorHandler for ServerImpl {}
+
 pub async fn start_server(addr: &str) {
     // initialize tracing
     tracing_subscriber::fmt::init();
 
     // Init Axum router
-    let app = apikey-auths::server::new(Arc::new(ServerImpl));
+    let app = apikey_auths::server::new(Arc::new(ServerImpl));
 
     // Add layers to the router
     let app = app.layer(...);

samples/server/petstore/rust-axum/output/apikey-auths/src/apis/mod.rs

@@ -24,3 +24,16 @@ pub trait CookieAuthentication {
         key: &str,
     ) -> Option<Self::Claims>;
 }
+
+// Error handler for unhandled errors.
+#[async_trait::async_trait]
+pub trait ErrorHandler<E: std::fmt::Debug + Send + Sync + 'static = ()> {
+    #[tracing::instrument(skip(self))]
+    async fn handle_error(&self, error: E) -> Result<axum::response::Response, http::StatusCode> {
+        tracing::error!("Unhandled error: {:?}", error);
+        axum::response::Response::builder()
+            .status(500)
+            .body(axum::body::Body::empty())
+            .map_err(|_| http::StatusCode::INTERNAL_SERVER_ERROR)
+    }
+}

samples/server/petstore/rust-axum/output/apikey-auths/src/apis/payments.rs

@@ -38,7 +38,9 @@ pub enum PostMakePaymentResponse {
 /// Payments
 #[async_trait]
 #[allow(clippy::ptr_arg)]
-pub trait Payments {
+pub trait Payments<E: std::fmt::Debug + Send + Sync + 'static = ()>:
+    super::ErrorHandler<E>
+{
     type Claims;
 
     /// Get payment method by id.
@@ -50,7 +52,7 @@ pub trait Payments {
         host: Host,
         cookies: CookieJar,
         path_params: models::GetPaymentMethodByIdPathParams,
-    ) -> Result<GetPaymentMethodByIdResponse, ()>;
+    ) -> Result<GetPaymentMethodByIdResponse, E>;
 
     /// Get payment methods.
     ///
@@ -60,7 +62,7 @@ pub trait Payments {
         method: Method,
         host: Host,
         cookies: CookieJar,
-    ) -> Result<GetPaymentMethodsResponse, ()>;
+    ) -> Result<GetPaymentMethodsResponse, E>;
 
     /// Make a payment.
     ///
@@ -72,5 +74,5 @@ pub trait Payments {
         cookies: CookieJar,
         claims: Self::Claims,
         body: Option<models::Payment>,
-    ) -> Result<PostMakePaymentResponse, ()>;
+    ) -> Result<PostMakePaymentResponse, E>;
 }

samples/server/petstore/rust-axum/output/apikey-auths/src/server/mod.rs

@@ -13,23 +13,29 @@ use crate::{header, types::*};
 use crate::{apis, models};
 
 /// Setup API Server.
-pub fn new<I, A, C>(api_impl: I) -> Router
+pub fn new<I, A, E, C>(api_impl: I) -> Router
 where
     I: AsRef<A> + Clone + Send + Sync + 'static,
-    A: apis::payments::Payments<Claims = C>
+    A: apis::payments::Payments<E, Claims = C>
         + apis::ApiKeyAuthHeader<Claims = C>
         + apis::CookieAuthentication<Claims = C>
+        + Send
+        + Sync
         + 'static,
+    E: std::fmt::Debug + Send + Sync + 'static,
     C: Send + Sync + 'static,
 {
     // build our application with a route
     Router::new()
-        .route("/v71/paymentMethods", get(get_payment_methods::<I, A, C>))
+        .route(
+            "/v71/paymentMethods",
+            get(get_payment_methods::<I, A, E, C>),
+        )
         .route(
             "/v71/paymentMethods/:id",
-            get(get_payment_method_by_id::<I, A, C>),
+            get(get_payment_method_by_id::<I, A, E, C>),
         )
-        .route("/v71/payments", post(post_make_payment::<I, A, C>))
+        .route("/v71/payments", post(post_make_payment::<I, A, E, C>))
         .with_state(api_impl)
 }
 
@@ -43,7 +49,7 @@ fn get_payment_method_by_id_validation(
 }
 /// GetPaymentMethodById - GET /v71/paymentMethods/{id}
 #[tracing::instrument(skip_all)]
-async fn get_payment_method_by_id<I, A, C>(
+async fn get_payment_method_by_id<I, A, E, C>(
     method: Method,
     host: Host,
     cookies: CookieJar,
@@ -52,7 +58,8 @@ async fn get_payment_method_by_id<I, A, C>(
 ) -> Result<Response, StatusCode>
 where
     I: AsRef<A> + Send + Sync,
-    A: apis::payments::Payments<Claims = C>,
+    A: apis::payments::Payments<E, Claims = C> + Send + Sync,
+    E: std::fmt::Debug + Send + Sync + 'static,
 {
     #[allow(clippy::redundant_closure)]
     let validation =
@@ -123,10 +130,10 @@ where
                 response.body(Body::from(body_content))
             }
         },
-        Err(_) => {
+        Err(why) => {
             // Application code returned an error. This should not happen, as the implementation should
             // return a valid response.
-            response.status(500).body(Body::empty())
+            return api_impl.as_ref().handle_error(why).await;
         }
     };
 
@@ -142,15 +149,16 @@ fn get_payment_methods_validation() -> std::result::Result<(), ValidationErrors>
 }
 /// GetPaymentMethods - GET /v71/paymentMethods
 #[tracing::instrument(skip_all)]
-async fn get_payment_methods<I, A, C>(
+async fn get_payment_methods<I, A, E, C>(
     method: Method,
     host: Host,
     cookies: CookieJar,
     State(api_impl): State<I>,
 ) -> Result<Response, StatusCode>
 where
     I: AsRef<A> + Send + Sync,
-    A: apis::payments::Payments<Claims = C>,
+    A: apis::payments::Payments<E, Claims = C> + Send + Sync,
+    E: std::fmt::Debug + Send + Sync + 'static,
 {
     #[allow(clippy::redundant_closure)]
     let validation = tokio::task::spawn_blocking(move || get_payment_methods_validation())
@@ -197,10 +205,10 @@ where
                 response.body(Body::from(body_content))
             }
         },
-        Err(_) => {
+        Err(why) => {
             // Application code returned an error. This should not happen, as the implementation should
             // return a valid response.
-            response.status(500).body(Body::empty())
+            return api_impl.as_ref().handle_error(why).await;
         }
     };
 
@@ -230,7 +238,7 @@ fn post_make_payment_validation(
 }
 /// PostMakePayment - POST /v71/payments
 #[tracing::instrument(skip_all)]
-async fn post_make_payment<I, A, C>(
+async fn post_make_payment<I, A, E, C>(
     method: Method,
     host: Host,
     cookies: CookieJar,
@@ -239,7 +247,11 @@ async fn post_make_payment<I, A, C>(
 ) -> Result<Response, StatusCode>
 where
     I: AsRef<A> + Send + Sync,
-    A: apis::payments::Payments<Claims = C> + apis::CookieAuthentication<Claims = C>,
+    A: apis::payments::Payments<E, Claims = C>
+        + apis::CookieAuthentication<Claims = C>
+        + Send
+        + Sync,
+    E: std::fmt::Debug + Send + Sync + 'static,
 {
     // Authentication
     let claims_in_cookie = api_impl
@@ -322,10 +334,10 @@ where
                 response.body(Body::from(body_content))
             }
         },
-        Err(_) => {
+        Err(why) => {
             // Application code returned an error. This should not happen, as the implementation should
             // return a valid response.
-            response.status(500).body(Body::empty())
+            return api_impl.as_ref().handle_error(why).await;
         }
     };
 

samples/server/petstore/rust-axum/output/multipart-v3/README.md

@@ -43,16 +43,18 @@ struct ServerImpl {
 
 #[allow(unused_variables)]
 #[async_trait]
-impl multipart-v3::Api for ServerImpl {
+impl multipart_v3::apis::default::Api for ServerImpl {
   // API implementation goes here
 }
 
+impl multipart_v3::apis::ErrorHandler for ServerImpl {}
+
 pub async fn start_server(addr: &str) {
     // initialize tracing
     tracing_subscriber::fmt::init();
 
     // Init Axum router
-    let app = multipart-v3::server::new(Arc::new(ServerImpl));
+    let app = multipart_v3::server::new(Arc::new(ServerImpl));
 
     // Add layers to the router
     let app = app.layer(...);

samples/server/petstore/rust-axum/output/multipart-v3/src/apis/default.rs

@@ -34,15 +34,15 @@ pub enum MultipleIdenticalMimeTypesPostResponse {
 /// Default
 #[async_trait]
 #[allow(clippy::ptr_arg)]
-pub trait Default {
+pub trait Default<E: std::fmt::Debug + Send + Sync + 'static = ()>: super::ErrorHandler<E> {
     /// MultipartRelatedRequestPost - POST /multipart_related_request
     async fn multipart_related_request_post(
         &self,
         method: Method,
         host: Host,
         cookies: CookieJar,
         body: axum::body::Body,
-    ) -> Result<MultipartRelatedRequestPostResponse, ()>;
+    ) -> Result<MultipartRelatedRequestPostResponse, E>;
 
     /// MultipartRequestPost - POST /multipart_request
     async fn multipart_request_post(
@@ -51,7 +51,7 @@ pub trait Default {
         host: Host,
         cookies: CookieJar,
         body: Multipart,
-    ) -> Result<MultipartRequestPostResponse, ()>;
+    ) -> Result<MultipartRequestPostResponse, E>;
 
     /// MultipleIdenticalMimeTypesPost - POST /multiple-identical-mime-types
     async fn multiple_identical_mime_types_post(
@@ -60,5 +60,5 @@ pub trait Default {
         host: Host,
         cookies: CookieJar,
         body: axum::body::Body,
-    ) -> Result<MultipleIdenticalMimeTypesPostResponse, ()>;
+    ) -> Result<MultipleIdenticalMimeTypesPostResponse, E>;
 }

samples/server/petstore/rust-axum/output/multipart-v3/src/apis/mod.rs

@@ -1 +1,14 @@
 pub mod default;
+
+// Error handler for unhandled errors.
+#[async_trait::async_trait]
+pub trait ErrorHandler<E: std::fmt::Debug + Send + Sync + 'static = ()> {
+    #[tracing::instrument(skip(self))]
+    async fn handle_error(&self, error: E) -> Result<axum::response::Response, http::StatusCode> {
+        tracing::error!("Unhandled error: {:?}", error);
+        axum::response::Response::builder()
+            .status(500)
+            .body(axum::body::Body::empty())
+            .map_err(|_| http::StatusCode::INTERNAL_SERVER_ERROR)
+    }
+}