OpenAPI: Prune null from enum/type in componentized schemas

Improve handling of nullable enums and componentized types in OpenAPI schema generation.
- Remove "null" from type/enum arrays and use nullable/oneOf for nullability.
- Add tests to verify correct schema references and nullability for parameters and request bodies.

Author: desjoerd

src/OpenApi/src/Extensions/JsonNodeSchemaExtensions.cs

@@ -507,19 +507,29 @@ internal static void ApplyNullabilityContextInfo(this JsonNode schema, JsonPrope
     /// <param name="schema">The <see cref="JsonNode"/> produced by the underlying schema generator.</param>
     internal static void PruneNullTypeForComponentizedTypes(this JsonNode schema)
     {
-        if (schema.WillBeComponentized() &&
-                schema[OpenApiSchemaKeywords.TypeKeyword] is JsonArray typeArray)
+        if (schema.WillBeComponentized())
         {
-            for (var i = typeArray.Count - 1; i >= 0; i--)
+            if (schema[OpenApiSchemaKeywords.TypeKeyword] is JsonArray typeArray)
             {
-                if (typeArray[i]?.GetValue<string>() == "null")
+                for (var i = typeArray.Count - 1; i >= 0; i--)
                 {
-                    typeArray.RemoveAt(i);
+                    if (typeArray[i]?.GetValue<string>() == "null")
+                    {
+                        typeArray.RemoveAt(i);
+                    }
+                }
+                if (typeArray.Count == 1)
+                {
+                    schema[OpenApiSchemaKeywords.TypeKeyword] = typeArray[0]?.GetValue<string>();
                 }
             }
-            if (typeArray.Count == 1)
+            else if (schema[OpenApiSchemaKeywords.EnumKeyword] is JsonArray enumArray)
             {
-                schema[OpenApiSchemaKeywords.TypeKeyword] = typeArray[0]?.GetValue<string>();
+                var hasRemovedNull = enumArray.Remove(null);
+                if (hasRemovedNull)
+                {
+                    schema[OpenApiConstants.NullableProperty] = true;
+                }
             }
         }
     }

src/OpenApi/test/Microsoft.AspNetCore.OpenApi.Tests/Services/OpenApiSchemaService/OpenApiSchemaService.ParameterSchemas.cs

@@ -977,6 +977,38 @@ await VerifyOpenApiDocument(builder, document =>
         });
     }
 
+    [Fact]
+    public async Task GetOpenApiParameters_DoesNotGenerateNullComponetizedSchemaAsNullableParametersAreOptional()
+    {
+        // Arrange
+        var builder1 = CreateBuilder();
+        builder1.MapGet("/query", (Status status, Status? optionalStatus) => "TEST");
+
+        var builder2 = CreateBuilder();
+        builder2.MapGet("/query", (Status? optionalStatus, Status status) => "TEST");
+
+        // Assert
+        await VerifyOpenApiDocument(builder1, VerifyNonNullComponetizedSchema);
+        await VerifyOpenApiDocument(builder2, VerifyNonNullComponetizedSchema);
+
+        static void VerifyNonNullComponetizedSchema(OpenApiDocument doc)
+        {
+            var schema = doc.Components.Schemas["Status"];
+            Assert.DoesNotContain(schema.Enum, node => node is null);
+            Assert.Equal(3, schema.Enum.Count);
+
+            var operation = doc.Paths["/query"].Operations[HttpMethod.Get];
+
+            Assert.Equal(2, operation.Parameters.Count);
+            var nullableParam = operation.Parameters.First(p => p.Name == "optionalStatus");
+            Assert.Equal("Status", ((OpenApiSchemaReference)nullableParam.Schema).Reference.Id);
+
+            var notNullableParam = operation.Parameters.First(p => p.Name == "status");
+            var notNullableSchemaReference = Assert.IsType<OpenApiSchemaReference>(notNullableParam.Schema);
+            Assert.Equal("Status", notNullableSchemaReference.Reference.Id);
+        }
+    }
+
     [ApiController]
     [Route("[controller]/[action]")]
     private class TestFromQueryController : ControllerBase

src/OpenApi/test/Microsoft.AspNetCore.OpenApi.Tests/Services/OpenApiSchemaService/OpenApiSchemaService.RequestBodySchemas.cs

@@ -999,4 +999,39 @@ internal Status FormPostWithOptionalEnumParam(
             [FromForm(Name = "status")] Status status = Status.Approved
         ) => status;
     }
+
+    [Fact]
+    private async Task HandlesNullableEnumWithOneOf()
+    {
+        var builder = CreateBuilder();
+
+        builder.MapPost("/nullableEnum", (NullableEnumDto body) => { });
+
+        await VerifyOpenApiDocument(builder, (document) =>
+        {
+            var enumDtoSchema = document.Components.Schemas["NullableEnumDto"];
+
+            var statusPropertySchema = enumDtoSchema.Properties["status"];
+            Assert.Collection(statusPropertySchema.OneOf,
+                item =>
+                {
+                    Assert.NotNull(item);
+                    Assert.Equal(JsonSchemaType.Null, item.Type);
+                },
+                item =>
+                {
+                    Assert.NotNull(item);
+                    Assert.Equal("Status", ((OpenApiSchemaReference)item).Reference.Id);
+                });
+
+            var statusEnumSchema = document.Components.Schemas["Status"];
+            Assert.Equal(3, statusEnumSchema.Enum.Count);
+            Assert.DoesNotContain(null, statusEnumSchema.Enum);
+        });
+    }
+
+    internal class NullableEnumDto
+    {
+        public Status? Status { get; set; }
+    }
 }