[Core, Rust Server] Support JSON query parameters (#6577)

* [Core] Record content type for parameters

* [Rust Server] Support query parameters in JSON

* [Rust Server] Add test for JSON query parameter

* Update samples

Author: richardwhiuk

modules/openapi-generator/src/main/java/org/openapitools/codegen/DefaultCodegen.java

@@ -4096,22 +4096,23 @@ public CodegenParameter fromParameter(Parameter parameter, Set<String> imports)
             codegenParameter.vendorExtensions.putAll(parameter.getExtensions());
         }
 
-        Schema s;
+        Schema parameterSchema;
         if (parameter.getSchema() != null) {
-            s = parameter.getSchema();
+            parameterSchema = parameter.getSchema();
         } else if (parameter.getContent() != null) {
             Content content = parameter.getContent();
             if (content.size() > 1) {
                 once(LOGGER).warn("Multiple schemas found in content, returning only the first one");
             }
-            MediaType mediaType = content.values().iterator().next();
-            s = mediaType.getSchema();
+            Map.Entry<String, MediaType> entry = content.entrySet().iterator().next();
+            codegenParameter.contentType = entry.getKey();
+            parameterSchema = entry.getValue().getSchema();
         } else {
-            s = null;
+            parameterSchema = null;
         }
 
-        if (s != null) {
-            Schema parameterSchema = ModelUtils.unaliasSchema(this.openAPI, s, importMapping);
+        if (parameterSchema != null) {
+            parameterSchema = ModelUtils.unaliasSchema(this.openAPI, parameterSchema);
             if (parameterSchema == null) {
                 LOGGER.warn("warning!  Schema not found for parameter \"" + parameter.getName() + "\", using String");
                 parameterSchema = new StringSchema().description("//TODO automatically added by openapi-generator due to missing type definition.");

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustServerCodegen.java

@@ -1027,6 +1027,13 @@ private void postProcessOperationWithModels(CodegenOperation op, List<Object> al
             }
         }
 
+        for (CodegenParameter param : op.queryParams) {
+            // If the MIME type is JSON, mark it.  We don't currently support any other MIME types.
+            if (param.contentType != null && isMimetypeJson(param.contentType)) {
+                param.vendorExtensions.put("x-consumes-json", true);
+            }
+        }
+
         for (CodegenParameter param : op.formParams) {
             processParam(param, op);
         }

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

@@ -36,7 +36,23 @@
   {{^required}}
             if let Some(param_{{{paramName}}}) = param_{{{paramName}}} {
   {{/required}}
-                query_string.append_pair("{{{baseName}}}", &param_{{{paramName}}}{{#isListContainer}}.iter().map(ToString::to_string).collect::<Vec<String>>().join(","){{/isListContainer}}{{^isListContainer}}.to_string(){{/isListContainer}});
+                query_string.append_pair("{{{baseName}}}",
+  {{#vendorExtensions}}
+    {{#x-consumes-json}}
+                    &match serde_json::to_string(&param_{{{paramName}}}) {
+                        Ok(str) => str,
+                        Err(e) => return Err(ApiError(format!("Unable to serialize {{{paramName}}} to string: {}", e))),
+                    });
+    {{/x-consumes-json}}
+    {{^x-consumes-json}}
+      {{#isListContainer}}
+                    &param_{{{paramName}}}.iter().map(ToString::to_string).collect::<Vec<String>>().join(","));
+      {{/isListContainer}}
+      {{^isListContainer}}
+                    &param_{{{paramName}}}.to_string());
+      {{/isListContainer}}
+    {{/x-consumes-json}}
+  {{/vendorExtensions}}
   {{^required}}
             }
   {{/required}}
@@ -87,7 +103,7 @@
           {{#jsonSchema}}
             let {{{paramName}}}_str = match serde_json::to_string(&param_{{{paramName}}}) {
                 Ok(str) => str,
-                Err(e) => return Err(ApiError(format!("Unable to parse {{{paramName}}} to string: {}", e))),
+                Err(e) => return Err(ApiError(format!("Unable to serialize {{{paramName}}} to string: {}", e))),
             };
 
             let {{{paramName}}}_vec = {{{paramName}}}_str.as_bytes().to_vec();

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

@@ -121,43 +121,83 @@
   {{/-last}}
 {{/headerParams}}
 {{#queryParams}}
-{{#-first}}
+  {{#-first}}
                 // Query parameters (note that non-required or collection query parameters will ignore garbage values, rather than causing a 400 response)
                 let query_params = form_urlencoded::parse(uri.query().unwrap_or_default().as_bytes()).collect::<Vec<_>>();
-{{/-first}}
+  {{/-first}}
                 let param_{{{paramName}}} = query_params.iter().filter(|e| e.0 == "{{{baseName}}}").map(|e| e.1.to_owned())
-{{#isListContainer}}
+  {{#isListContainer}}
+    {{^vendorExtensions.x-consumes-json}}
                     .filter_map(|param_{{{paramName}}}| param_{{{paramName}}}.parse().ok())
                     .collect::<Vec<_>>();
-{{^required}}
+      {{^required}}
                 let param_{{{paramName}}} = if !param_{{{paramName}}}.is_empty() {
                     Some(param_{{{paramName}}})
                 } else {
                     None
                 };
-{{/required}}
-{{/isListContainer}}
-{{^isListContainer}}
+      {{/required}}
+    {{/vendorExtensions.x-consumes-json}}
+    {{#vendorExtensions.x-consumes-json}}
                     .nth(0);
-{{#required}}
                 let param_{{{paramName}}} = match param_{{{paramName}}} {
-                    Some(param_{{{paramName}}}) => match param_{{{paramName}}}.parse::<{{{dataType}}}>() {
-                        Ok(param_{{{paramName}}}) => param_{{{paramName}}},
-                        Err(e) => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from(format!("Couldn't parse query parameter {{{baseName}}} - doesn't match schema: {}", e)))
-                                        .expect("Unable to create Bad Request response for invalid query parameter {{{baseName}}}")),
+                    Some(param_{{{paramName}}}) => {
+                        let param_{{{paramName}}} =
+                            serde_json::from_str::<{{{dataType}}}>
+                                (&param_{{{paramName}}});
+                        match param_{{{paramName}}} {
+                            Ok(param_{{{paramName}}}) => Some(param_{{{paramName}}}),
+                            Err(e) => return Ok(Response::builder()
+                                .status(StatusCode::BAD_REQUEST)
+                                .body(Body::from(format!("Couldn't parse query parameter {{{baseName}}} - doesn't match schema: {}", e)))
+                                .expect("Unable to create Bad Request response for invalid query parameter {{{baseName}}}")),
+                        }
                     },
+                    None => None,
+                };
+      {{#required}}
+                let param_{{{paramName}}} = match param_{{{paramName}}} {
+                    Some(param_{{{paramName}}}) => param_{{{paramName}}},
                     None => return Ok(Response::builder()
-                                        .status(StatusCode::BAD_REQUEST)
-                                        .body(Body::from("Missing required query parameter {{{baseName}}}"))
-                                        .expect("Unable to create Bad Request response for missing qeury parameter {{{baseName}}}")),
+                        .status(StatusCode::BAD_REQUEST)
+                        .body(Body::from("Missing required query parameter {{{baseName}}}"))
+                        .expect("Unable to create Bad Request response for missing query parameter {{{baseName}}}")),
                 };
-{{/required}}
-{{^required}}
-                let param_{{{paramName}}} = param_{{{paramName}}}.and_then(|param_{{{paramName}}}| param_{{{paramName}}}.parse::<{{{baseType}}}>().ok());
-{{/required}}
-{{/isListContainer}}
+      {{/required}}
+    {{/vendorExtensions.x-consumes-json}}
+  {{/isListContainer}}
+  {{^isListContainer}}
+                    .nth(0);
+                let param_{{{paramName}}} = match param_{{{paramName}}} {
+                    Some(param_{{{paramName}}}) => {
+                        let param_{{{paramName}}} =
+    {{#vendorExtensions.x-consumes-json}}
+                            serde_json::from_str::<{{{dataType}}}>
+    {{/vendorExtensions.x-consumes-json}}
+    {{^vendorExtensions.x-consumes-json}}
+                            <{{{dataType}}} as std::str::FromStr>::from_str
+    {{/vendorExtensions.x-consumes-json}}
+                                (&param_{{{paramName}}});
+                        match param_{{{paramName}}} {
+                            Ok(param_{{{paramName}}}) => Some(param_{{{paramName}}}),
+                            Err(e) => return Ok(Response::builder()
+                                .status(StatusCode::BAD_REQUEST)
+                                .body(Body::from(format!("Couldn't parse query parameter {{{baseName}}} - doesn't match schema: {}", e)))
+                                .expect("Unable to create Bad Request response for invalid query parameter {{{baseName}}}")),
+                        }
+                    },
+                    None => None,
+                };
+    {{#required}}
+                let param_{{{paramName}}} = match param_{{{paramName}}} {
+                    Some(param_{{{paramName}}}) => param_{{{paramName}}},
+                    None => return Ok(Response::builder()
+                        .status(StatusCode::BAD_REQUEST)
+                        .body(Body::from("Missing required query parameter {{{baseName}}}"))
+                        .expect("Unable to create Bad Request response for missing query parameter {{{baseName}}}")),
+                };
+    {{/required}}
+  {{/isListContainer}}
   {{#-last}}
 
   {{/-last}}

modules/openapi-generator/src/test/resources/3_0/rust-server/openapi-v3.yaml

@@ -391,6 +391,20 @@ paths:
       responses:
         '200':
           description: Success
+  /json-complex-query-param:
+    get:
+      parameters:
+        - name: list-of-strings
+          in: query
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: '#/components/schemas/StringObject'
+      responses:
+        '200':
+          description: Success
 
 components:
   securitySchemes:

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

@@ -574,7 +574,7 @@ impl<S, C> Api<C> for Client<S, C> where
 
             let string_field_str = match serde_json::to_string(&param_string_field) {
                 Ok(str) => str,
-                Err(e) => return Err(ApiError(format!("Unable to parse string_field to string: {}", e))),
+                Err(e) => return Err(ApiError(format!("Unable to serialize string_field to string: {}", e))),
             };
 
             let string_field_vec = string_field_str.as_bytes().to_vec();
@@ -586,7 +586,7 @@ impl<S, C> Api<C> for Client<S, C> where
 
             let optional_string_field_str = match serde_json::to_string(&param_optional_string_field) {
                 Ok(str) => str,
-                Err(e) => return Err(ApiError(format!("Unable to parse optional_string_field to string: {}", e))),
+                Err(e) => return Err(ApiError(format!("Unable to serialize optional_string_field to string: {}", e))),
             };
 
             let optional_string_field_vec = optional_string_field_str.as_bytes().to_vec();
@@ -598,7 +598,7 @@ impl<S, C> Api<C> for Client<S, C> where
 
             let object_field_str = match serde_json::to_string(&param_object_field) {
                 Ok(str) => str,
-                Err(e) => return Err(ApiError(format!("Unable to parse object_field to string: {}", e))),
+                Err(e) => return Err(ApiError(format!("Unable to serialize object_field to string: {}", e))),
             };
 
             let object_field_vec = object_field_str.as_bytes().to_vec();

samples/server/petstore/rust-server/output/openapi-v3/README.md

@@ -63,6 +63,7 @@ To run a client, follow one of the following simple steps:
 ```
 cargo run --example client CallbackWithHeaderPost
 cargo run --example client ComplexQueryParamGet
+cargo run --example client JsonComplexQueryParamGet
 cargo run --example client MandatoryRequestHeaderGet
 cargo run --example client MergePatchJsonGet
 cargo run --example client MultigetGet
@@ -119,6 +120,7 @@ Method | HTTP request | Description
 [****](docs/default_api.md#) | **POST** /callback-with-header | 
 [****](docs/default_api.md#) | **GET** /complex-query-param | 
 [****](docs/default_api.md#) | **GET** /enum_in_path/{path_param} | 
+[****](docs/default_api.md#) | **GET** /json-complex-query-param | 
 [****](docs/default_api.md#) | **GET** /mandatory-request-header | 
 [****](docs/default_api.md#) | **GET** /merge-patch-json | 
 [****](docs/default_api.md#) | **GET** /multiget | Get some stuff.

samples/server/petstore/rust-server/output/openapi-v3/api/openapi.yaml

@@ -407,6 +407,23 @@ paths:
           description: Success
       tags:
       - Repo
+  /json-complex-query-param:
+    get:
+      parameters:
+      - content:
+          application/json:
+            schema:
+              items:
+                $ref: '#/components/schemas/StringObject'
+              type: array
+        explode: true
+        in: query
+        name: list-of-strings
+        required: false
+        style: form
+      responses:
+        "200":
+          description: Success
 components:
   schemas:
     EnumWithStarObject:

samples/server/petstore/rust-server/output/openapi-v3/docs/default_api.md

@@ -7,6 +7,7 @@ Method | HTTP request | Description
 ****](default_api.md#) | **POST** /callback-with-header | 
 ****](default_api.md#) | **GET** /complex-query-param | 
 ****](default_api.md#) | **GET** /enum_in_path/{path_param} | 
+****](default_api.md#) | **GET** /json-complex-query-param | 
 ****](default_api.md#) | **GET** /mandatory-request-header | 
 ****](default_api.md#) | **GET** /merge-patch-json | 
 ****](default_api.md#) | **GET** /multiget | Get some stuff.
@@ -109,6 +110,38 @@ No authorization required
 
 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
 
+# ****
+> (optional)
+
+
+### Required Parameters
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **optional** | **map[string]interface{}** | optional parameters | nil if no parameters
+
+### Optional Parameters
+Optional parameters are passed through a map[string]interface{}.
+
+Name | Type | Description  | Notes
+------------- | ------------- | ------------- | -------------
+ **list_of_strings** | [**String**](String.md)|  | 
+
+### Return type
+
+ (empty response body)
+
+### Authorization
+
+No authorization required
+
+### HTTP request headers
+
+ - **Content-Type**: Not defined
+ - **Accept**: Not defined
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
 # ****
 > (x_header)
 

samples/server/petstore/rust-server/output/openapi-v3/examples/client/main.rs

@@ -9,6 +9,7 @@ use openapi_v3::{Api, ApiNoContext, Client, ContextWrapperExt, models,
                       CallbackWithHeaderPostResponse,
                       ComplexQueryParamGetResponse,
                       EnumInPathPathParamGetResponse,
+                      JsonComplexQueryParamGetResponse,
                       MandatoryRequestHeaderGetResponse,
                       MergePatchJsonGetResponse,
                       MultigetGetResponse,
@@ -52,6 +53,7 @@ fn main() {
             .possible_values(&[
                 "CallbackWithHeaderPost",
                 "ComplexQueryParamGet",
+                "JsonComplexQueryParamGet",
                 "MandatoryRequestHeaderGet",
                 "MergePatchJsonGet",
                 "MultigetGet",
@@ -138,6 +140,12 @@ fn main() {
             info!("{:?} (X-Span-ID: {:?})", result, (client.context() as &dyn Has<XSpanIdString>).get().clone());
         },
         */
+        Some("JsonComplexQueryParamGet") => {
+            let result = rt.block_on(client.json_complex_query_param_get(
+                  Some(&Vec::new())
+            ));
+            info!("{:?} (X-Span-ID: {:?})", result, (client.context() as &dyn Has<XSpanIdString>).get().clone());
+        },
         Some("MandatoryRequestHeaderGet") => {
             let result = rt.block_on(client.mandatory_request_header_get(
                   "x_header_example".to_string()