[fix] Apply REMOVE_X_INTERNAL normalizer to nested inline properties (#22097)

* fix: Apply REMOVE_X_INTERNAL normalizer to nested inline properties

When REMOVE_X_INTERNAL=true is set, the normalizer removes the x-internal
extension from top-level schemas in components/schemas but fails to remove
it from inline object properties within those schemas.

This causes issues when:
1. A schema is imported cross-file (e.g., admin.yaml imports from chat.yaml)
2. That schema has an inline object property with x-internal: true
3. The inline property has type: object with nested properties

Result: TypeScript generator creates a type reference but no interface
definition, causing compilation errors.

This fix applies the same x-internal removal logic to normalizeProperties()
that already exists in normalizeComponentsSchemas(), ensuring inline
properties are handled consistently.

Fixes behavior for inline schemas with x-internal in cross-file imports.

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

Co-authored-by: Copilot <[email protected]>

* test: Add test case for REMOVE_X_INTERNAL with inline properties

Adds test to verify that REMOVE_X_INTERNAL normalizer correctly removes
x-internal extension from inline object properties, not just top-level schemas.

* Apply suggestion from @Copilot

Co-authored-by: Copilot <[email protected]>

* Revert "Apply suggestion from @Copilot"

This reverts commit c899e9e.

---------

Co-authored-by: Copilot <[email protected]>

Author: rc-glean

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

@@ -855,6 +855,20 @@ protected void normalizeProperties(Map<String, Schema> properties, Set<Schema> v
         }
         for (Map.Entry<String, Schema> propertiesEntry : properties.entrySet()) {
             Schema property = propertiesEntry.getValue();
+            
+            // remove x-internal if needed (same logic as normalizeComponentsSchemas)
+            if (property.getExtensions() != null && getRule(REMOVE_X_INTERNAL)) {
+                Object xInternalValue = property.getExtensions().get(X_INTERNAL);
+                boolean isInternal = false;
+                if (xInternalValue instanceof Boolean) {
+                    isInternal = (Boolean) xInternalValue;
+                } else if (xInternalValue instanceof String) {
+                    isInternal = Boolean.parseBoolean((String) xInternalValue);
+                }
+                if (isInternal) {
+                    property.getExtensions().remove(X_INTERNAL);
+                }
+            }
             Schema newProperty = normalizeSchema(property, new HashSet<>());
             propertiesEntry.setValue(newProperty);
         }

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

@@ -1153,6 +1153,42 @@ public void testNormalizerClass() {
         assertEquals(requiredProperties.getRequired(), null);
     }
 
+
+    @Test
+    public void testRemoveXInternalFromInlineProperties() {
+        OpenAPI openAPI = TestUtils.parseSpec("src/test/resources/3_0/inline_x_internal_test.yaml");
+        Schema parentSchema = openAPI.getComponents().getSchemas().get("ParentSchema");
+        Schema inlineProperty = (Schema) parentSchema.getProperties().get("inlineXInternalProperty");
+        
+        // Before normalization: x-internal should be present on inline property
+        assertNotNull(inlineProperty.getExtensions());
+        assertEquals(inlineProperty.getExtensions().get("x-internal"), true);
+        
+        // Run normalizer with REMOVE_X_INTERNAL=true
+        Map<String, String> options = new HashMap<>();
+        options.put("REMOVE_X_INTERNAL", "true");
+        OpenAPINormalizer openAPINormalizer = new OpenAPINormalizer(openAPI, options);
+        openAPINormalizer.normalize();
+        
+        // After normalization: x-internal should be removed from inline property
+        Schema parentSchemaAfter = openAPI.getComponents().getSchemas().get("ParentSchema");
+        Schema inlinePropertyAfter = (Schema) parentSchemaAfter.getProperties().get("inlineXInternalProperty");
+        
+        // x-internal extension should be removed (null or not present in map)
+        if (inlinePropertyAfter.getExtensions() != null) {
+            assertNull(inlinePropertyAfter.getExtensions().get("x-internal"));
+        }
+        
+        // The property itself should still exist (we're removing the flag, not the property)
+        assertNotNull(inlinePropertyAfter);
+        assertEquals(inlinePropertyAfter.getType(), "object");
+        
+        // Nested properties should still exist
+        assertNotNull(inlinePropertyAfter.getProperties());
+        assertNotNull(inlinePropertyAfter.getProperties().get("nestedField"));
+        assertNotNull(inlinePropertyAfter.getProperties().get("nestedNumber"));
+    }
+
     public static class RemoveRequiredNormalizer extends OpenAPINormalizer {
 
         public RemoveRequiredNormalizer(OpenAPI openAPI, Map<String, String> inputRules) {

modules/openapi-generator/src/test/resources/3_0/inline_x_internal_test.yaml

@@ -0,0 +1,24 @@
+openapi: 3.0.0
+info:
+  version: 1.0.0
+  title: Test inline x-internal
+components:
+  schemas:
+    ParentSchema:
+      description: Schema with inline x-internal property
+      type: object
+      properties:
+        normalProperty:
+          type: string
+          description: A normal property without x-internal
+        inlineXInternalProperty:
+          x-internal: true
+          description: Inline object property marked as x-internal
+          type: object
+          properties:
+            nestedField:
+              type: string
+              description: A field inside the inline x-internal object
+            nestedNumber:
+              type: integer
+              description: Another field inside the inline object