fix(normalizer): simplify oneOf/anyOf with a single inline const/enum sub-schema

Previously EnumUtils.simplifyComposedSchemaWithEnums bailed out whenever a
oneOf/anyOf had fewer than 2 sub-schemas, regardless of whether the lone
sub-schema was a named \ (which should be preserved) or an inline
const/enum literal (e.g. oneOf: [{const: FIAttached}]).

For the inline case, the schema fell through to
simplifyOneOfAnyOfWithOnlyOneNonNullSubSchema, which collapses to the
sub-schema but does not convert const to enum and drops the parent's
type/default/extensions, producing a plain string field instead of a
generated enum (e.g. in C# generichost/netcore templates).

Only skip simplification now when the sole sub-schema is a \, preserving
reusable named enum schemas while correctly simplifying single-value inline
const/enum oneOf/anyOf schemas.

Author: nagabalaji-b

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

@@ -118,11 +118,20 @@ public static Schema simplifyComposedSchemaWithEnums(Schema schema,
             return schema;
         }
 
-        if (subSchemas.size() < 2) {
-            //do not process if there's less than 2 sub-schemas. It will be normalized later, and this prevents
-            //named enum schemas from being converted to inline enum schemas
+        if (subSchemas.isEmpty()) {
             return schema;
         }
+
+        if (subSchemas.size() == 1) {
+            Object onlySubSchema = subSchemas.get(0);
+            // A lone $ref to a named schema is left as-is (it will be normalized later); this
+            // prevents named enum schemas from being converted to inline enum schemas. An inline
+            // const/enum sub-schema (e.g. `oneOf: [{const: foo}]`), however, is processed below so
+            // that single-value enums are simplified the same way as multi-value ones.
+            if (!(onlySubSchema instanceof Schema) || ((Schema) onlySubSchema).get$ref() != null) {
+                return schema;
+            }
+        }
         String schemaType = ModelUtils.getType(schema);
 
         for (Object item : subSchemas) {

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

@@ -1725,6 +1725,30 @@ public void testOpenAPINormalizerSingleConstEnum31Spec() {
         assertEquals(Arrays.asList(originalConst), normalizedTypeSchema.getEnum());
     }
 
+    @Test
+    public void testOpenAPINormalizerSingleOneOfConstEnum31Spec() {
+        // reproduces https://github.com/OpenAPITools/openapi-generator/issues/ where a `oneOf` wrapping
+        // a single `const` sub-schema (as opposed to 2+ consts) was not simplified into a proper enum,
+        // and lost the parent's `type`/`default`/`x-omitempty` in the process.
+        OpenAPI openAPI = TestUtils.parseSpec("src/test/resources/3_1/enum-single-value.yaml");
+
+        Schema schema = openAPI.getComponents().getSchemas().get("SingleValueOneOfConst_3_1");
+        Schema originalTypeSchema = (Schema) schema.getProperties().get("type");
+        assertEquals(originalTypeSchema.getOneOf().size(), 1);
+
+        OpenAPINormalizer openAPINormalizer = new OpenAPINormalizer(openAPI, Map.of());
+        openAPINormalizer.normalize();
+
+        Schema schema2 = openAPI.getComponents().getSchemas().get("SingleValueOneOfConst_3_1");
+        Schema normalizedTypeSchema = (Schema) schema2.getProperties().get("type");
+        assertTrue(ModelUtils.isEnumSchema(normalizedTypeSchema));
+        assertNull(normalizedTypeSchema.getOneOf());
+        assertEquals(normalizedTypeSchema.getEnum(), List.of("this-is-my-only-value"));
+        assertEquals(ModelUtils.getType(normalizedTypeSchema), "string");
+        assertEquals(normalizedTypeSchema.getDefault(), "this-is-my-only-value");
+        assertEquals(normalizedTypeSchema.getExtensions().get("x-omitempty"), true);
+    }
+
     @Test
     public void testOpenAPINormalizerProcessingAllOfSchema31Spec() {
         // to test array schema processing in 3.1 spec

modules/openapi-generator/src/test/resources/3_1/enum-single-value.yaml

@@ -17,4 +17,15 @@ components:
         properties:
           type:
             enum:
-              - this-is-my-only-value
+              - this-is-my-only-value
+      SingleValueOneOfConst_3_1:
+        required:
+          - type
+        properties:
+          type:
+            type: string
+            default: this-is-my-only-value
+            x-omitempty: true
+            oneOf:
+              - const: this-is-my-only-value
+                description: the only allowed value