Fix: Handle nullable oneOf schemas correctly in normalizer

Author: sshekhar563

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

@@ -963,36 +963,75 @@ protected Schema normalizeAllOfWithProperties(Schema schema, Set<Schema> visited
         return schema;
     }
 
+    protected Schema simplifyNullableOneOf(Schema schema) {
+    
+        if (schema.getOneOf() == null || schema.getOneOf().size() != 2) {
+           // Not the pattern we are looking for, so do nothing.
+           return schema;
+        }
+
+           List<Schema> subSchemas = new ArrayList<>(schema.getOneOf());
+           Schema nullSchema = null;
+           Schema mainSchema = null;
+
+          // Identify the null schema and the main schema
+        if (ModelUtils.isNullTypeSchema(openAPI, subSchemas.get(0))) {
+          nullSchema = subSchemas.get(0);
+          mainSchema = subSchemas.get(1);
+        } else if (ModelUtils.isNullTypeSchema(openAPI, subSchemas.get(1))) {
+          nullSchema = subSchemas.get(1);
+          mainSchema = subSchemas.get(0);
+        } else {
+          // Pattern does not contain a null type, so do nothing.
+         return schema;
+        }
+
+     // Clone the main schema to avoid modifying the original component
+     Schema result = ModelUtils.cloneSchema(mainSchema);
+
+     // Set nullable to true on the result
+     result.setNullable(true);
+    
+     // Copy metadata from the original container schema to the result
+     ModelUtils.copyMetadata(schema, result);
+
+     LOGGER.debug("Simplified nullable oneOf schema.");
+     return result;
+    }
+
     protected Schema normalizeOneOf(Schema schema, Set<Schema> visitedSchemas) {
         // Remove duplicate oneOf entries
         ModelUtils.deduplicateOneOfSchema(schema);
 
-        schema = processSimplifyOneOfEnum(schema);
-
-        // simplify first as the schema may no longer be a oneOf after processing the rule below
-        schema = processSimplifyOneOf(schema);
+        // Try to simplify oneOf with a nullable type first
+        schema = simplifyNullableOneOf(schema);
 
-        // if it's still a oneOf, loop through the sub-schemas
+        // if it's still a oneOf after simplification, continue with other rules
         if (schema.getOneOf() != null) {
-            for (int i = 0; i < schema.getOneOf().size(); i++) {
-                // normalize oneOf sub schemas one by one
-                Object item = schema.getOneOf().get(i);
-
+            schema = processSimplifyOneOfEnum(schema);
+                // simplify first as the schema may no longer be a oneOf after processing the rule below
+               schema = processSimplifyOneOf(schema);
+
+               if (schema.getOneOf() != null) {
+                   for (int i = 0; i < schema.getOneOf().size(); i++) {
+                   // normalize oneOf sub schemas one by one
+                   Object item = schema.getOneOf().get(i);
+                }
                 if (item == null) {
-                    continue;
+                   continue;
                 }
                 if (!(item instanceof Schema)) {
-                    throw new RuntimeException("Error! oneOf schema is not of the type Schema: " + item);
-                }
-
-                // update sub-schema with the updated schema
+                throw new RuntimeException("Error! oneOf schema is not of the type Schema: " + item);
                 schema.getOneOf().set(i, normalizeSchema((Schema) item, visitedSchemas));
             }
         } else {
-            // normalize it as it's no longer an oneOf
+            // normalize it as it's no longer a oneOf
             schema = normalizeSchema(schema, visitedSchemas);
         }
-
+        } else {
+            // It was simplified and is no longer a oneOf, so normalize it as a simple schema
+            return normalizeSchema(schema, visitedSchemas);
+        }
         return schema;
     }
 

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

@@ -1251,6 +1251,60 @@ public void testRemoveXInternalFromInlineProperties() {
         assertNotNull(inlinePropertyAfter.getProperties().get("nestedNumber"));
     }
 
+    @Test
+    public void testSimplifyNullableOneOf() {
+         // 1. Define the OpenAPI spec string that contains the bug pattern
+         final String yaml =
+                "openapi: 3.0.0\n" +
+                "info:\n" +
+                "  version: 1.0.0\n" +
+                "  title: API\n" +
+                "paths:\n" +
+                "  /test:\n" +
+                "    get:\n" +
+                "      responses:\n" +
+                "        '200':\n" +
+                "          description: OK\n" +
+                "          content:\n" +
+                "            application/json:\n" +
+                "              schema:\n" +
+                "                $ref: '#/components/schemas/Recipe'\n" +
+                "components:\n" +
+                "  schemas:\n" +
+                "    Category:\n" +
+                "      type: object\n" +
+                "      properties:\n" +
+                "        name:\n" +
+                "          type: string\n" +
+                "    Recipe:\n" +
+                "      type: object\n" +
+                "      properties:\n" +
+                "        category:\n" + // This is the property with the nullable oneOf
+                "          description: 'This should become nullable'\n" +
+                "          oneOf:\n" +
+                "            - $ref: '#/components/schemas/Category'\n" +
+                "            - type: 'null'\n";
+
+         // 2. Load the spec and run the normalizer (with default rules)
+          final OpenAPI openAPI = TestUtils.parseSpec(yaml);
+         new OpenAPINormalizer(openAPI, Collections.emptyMap()).normalize();
+
+         // 3. Get the specific schema property that should have been fixed
+         Schema recipeSchema = openAPI.getComponents().getSchemas().get("Recipe");
+         Schema categoryProperty = (Schema) recipeSchema.getProperties().get("category");
+
+         // 4. Assert that the fix worked as expected
+         assertNotNull(categoryProperty, "The category property should not be null.");
+        
+         // Key Assertions:
+         assertTrue(categoryProperty.getNullable(), "The property should be marked as nullable.");
+         assertNull(categoryProperty.getOneOf(), "The oneOf should have been removed.");
+         assertEquals(categoryProperty.get$ref(), "#/components/schemas/Category", "The $ref should be preserved.");
+        
+         // Also check that metadata was preserved
+         assertEquals(categoryProperty.getDescription(), "This should become nullable'");
+    }
+
     public static class RemoveRequiredNormalizer extends OpenAPINormalizer {
 
         public RemoveRequiredNormalizer(OpenAPI openAPI, Map<String, String> inputRules) {