Merge remote-tracking branch 'upstream/master' into remove-barrel-imports

Author: celluj34

docs/customization.md

@@ -723,3 +723,10 @@ Into this securityScheme:
       scheme: bearer
       type: http
 ```
+
+- `SORT_MODEL_PROPERTIES`: When set to true, model properties will be sorted alphabetically by name. This ensures deterministic code generation output regardless of property ordering in the source spec.
+
+Example:
+```
+java -jar modules/openapi-generator-cli/target/openapi-generator-cli.jar generate -g java -i modules/openapi-generator/src/test/resources/3_0/petstore.yaml -o /tmp/java-okhttp/ --openapi-normalizer SORT_MODEL_PROPERTIES=true
+```

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

@@ -151,6 +151,9 @@ public class OpenAPINormalizer {
     boolean updateNumberToNullable;
     boolean updateBooleanToNullable;
 
+    // when set to true, sort model properties by name to ensure deterministic output
+    final String SORT_MODEL_PROPERTIES = "SORT_MODEL_PROPERTIES";
+
     // ============= end of rules =============
 
     /**
@@ -209,6 +212,7 @@ public OpenAPINormalizer(OpenAPI openAPI, Map<String, String> inputRules) {
         ruleNames.add(SET_PRIMITIVE_TYPES_TO_NULLABLE);
         ruleNames.add(SIMPLIFY_ONEOF_ANYOF_ENUM);
         ruleNames.add(REMOVE_PROPERTIES_FROM_TYPE_OTHER_THAN_OBJECT);
+        ruleNames.add(SORT_MODEL_PROPERTIES);
 
         // rules that are default to true
         rules.put(SIMPLIFY_ONEOF_ANYOF, true);
@@ -768,7 +772,7 @@ public Schema normalizeSchema(Schema schema, Set<Schema> visitedSchemas) {
             }
 
             if (schema.getProperties() != null && !schema.getProperties().isEmpty()) {
-                normalizeProperties(schema.getProperties(), visitedSchemas);
+                normalizeProperties(schema, visitedSchemas);
             }
 
             if (schema.getAdditionalProperties() != null) {
@@ -777,7 +781,7 @@ public Schema normalizeSchema(Schema schema, Set<Schema> visitedSchemas) {
 
             return schema;
         } else if (schema.getProperties() != null && !schema.getProperties().isEmpty()) {
-            normalizeProperties(schema.getProperties(), visitedSchemas);
+            normalizeProperties(schema, visitedSchemas);
         } else if (schema.getAdditionalProperties() instanceof Schema) { // map
             normalizeMapSchema(schema);
             normalizeSchema((Schema) schema.getAdditionalProperties(), visitedSchemas);
@@ -880,10 +884,19 @@ protected void normalizeIntegerSchema(Schema schema, Set<Schema> visitedSchemas)
         processSetPrimitiveTypesToNullable(schema);
     }
 
-    protected void normalizeProperties(Map<String, Schema> properties, Set<Schema> visitedSchemas) {
+    protected void normalizeProperties(Schema schema, Set<Schema> visitedSchemas) {
+        Map<String, Schema> properties = schema.getProperties();
         if (properties == null) {
             return;
         }
+
+        // Sort properties by name if rule is enabled
+        if (getRule(SORT_MODEL_PROPERTIES)) {
+            Map<String, Schema> sortedProperties = new TreeMap<>(properties);
+            schema.setProperties(sortedProperties);
+            properties = sortedProperties;
+        }
+
         for (Map.Entry<String, Schema> propertiesEntry : properties.entrySet()) {
             Schema property = propertiesEntry.getValue();
 
@@ -1089,7 +1102,7 @@ protected Schema normalizeAnyOf(Schema schema, Set<Schema> visitedSchemas) {
     protected Schema normalizeComplexComposedSchema(Schema schema, Set<Schema> visitedSchemas) {
         // loop through properties, if any
         if (schema.getProperties() != null && !schema.getProperties().isEmpty()) {
-            normalizeProperties(schema.getProperties(), visitedSchemas);
+            normalizeProperties(schema, visitedSchemas);
         }
 
         processRemoveAnyOfOneOfAndKeepPropertiesOnly(schema);

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

@@ -601,17 +601,25 @@ public String toOperationId(String operationId) {
     public ModelsMap postProcessModels(ModelsMap objs) {
         for (ModelMap mo : objs.getModels()) {
             CodegenModel cm = mo.getModel();
+            boolean needsExtractSimpleType = false;
             for (CodegenProperty var : cm.vars) {
                 // check to see if base name is an empty string
                 if ("".equals(var.baseName)) {
                     LOGGER.debug("Empty baseName `` (empty string) in the model `{}` has been renamed to `empty_string` to avoid compilation errors.", cm.classname);
                     var.baseName = "empty_string";
                 }
 
+                if (!var.isPrimitiveType) {
+                    needsExtractSimpleType = true;
+                }
+
                 // create extension x-r-doc-type to store the data type in r doc format
                 var.vendorExtensions.put("x-r-doc-type", constructRdocType(var));
             }
 
+            // create extension x-r-has-non-primitive-field to indicate whether generated models need special handling for complex types
+            cm.vendorExtensions.put("x-r-has-non-primitive-field", needsExtractSimpleType);
+
             // apply the same fix, enhancement for allVars
             for (CodegenProperty var : cm.allVars) {
                 // check to see if base name is an empty string

modules/openapi-generator/src/main/resources/JavaJaxRS/spec/enumOuterClass.mustache

@@ -6,6 +6,8 @@ import com.fasterxml.jackson.annotation.JsonValue;
 /**
  * {{description}}{{^description}}Gets or Sets {{{name}}}{{/description}}
  */
+{{>generatedAnnotation}}
+
 {{>additionalEnumTypeAnnotations}}public enum {{{datatypeWithEnum}}}{{^datatypeWithEnum}}{{{classname}}}{{/datatypeWithEnum}} {
   {{#gson}}
   {{#allowableValues}}{{#enumVars}}

modules/openapi-generator/src/main/resources/r/modelGeneric.mustache

@@ -242,15 +242,15 @@
           self$`{{name}}`
           {{/isPrimitiveType}}
           {{^isPrimitiveType}}
-          lapply(self$`{{name}}`, function(x) x$toSimpleType())
+          self$extractSimpleType(self$`{{name}}`)
           {{/isPrimitiveType}}
           {{/isArray}}
           {{#isMap}}
           {{#isPrimitiveType}}
           self$`{{name}}`
           {{/isPrimitiveType}}
           {{^isPrimitiveType}}
-          lapply(self$`{{name}}`, function(x) x$toSimpleType())
+          self$extractSimpleType(self$`{{name}}`)
           {{/isPrimitiveType}}
           {{/isMap}}
           {{/isContainer}}
@@ -259,7 +259,7 @@
           self$`{{name}}`
           {{/isPrimitiveType}}
           {{^isPrimitiveType}}
-          self$`{{name}}`$toSimpleType()
+          self$extractSimpleType(self$`{{name}}`)
           {{/isPrimitiveType}}
           {{/isContainer}}
       }
@@ -272,6 +272,31 @@
       {{/isAdditionalPropertiesTrue}}
       return({{classname}}Object)
     },
+    {{#vendorExtensions.x-r-has-non-primitive-field}}
+
+    extractSimpleType = function(x) {
+      if (R6::is.R6(x)) {
+        return(x$toSimpleType())
+      } else if (!self$hasNestedR6(x)) {
+        return(x)
+      }
+      lapply(x, self$extractSimpleType)
+    },
+
+    hasNestedR6 = function(x) {
+      if (R6::is.R6(x)) {
+        return(TRUE)
+      }
+      if (is.list(x)) {
+        for (item in x) {
+          if (self$hasNestedR6(item)) {
+            return(TRUE)
+          }
+        }
+      }
+      FALSE
+    },
+    {{/vendorExtensions.x-r-has-non-primitive-field}}
 
     #' @description
     #' Deserialize JSON string into an instance of {{{classname}}}

modules/openapi-generator/src/test/java/org/openapitools/codegen/OpenAPINormalizerTest.java

@@ -1306,6 +1306,59 @@ public void testRemoveXInternalFromInlineProperties() {
         assertNotNull(inlinePropertyAfter.getProperties().get("nestedNumber"));
     }
 
+    @Test
+    public void testSortModelProperties() {
+        // Create a schema with properties in non-alphabetical order
+        Schema schema = new ObjectSchema()
+                .addProperty("zebra", new StringSchema())
+                .addProperty("apple", new StringSchema())
+                .addProperty("mango", new IntegerSchema());
+
+        OpenAPI openAPI = TestUtils.createOpenAPIWithOneSchema("TestModel", schema);
+
+        // Verify original order (LinkedHashMap preserves insertion order)
+        List<String> originalOrder = new ArrayList<>(schema.getProperties().keySet());
+        assertEquals(originalOrder.get(0), "zebra");
+        assertEquals(originalOrder.get(1), "apple");
+        assertEquals(originalOrder.get(2), "mango");
+
+        // Apply normalizer with SORT_MODEL_PROPERTIES=true
+        Map<String, String> options = new HashMap<>();
+        options.put("SORT_MODEL_PROPERTIES", "true");
+        OpenAPINormalizer openAPINormalizer = new OpenAPINormalizer(openAPI, options);
+        openAPINormalizer.normalize();
+
+        // Verify properties are now sorted alphabetically
+        Schema normalizedSchema = openAPI.getComponents().getSchemas().get("TestModel");
+        List<String> sortedOrder = new ArrayList<>(normalizedSchema.getProperties().keySet());
+        assertEquals(sortedOrder.get(0), "apple");
+        assertEquals(sortedOrder.get(1), "mango");
+        assertEquals(sortedOrder.get(2), "zebra");
+    }
+
+    @Test
+    public void testSortModelPropertiesDisabledByDefault() {
+        // Create a schema with properties in non-alphabetical order
+        Schema schema = new ObjectSchema()
+                .addProperty("zebra", new StringSchema())
+                .addProperty("apple", new StringSchema())
+                .addProperty("mango", new IntegerSchema());
+
+        OpenAPI openAPI = TestUtils.createOpenAPIWithOneSchema("TestModel", schema);
+
+        // Apply normalizer without SORT_MODEL_PROPERTIES (default is false)
+        Map<String, String> options = new HashMap<>();
+        OpenAPINormalizer openAPINormalizer = new OpenAPINormalizer(openAPI, options);
+        openAPINormalizer.normalize();
+
+        // Verify properties retain original order
+        Schema normalizedSchema = openAPI.getComponents().getSchemas().get("TestModel");
+        List<String> order = new ArrayList<>(normalizedSchema.getProperties().keySet());
+        assertEquals(order.get(0), "zebra");
+        assertEquals(order.get(1), "apple");
+        assertEquals(order.get(2), "mango");
+    }
+
     public static class RemoveRequiredNormalizer extends OpenAPINormalizer {
 
         public RemoveRequiredNormalizer(OpenAPI openAPI, Map<String, String> inputRules) {

samples/client/echo_api/r/R/default_value.R

@@ -119,7 +119,7 @@ DefaultValue <- R6::R6Class(
       DefaultValueObject <- list()
       if (!is.null(self$`array_string_enum_ref_default`)) {
         DefaultValueObject[["array_string_enum_ref_default"]] <-
-          lapply(self$`array_string_enum_ref_default`, function(x) x$toSimpleType())
+          self$extractSimpleType(self$`array_string_enum_ref_default`)
       }
       if (!is.null(self$`array_string_enum_default`)) {
         DefaultValueObject[["array_string_enum_default"]] <-
@@ -152,6 +152,29 @@ DefaultValue <- R6::R6Class(
       return(DefaultValueObject)
     },
 
+    extractSimpleType = function(x) {
+      if (R6::is.R6(x)) {
+        return(x$toSimpleType())
+      } else if (!self$hasNestedR6(x)) {
+        return(x)
+      }
+      lapply(x, self$extractSimpleType)
+    },
+
+    hasNestedR6 = function(x) {
+      if (R6::is.R6(x)) {
+        return(TRUE)
+      }
+      if (is.list(x)) {
+        for (item in x) {
+          if (self$hasNestedR6(item)) {
+            return(TRUE)
+          }
+        }
+      }
+      FALSE
+    },
+
     #' @description
     #' Deserialize JSON string into an instance of DefaultValue
     #'

samples/client/echo_api/r/R/pet.R

@@ -115,15 +115,15 @@ Pet <- R6::R6Class(
       }
       if (!is.null(self$`category`)) {
         PetObject[["category"]] <-
-          self$`category`$toSimpleType()
+          self$extractSimpleType(self$`category`)
       }
       if (!is.null(self$`photoUrls`)) {
         PetObject[["photoUrls"]] <-
           self$`photoUrls`
       }
       if (!is.null(self$`tags`)) {
         PetObject[["tags"]] <-
-          lapply(self$`tags`, function(x) x$toSimpleType())
+          self$extractSimpleType(self$`tags`)
       }
       if (!is.null(self$`status`)) {
         PetObject[["status"]] <-
@@ -132,6 +132,29 @@ Pet <- R6::R6Class(
       return(PetObject)
     },
 
+    extractSimpleType = function(x) {
+      if (R6::is.R6(x)) {
+        return(x$toSimpleType())
+      } else if (!self$hasNestedR6(x)) {
+        return(x)
+      }
+      lapply(x, self$extractSimpleType)
+    },
+
+    hasNestedR6 = function(x) {
+      if (R6::is.R6(x)) {
+        return(TRUE)
+      }
+      if (is.list(x)) {
+        for (item in x) {
+          if (self$hasNestedR6(item)) {
+            return(TRUE)
+          }
+        }
+      }
+      FALSE
+    },
+
     #' @description
     #' Deserialize JSON string into an instance of Pet
     #'