Merge branch 'support/v2' into feat/null-downcasting-to-v3

Signed-off-by: Vincent Biret <vibiret@microsoft.com>

Author: baywet

CHANGELOG.md

@@ -2,7 +2,6 @@
 
 ## [3.0.3](https://github.com/microsoft/OpenAPI.NET/compare/v3.0.2...v3.0.3) (2025-12-16)
 
-
 ### Bug Fixes
 
 * load JSON documents that are preceded by multiple whitespace ([6461bac](https://github.com/microsoft/OpenAPI.NET/commit/6461bac01c4176424210e9ac249698f665a514a6))
@@ -37,6 +36,16 @@
 
 * adds support for OpenAPI 3.2.0 ([765a8dd](https://github.com/microsoft/OpenAPI.NET/commit/765a8dd4d6efd1a31b6a76d282ccffa5877a845a))
 
+## [2.3.12](https://github.com/microsoft/OpenAPI.NET/compare/v2.3.11...v2.3.12) (2025-12-15)
+
+
+### Bug Fixes
+
+* load JSON documents that are preceded by multiple whitespace ([640e59a](https://github.com/microsoft/OpenAPI.NET/commit/640e59a143a2a6d3b79c9f6a97a6029593d7dd8f))
+* non-seekable json streams would fail to load as a document ([76b0159](https://github.com/microsoft/OpenAPI.NET/commit/76b0159d12790ab00310ff107e37396ecdf13336))
+* non-seekable json streams would fail to load as a document ([2436d73](https://github.com/microsoft/OpenAPI.NET/commit/2436d7382bfbf8b9ba501d88f682e952bdf27146))
+* reading streams in an asp.net context would cause async exceptions ([f9e5248](https://github.com/microsoft/OpenAPI.NET/commit/f9e524859722476b3111cb6006f77208c2d1f526))
+
 ## [2.3.11](https://github.com/microsoft/OpenAPI.NET/compare/v2.3.10...v2.3.11) (2025-12-08)
 
 ### Bug Fixes

src/Microsoft.OpenApi/Models/OpenApiSchema.cs

@@ -443,23 +443,39 @@ private void SerializeInternal(IOpenApiWriter writer, OpenApiSpecVersion version
 
             // enum
             var enumValue = Enum is not { Count: > 0 }
-                && !string.IsNullOrEmpty(Const) 
+                && !string.IsNullOrEmpty(Const)
                 && version < OpenApiSpecVersion.OpenApi3_1
                 ? new List<JsonNode> { JsonValue.Create(Const)! }
                 : Enum;
             writer.WriteOptionalCollection(OpenApiConstants.Enum, enumValue, (nodeWriter, s) => nodeWriter.WriteAny(s));
 
+            // Handle oneOf/anyOf with null type for v3.0 downcast
+            IList<IOpenApiSchema>? effectiveOneOf = OneOf;
+            IList<IOpenApiSchema>? effectiveAnyOf = AnyOf;
+            bool hasNullInComposition = false;
+            JsonSchemaType? inferredType = null;
+
+            if (version == OpenApiSpecVersion.OpenApi3_0)
+            {
+                (effectiveOneOf, var inferredOneOf, var nullInOneOf) = ProcessCompositionForNull(OneOf);
+                hasNullInComposition |= nullInOneOf;
+                inferredType = inferredOneOf ?? inferredType;
+                (effectiveAnyOf, var inferredAnyOf, var nullInAnyOf) = ProcessCompositionForNull(AnyOf);
+                hasNullInComposition |= nullInAnyOf;
+                inferredType = inferredAnyOf ?? inferredType;
+            }
+
             // type
-            SerializeTypeProperty(writer, version);
+            SerializeTypeProperty(writer, version, inferredType);
 
             // allOf
             writer.WriteOptionalCollection(OpenApiConstants.AllOf, AllOf, callback);
 
             // anyOf
-            writer.WriteOptionalCollection(OpenApiConstants.AnyOf, AnyOf, callback);
+            writer.WriteOptionalCollection(OpenApiConstants.AnyOf, effectiveAnyOf, callback);
 
             // oneOf
-            writer.WriteOptionalCollection(OpenApiConstants.OneOf, OneOf, callback);
+            writer.WriteOptionalCollection(OpenApiConstants.OneOf, effectiveOneOf, callback);
 
             // not
             writer.WriteOptionalObject(OpenApiConstants.Not, Not, callback);
@@ -498,7 +514,7 @@ private void SerializeInternal(IOpenApiWriter writer, OpenApiSpecVersion version
             // nullable
             if (version == OpenApiSpecVersion.OpenApi3_0)
             {
-                SerializeNullable(writer, version);
+                SerializeNullable(writer, version, hasNullInComposition);
             }
 
             // discriminator
@@ -771,14 +787,17 @@ private void SerializeAsV2(
             writer.WriteEndObject();
         }
 
-        private void SerializeTypeProperty(IOpenApiWriter writer, OpenApiSpecVersion version)
+        private void SerializeTypeProperty(IOpenApiWriter writer, OpenApiSpecVersion version, JsonSchemaType? inferredType = null)
         {
-            if (Type is null)
+            // Use original type or inferred type when the explicit type is not set
+            var typeToUse = Type ?? inferredType;
+
+            if (typeToUse is null)
             {
                 return;
             }
 
-            var unifiedType = IsNullable ? Type.Value | JsonSchemaType.Null : Type.Value;
+            var unifiedType = IsNullable ? typeToUse.Value | JsonSchemaType.Null : typeToUse.Value;
             var typeWithoutNull = unifiedType & ~JsonSchemaType.Null;
 
             switch (version)
@@ -809,8 +828,8 @@ private static bool HasMultipleTypes(JsonSchemaType schemaType)
         private static void WriteUnifiedSchemaType(JsonSchemaType type, IOpenApiWriter writer)
         {
             var array = (from JsonSchemaType flag in jsonSchemaTypeValues
-                        where type.HasFlag(flag)
-                        select flag.ToFirstIdentifier()).ToArray();
+                         where type.HasFlag(flag)
+                         select flag.ToFirstIdentifier()).ToArray();
             if (array.Length > 1)
             {
                 writer.WriteOptionalCollection(OpenApiConstants.Type, array, (w, s) =>
@@ -827,9 +846,9 @@ where type.HasFlag(flag)
             }
         }
 
-        private void SerializeNullable(IOpenApiWriter writer, OpenApiSpecVersion version)
+        private void SerializeNullable(IOpenApiWriter writer, OpenApiSpecVersion version, bool hasNullInComposition = false)
         {
-            if (IsNullable)
+            if (IsNullable || hasNullInComposition)
             {
                 switch (version)
                 {
@@ -843,6 +862,41 @@ private void SerializeNullable(IOpenApiWriter writer, OpenApiSpecVersion version
             }
         }
 
+        /// <summary>
+        /// Processes a composition (oneOf or anyOf) for null types, filtering out null schemas and inferring common type.
+        /// </summary>
+        /// <param name="composition">The list of schemas in the composition.</param>
+        /// <returns>A tuple with the effective list, inferred type, and whether null is present in composition.</returns>
+        private static (IList<IOpenApiSchema>? effective, JsonSchemaType? inferredType, bool hasNullInComposition)
+            ProcessCompositionForNull(IList<IOpenApiSchema>? composition)
+        {
+            if (composition is null || !composition.Any(static s => s.Type is JsonSchemaType.Null))
+            {
+                // Nothing to patch
+                return (composition, null, false);
+            }
+
+            var nonNullSchemas = composition
+                .Where(static s => s.Type is null or not JsonSchemaType.Null)
+                .ToList();
+
+            if (nonNullSchemas.Count > 0)
+            {
+                JsonSchemaType commonType = 0;
+
+                foreach (var schema in nonNullSchemas)
+                {
+                    commonType |= schema.Type.GetValueOrDefault() & ~JsonSchemaType.Null;
+                }
+
+                return (nonNullSchemas, commonType, true);
+            }
+            else
+            {
+                return (null, null, true);
+            }
+        }
+
 #if NET5_0_OR_GREATER
         private static readonly Array jsonSchemaTypeValues = System.Enum.GetValues<JsonSchemaType>();
 #else