Generate code for OpenAPI 3.2 query/additionalOperations/in:querystring

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

@@ -387,4 +387,18 @@ default List<Operation> divideOperationsByContentType(OpenAPI openAPI, String pa
 
     Set<String> getOpenapiGeneratorIgnoreList();
 
+    /**
+     * Whether this generator can emit operations defined through OpenAPI 3.2's
+     * {@code query} fixed field and {@code additionalOperations} map, i.e. HTTP
+     * methods outside the original eight fixed methods. Generators whose
+     * templates embed enumerated method constants (e.g. {@code HttpMethod.QUERY})
+     * must keep the default {@code false}: the affected operations are then
+     * skipped with a warning instead of producing uncompilable code.
+     *
+     * @return true if the generator supports OpenAPI 3.2 query/additional operations
+     */
+    default boolean supportsAdditionalOperations() {
+        return false;
+    }
+
 }

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

@@ -50,6 +50,11 @@ public class CodegenParameter implements IJsonSchemaValidationProperties {
      * If a query parameter should be serialized as json
      */
     public boolean queryIsJsonMimeType;
+    /**
+     * OpenAPI 3.2 {@code in: querystring} parameter: the parameter value describes
+     * the entire query string (via {@code content}), not a single name=value pair.
+     */
+    public boolean isQueryStringParam;
     /**
      * datatype is the generic inner parameter of a std::optional for C++, or Optional (Java)
      */
@@ -270,6 +275,7 @@ public CodegenParameter copy() {
         output.isArray = this.isArray;
         output.isMap = this.isMap;
         output.queryIsJsonMimeType = this.queryIsJsonMimeType;
+        output.isQueryStringParam = this.isQueryStringParam;
         output.isOptional = this.isOptional;
         output.isExplode = this.isExplode;
         output.style = this.style;
@@ -294,7 +300,7 @@ public int hashCode() {
                 isFormStyle, isSpaceDelimited, isPipeDelimited,
                 jsonSchema, isString, isNumeric, isInteger, isLong, isNumber, isFloat, isDouble, isDecimal,
                 isByteArray, isBinary, isBoolean, isDate, isDateTime, isUuid, isUri, isEmail, isPassword,
-                isFreeFormObject, isAnyType, isArray, isMap, queryIsJsonMimeType, isOptional, isFile, isEnum, isEnumRef, _enum, allowableValues,
+                isFreeFormObject, isAnyType, isArray, isMap, queryIsJsonMimeType, isQueryStringParam, isOptional, isFile, isEnum, isEnumRef, _enum, allowableValues,
                 items, mostInnerItems, additionalProperties, vars, requiredVars, vendorExtensions, hasValidation,
                 getMaxProperties(), getMinProperties(), isNullable, isDeprecated, required, getMaximum(),
                 getExclusiveMaximum(), getMinimum(), getExclusiveMinimum(), getMaxLength(), getMinLength(),
@@ -312,6 +318,7 @@ public boolean equals(Object o) {
         CodegenParameter that = (CodegenParameter) o;
         return isFormParam == that.isFormParam &&
                 isQueryParam == that.isQueryParam &&
+                isQueryStringParam == that.isQueryStringParam &&
                 isPathParam == that.isPathParam &&
                 isHeaderParam == that.isHeaderParam &&
                 isCookieParam == that.isCookieParam &&
@@ -429,6 +436,7 @@ public String toString() {
         final StringBuilder sb = new StringBuilder("CodegenParameter{");
         sb.append("isFormParam=").append(isFormParam);
         sb.append(", isQueryParam=").append(isQueryParam);
+        sb.append(", isQueryStringParam=").append(isQueryStringParam);
         sb.append(", isPathParam=").append(isPathParam);
         sb.append(", isHeaderParam=").append(isHeaderParam);
         sb.append(", isCookieParam=").append(isCookieParam);

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

@@ -1397,8 +1397,20 @@ public void preprocessOpenAPI(OpenAPI openAPI) {
             // we need to add all request and response bodies to processed schemas
             if (pathItems != null) {
                 for (Map.Entry<String, PathItem> e : pathItems.entrySet()) {
-                    for (Map.Entry<PathItem.HttpMethod, Operation> op : e.getValue().readOperationsMap().entrySet()) {
-                        String opId = getOrGenerateOperationId(op.getValue(), e.getKey(), op.getKey().toString());
+                    Map<String, Operation> pathOperations = new LinkedHashMap<>();
+                    e.getValue().readOperationsMap().forEach((method, operation) -> {
+                        // HttpMethod.QUERY is in the enum map too - skip it for
+                        // generators that cannot emit the 3.2 operations
+                        if (method == PathItem.HttpMethod.QUERY && !supportsAdditionalOperations()) {
+                            return;
+                        }
+                        pathOperations.put(method.toString(), operation);
+                    });
+                    if (supportsAdditionalOperations() && e.getValue().getAdditionalOperations() != null) {
+                        pathOperations.putAll(e.getValue().getAdditionalOperations());
+                    }
+                    for (Map.Entry<String, Operation> op : pathOperations.entrySet()) {
+                        String opId = getOrGenerateOperationId(op.getValue(), e.getKey(), op.getKey());
                         // process request body
                         RequestBody b = ModelUtils.getReferencedRequestBody(openAPI, op.getValue().getRequestBody());
                         Schema requestSchema = null;
@@ -5154,7 +5166,11 @@ public CodegenOperation fromOperation(String path,
                 param = ModelUtils.getReferencedParameter(this.openAPI, param);
 
                 CodegenParameter p = fromParameter(param, imports);
-                p.setContent(getContent(param.getContent(), imports, "RequestParameter" + toModelName(param.getName())));
+                // for `in: querystring` the content schema only describes the wire format;
+                // the codegen parameter is a plain string and needs no content metadata/imports
+                if (!(param instanceof QueryStringParameter) && !"querystring".equalsIgnoreCase(param.getIn())) {
+                    p.setContent(getContent(param.getContent(), imports, "RequestParameter" + toModelName(param.getName())));
+                }
 
                 // ensure unique params
                 if (ensureUniqueParams) {
@@ -5173,6 +5189,10 @@ public CodegenOperation fromOperation(String path,
                     headerParams.add(p.copy());
                 } else if (param instanceof CookieParameter || "cookie".equalsIgnoreCase(param.getIn())) {
                     cookieParams.add(p.copy());
+                } else if (param instanceof QueryStringParameter || "querystring".equalsIgnoreCase(param.getIn())) {
+                    // keep it in queryParams so it lands in the operation signature;
+                    // templates use isQueryStringParam to emit the whole-query-string form
+                    queryParams.add(p.copy());
                 } else {
                     LOGGER.warn("Unknown parameter type {} for {}", p.baseType, p.baseName);
                 }
@@ -5501,14 +5521,31 @@ public CodegenCallback fromCallback(String name, Callback callback, List<Server>
                 u.vendorExtensions.putAll(pi.getExtensions());
             }
 
-            Stream.of(
-                            Pair.of("get", pi.getGet()),
-                            Pair.of("head", pi.getHead()),
-                            Pair.of("put", pi.getPut()),
-                            Pair.of("post", pi.getPost()),
-                            Pair.of("delete", pi.getDelete()),
-                            Pair.of("patch", pi.getPatch()),
-                            Pair.of("options", pi.getOptions()))
+            Stream.Builder<Pair<String, Operation>> callbackOps = Stream.builder();
+            callbackOps.add(Pair.of("get", pi.getGet()));
+            callbackOps.add(Pair.of("head", pi.getHead()));
+            callbackOps.add(Pair.of("put", pi.getPut()));
+            callbackOps.add(Pair.of("post", pi.getPost()));
+            callbackOps.add(Pair.of("delete", pi.getDelete()));
+            callbackOps.add(Pair.of("patch", pi.getPatch()));
+            callbackOps.add(Pair.of("options", pi.getOptions()));
+            callbackOps.add(Pair.of("trace", pi.getTrace()));
+            // additionalOperations keys are HTTP method names sent verbatim
+            Set<String> verbatimMethods = new HashSet<>();
+            if (supportsAdditionalOperations()) {
+                callbackOps.add(Pair.of("query", pi.getQuery()));
+                if (pi.getAdditionalOperations() != null) {
+                    pi.getAdditionalOperations().forEach((m, o) -> {
+                        callbackOps.add(Pair.of(m, o));
+                        verbatimMethods.add(m);
+                    });
+                }
+            } else if (pi.getQuery() != null
+                    || (pi.getAdditionalOperations() != null && !pi.getAdditionalOperations().isEmpty())) {
+                LOGGER.warn("Callback '{}' on expression '{}' declares OpenAPI 3.2 query/additionalOperations but generator '{}' does not support them; those operations will be missing from the generated output",
+                        name, expression, getName());
+            }
+            callbackOps.build()
                     .filter(p -> p.getValue() != null)
                     .forEach(p -> {
                         String method = p.getKey();
@@ -5532,6 +5569,9 @@ public CodegenCallback fromCallback(String name, Callback callback, List<Server>
                             op.getExtensions().put("x-callback-request", true);
 
                             CodegenOperation co = fromOperation(expression, method, op, servers);
+                            if (verbatimMethods.contains(method)) {
+                                co.httpMethod = method;
+                            }
                             if (genId) {
                                 co.operationIdOriginal = null;
                                 // legacy (see `fromOperation()`)
@@ -5646,7 +5686,22 @@ public CodegenParameter fromParameter(Parameter parameter, Set<String> imports)
         // e.g. #/components/schemas/list_pageQuery_parameter => toModelName(list_pageQuery_parameter)
         String parameterModelName = null;
 
-        if (parameter.getSchema() != null) {
+        // OpenAPI 3.2 `in: querystring`: the parameter describes the entire query
+        // string via `content`. Codegen exposes it as a plain string - the caller
+        // supplies the already-encoded query string (typed serialization of the
+        // content schema is not generated).
+        boolean isQueryStringParam = parameter instanceof QueryStringParameter
+                || "querystring".equalsIgnoreCase(parameter.getIn());
+        if (isQueryStringParam) {
+            parameterSchema = new StringSchema();
+            parameterModelName = getParameterDataType(parameter, parameterSchema);
+            if (!supportsQueryStringParameters()) {
+                once(LOGGER).warn("Encountered an `in: querystring` parameter ({}): this generator has no "
+                        + "dedicated querystring serialization support - generated code may drop the "
+                        + "parameter or emit a regular name=value pair instead of the whole query string.",
+                        parameter.getName());
+            }
+        } else if (parameter.getSchema() != null) {
             parameterSchema = unaliasSchema(parameter.getSchema());
             parameterModelName = getParameterDataType(parameter, parameterSchema);
             CodegenProperty prop;
@@ -5688,6 +5743,9 @@ public CodegenParameter fromParameter(Parameter parameter, Set<String> imports)
             codegenParameter.isHeaderParam = true;
         } else if (parameter instanceof CookieParameter || "cookie".equalsIgnoreCase(parameter.getIn())) {
             codegenParameter.isCookieParam = true;
+        } else if (parameter instanceof QueryStringParameter || "querystring".equalsIgnoreCase(parameter.getIn())) {
+            // OpenAPI 3.2: the parameter describes the entire query string via `content`
+            codegenParameter.isQueryStringParam = true;
         } else {
             LOGGER.warn("Unknown parameter type: {}", parameter.getName());
         }
@@ -5935,6 +5993,19 @@ public boolean isDataTypeBinary(String dataType) {
         }
     }
 
+    /**
+     * Whether this generator emits dedicated serialization for OpenAPI 3.2
+     * {@code in: querystring} parameters (the parameter value is the whole,
+     * already-encoded query string rather than a single name=value pair).
+     * Generators without support may drop the parameter or emit a named query
+     * parameter - {@link #fromParameter} warns in that case.
+     *
+     * @return true if the generator supports {@code in: querystring} parameters
+     */
+    protected boolean supportsQueryStringParameters() {
+        return false;
+    }
+
     // TODO revise below as it should be replaced by ModelUtils.isFileSchema(parameterSchema)
     public boolean isDataTypeFile(String dataType) {
         if (dataType != null) {

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

@@ -277,6 +277,7 @@ void configureGeneratorProperties() {
         // resolve inline models
         if (config.getUseInlineModelResolver()) {
             InlineModelResolver inlineModelResolver = new InlineModelResolver();
+            inlineModelResolver.setCodegen(config);
             inlineModelResolver.setInlineSchemaNameMapping(config.inlineSchemaNameMapping());
             inlineModelResolver.setInlineSchemaOptions(config.inlineSchemaOption());
 
@@ -1497,6 +1498,15 @@ public Map<String, List<CodegenOperation>> processPaths(Paths paths) {
             processOperation(resourcePath, "patch", path.getPatch(), ops, path);
             processOperation(resourcePath, "options", path.getOptions(), ops, path);
             processOperation(resourcePath, "trace", path.getTrace(), ops, path);
+            if (config.supportsAdditionalOperations()) {
+                processOperation(resourcePath, "query", path.getQuery(), ops, path);
+                if (path.getAdditionalOperations() != null) {
+                    path.getAdditionalOperations().forEach((method, operation) ->
+                            processOperation(resourcePath, method, method, operation, ops, path));
+                }
+            } else if (hasQueryOrAdditionalOperations(path)) {
+                LOGGER.warn("Path '{}' declares OpenAPI 3.2 query/additionalOperations but generator '{}' does not support them; those operations will be missing from the generated output", resourcePath, config.getName());
+            }
         }
         return ops;
     }
@@ -1518,11 +1528,29 @@ public Map<String, List<CodegenOperation>> processWebhooks(Map<String, PathItem>
             processOperation(resourceKey, "patch", path.getPatch(), ops, path);
             processOperation(resourceKey, "options", path.getOptions(), ops, path);
             processOperation(resourceKey, "trace", path.getTrace(), ops, path);
+            if (config.supportsAdditionalOperations()) {
+                processOperation(resourceKey, "query", path.getQuery(), ops, path);
+                if (path.getAdditionalOperations() != null) {
+                    path.getAdditionalOperations().forEach((method, operation) ->
+                            processOperation(resourceKey, method, method, operation, ops, path));
+                }
+            } else if (hasQueryOrAdditionalOperations(path)) {
+                LOGGER.warn("Webhook '{}' declares OpenAPI 3.2 query/additionalOperations but generator '{}' does not support them; those operations will be missing from the generated output", resourceKey, config.getName());
+            }
         }
         return ops;
     }
 
+    private boolean hasQueryOrAdditionalOperations(PathItem path) {
+        return path.getQuery() != null
+                || (path.getAdditionalOperations() != null && !path.getAdditionalOperations().isEmpty());
+    }
+
     private void processOperation(String resourcePath, String httpMethod, Operation operation, Map<String, List<CodegenOperation>> operations, PathItem path) {
+        processOperation(resourcePath, httpMethod, null, operation, operations, path);
+    }
+
+    private void processOperation(String resourcePath, String httpMethod, String wireHttpMethod, Operation operation, Map<String, List<CodegenOperation>> operations, PathItem path) {
         if (operation == null) {
             return;
         }
@@ -1533,7 +1561,7 @@ private void processOperation(String resourcePath, String httpMethod, Operation
         List<Operation> contentTypeVariants = config.divideOperationsByContentType(openAPI, resourcePath, httpMethod, operation);
         if (contentTypeVariants.size() > 1) {
             for (Operation variant : contentTypeVariants) {
-                processOperation(resourcePath, httpMethod, variant, operations, path);
+                processOperation(resourcePath, httpMethod, wireHttpMethod, variant, operations, path);
             }
             return;
         }
@@ -1604,6 +1632,11 @@ private void processOperation(String resourcePath, String httpMethod, Operation
                             httpMethod, resourcePath, operation.getOperationId());
                 } else {
                     CodegenOperation codegenOperation = config.fromOperation(resourcePath, httpMethod, operation, path.getServers());
+                    if (wireHttpMethod != null) {
+                        // OpenAPI 3.2 additionalOperations: the map key is the HTTP method
+                        // name and must be sent verbatim instead of upper-cased
+                        codegenOperation.httpMethod = wireHttpMethod;
+                    }
                     codegenOperation.tags = new ArrayList<>(tags);
                     config.addOperationToGroup(config.sanitizeTag(tag.getName()), resourcePath, operation, codegenOperation, operations);