Update

Author: linxGnu

modules/openapi-generator/src/test/resources/3_0/rust-axum/rust-axum-oneof.yaml

@@ -19,9 +19,9 @@ paths:
             "application/json":
               schema:
                 "$ref": "#/components/schemas/Message"
-  "/issue21143":
+  "/issue21143_1":
     post:
-      operationId: i21143
+      operationId: i21143_1
       requestBody:
         required: true
         content:
@@ -37,6 +37,38 @@ paths:
             "application/json":
               schema:
                 "$ref": "#/components/schemas/Message"
+  "/issue21143_2":
+    post:
+      operationId: i21143_2
+      requestBody:
+        required: true
+        content:
+          "application/json":
+            schema:
+              type: string
+      responses:
+        "200":
+          description: Re-serialize and echo the request data
+          content:
+            "application/json":
+              schema:
+                "$ref": "#/components/schemas/Message"
+  "/issue21143_3":
+    post:
+      operationId: i21143_3
+      requestBody:
+        required: true
+        content:
+          "application/json":
+            schema:
+              type: integer
+      responses:
+        "200":
+          description: Re-serialize and echo the request data
+          content:
+            "application/json":
+              schema:
+                "$ref": "#/components/schemas/Message"
 components:
   schemas:
     Message:

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

@@ -18,7 +18,23 @@ pub enum FooResponse {
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[must_use]
 #[allow(clippy::large_enum_variant)]
-pub enum I21143Response {
+pub enum I211431Response {
+    /// Re-serialize and echo the request data
+    Status200_Re(models::Message),
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[must_use]
+#[allow(clippy::large_enum_variant)]
+pub enum I211432Response {
+    /// Re-serialize and echo the request data
+    Status200_Re(models::Message),
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[must_use]
+#[allow(clippy::large_enum_variant)]
+pub enum I211433Response {
     /// Re-serialize and echo the request data
     Status200_Re(models::Message),
 }
@@ -37,13 +53,33 @@ pub trait Default<E: std::fmt::Debug + Send + Sync + 'static = ()>: super::Error
         body: &models::Message,
     ) -> Result<FooResponse, E>;
 
-    /// I21143 - POST /issue21143
-    async fn i21143(
+    /// I211431 - POST /issue21143_1
+    async fn i211431(
         &self,
 
         method: &Method,
         host: &Host,
         cookies: &CookieJar,
         body: &Vec<i32>,
-    ) -> Result<I21143Response, E>;
+    ) -> Result<I211431Response, E>;
+
+    /// I211432 - POST /issue21143_2
+    async fn i211432(
+        &self,
+
+        method: &Method,
+        host: &Host,
+        cookies: &CookieJar,
+        body: &String,
+    ) -> Result<I211432Response, E>;
+
+    /// I211433 - POST /issue21143_3
+    async fn i211433(
+        &self,
+
+        method: &Method,
+        host: &Host,
+        cookies: &CookieJar,
+        body: &i32,
+    ) -> Result<I211433Response, E>;
 }

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

@@ -28,7 +28,9 @@ where
     // build our application with a route
     Router::new()
         .route("/", post(foo::<I, A, E>))
-        .route("/issue21143", post(i21143::<I, A, E>))
+        .route("/issue21143_1", post(i211431::<I, A, E>))
+        .route("/issue21143_2", post(i211432::<I, A, E>))
+        .route("/issue21143_3", post(i211433::<I, A, E>))
         .with_state(api_impl)
 }
 
@@ -117,20 +119,20 @@ where
 
 #[derive(validator::Validate)]
 #[allow(dead_code)]
-struct I21143BodyValidator<'a> {
+struct I211431BodyValidator<'a> {
     body: &'a Vec<i32>,
 }
 
 #[tracing::instrument(skip_all)]
-fn i21143_validation(body: Vec<i32>) -> std::result::Result<(Vec<i32>,), ValidationErrors> {
-    let b = I21143BodyValidator { body: &body };
+fn i211431_validation(body: Vec<i32>) -> std::result::Result<(Vec<i32>,), ValidationErrors> {
+    let b = I211431BodyValidator { body: &body };
     b.validate()?;
 
     Ok((body,))
 }
-/// I21143 - POST /issue21143
+/// I211431 - POST /issue21143_1
 #[tracing::instrument(skip_all)]
-async fn i21143<I, A, E>(
+async fn i211431<I, A, E>(
     method: Method,
     host: Host,
     cookies: CookieJar,
@@ -143,7 +145,7 @@ where
     E: std::fmt::Debug + Send + Sync + 'static,
 {
     #[allow(clippy::redundant_closure)]
-    let validation = tokio::task::spawn_blocking(move || i21143_validation(body))
+    let validation = tokio::task::spawn_blocking(move || i211431_validation(body))
         .await
         .unwrap();
 
@@ -156,14 +158,181 @@ where
 
     let result = api_impl
         .as_ref()
-        .i21143(&method, &host, &cookies, &body)
+        .i211431(&method, &host, &cookies, &body)
         .await;
 
     let mut response = Response::builder();
 
     let resp = match result {
         Ok(rsp) => match rsp {
-            apis::default::I21143Response::Status200_Re(body) => {
+            apis::default::I211431Response::Status200_Re(body) => {
+                let mut response = response.status(200);
+                {
+                    let mut response_headers = response.headers_mut().unwrap();
+                    response_headers
+                        .insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
+                }
+
+                let body_content = tokio::task::spawn_blocking(move || {
+                    serde_json::to_vec(&body).map_err(|e| {
+                        error!(error = ?e);
+                        StatusCode::INTERNAL_SERVER_ERROR
+                    })
+                })
+                .await
+                .unwrap()?;
+                response.body(Body::from(body_content))
+            }
+        },
+        Err(why) => {
+            // Application code returned an error. This should not happen, as the implementation should
+            // return a valid response.
+            return api_impl
+                .as_ref()
+                .handle_error(&method, &host, &cookies, why)
+                .await;
+        }
+    };
+
+    resp.map_err(|e| {
+        error!(error = ?e);
+        StatusCode::INTERNAL_SERVER_ERROR
+    })
+}
+
+#[derive(validator::Validate)]
+#[allow(dead_code)]
+struct I211432BodyValidator<'a> {
+    #[validate(custom(function = "check_xss_string"))]
+    body: &'a String,
+}
+
+#[tracing::instrument(skip_all)]
+fn i211432_validation(body: String) -> std::result::Result<(String,), ValidationErrors> {
+    let b = I211432BodyValidator { body: &body };
+    b.validate()?;
+
+    Ok((body,))
+}
+/// I211432 - POST /issue21143_2
+#[tracing::instrument(skip_all)]
+async fn i211432<I, A, E>(
+    method: Method,
+    host: Host,
+    cookies: CookieJar,
+    State(api_impl): State<I>,
+    Json(body): Json<String>,
+) -> Result<Response, StatusCode>
+where
+    I: AsRef<A> + Send + Sync,
+    A: apis::default::Default<E> + Send + Sync,
+    E: std::fmt::Debug + Send + Sync + 'static,
+{
+    #[allow(clippy::redundant_closure)]
+    let validation = tokio::task::spawn_blocking(move || i211432_validation(body))
+        .await
+        .unwrap();
+
+    let Ok((body,)) = validation else {
+        return Response::builder()
+            .status(StatusCode::BAD_REQUEST)
+            .body(Body::from(validation.unwrap_err().to_string()))
+            .map_err(|_| StatusCode::BAD_REQUEST);
+    };
+
+    let result = api_impl
+        .as_ref()
+        .i211432(&method, &host, &cookies, &body)
+        .await;
+
+    let mut response = Response::builder();
+
+    let resp = match result {
+        Ok(rsp) => match rsp {
+            apis::default::I211432Response::Status200_Re(body) => {
+                let mut response = response.status(200);
+                {
+                    let mut response_headers = response.headers_mut().unwrap();
+                    response_headers
+                        .insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
+                }
+
+                let body_content = tokio::task::spawn_blocking(move || {
+                    serde_json::to_vec(&body).map_err(|e| {
+                        error!(error = ?e);
+                        StatusCode::INTERNAL_SERVER_ERROR
+                    })
+                })
+                .await
+                .unwrap()?;
+                response.body(Body::from(body_content))
+            }
+        },
+        Err(why) => {
+            // Application code returned an error. This should not happen, as the implementation should
+            // return a valid response.
+            return api_impl
+                .as_ref()
+                .handle_error(&method, &host, &cookies, why)
+                .await;
+        }
+    };
+
+    resp.map_err(|e| {
+        error!(error = ?e);
+        StatusCode::INTERNAL_SERVER_ERROR
+    })
+}
+
+#[derive(validator::Validate)]
+#[allow(dead_code)]
+struct I211433BodyValidator<'a> {
+    body: &'a i32,
+}
+
+#[tracing::instrument(skip_all)]
+fn i211433_validation(body: i32) -> std::result::Result<(i32,), ValidationErrors> {
+    let b = I211433BodyValidator { body: &body };
+    b.validate()?;
+
+    Ok((body,))
+}
+/// I211433 - POST /issue21143_3
+#[tracing::instrument(skip_all)]
+async fn i211433<I, A, E>(
+    method: Method,
+    host: Host,
+    cookies: CookieJar,
+    State(api_impl): State<I>,
+    Json(body): Json<i32>,
+) -> Result<Response, StatusCode>
+where
+    I: AsRef<A> + Send + Sync,
+    A: apis::default::Default<E> + Send + Sync,
+    E: std::fmt::Debug + Send + Sync + 'static,
+{
+    #[allow(clippy::redundant_closure)]
+    let validation = tokio::task::spawn_blocking(move || i211433_validation(body))
+        .await
+        .unwrap();
+
+    let Ok((body,)) = validation else {
+        return Response::builder()
+            .status(StatusCode::BAD_REQUEST)
+            .body(Body::from(validation.unwrap_err().to_string()))
+            .map_err(|_| StatusCode::BAD_REQUEST);
+    };
+
+    let result = api_impl
+        .as_ref()
+        .i211433(&method, &host, &cookies, &body)
+        .await;
+
+    let mut response = Response::builder();
+
+    let resp = match result {
+        Ok(rsp) => match rsp {
+            apis::default::I211433Response::Status200_Re(body) => {
                 let mut response = response.status(200);
                 {
                     let mut response_headers = response.headers_mut().unwrap();