fix: refactor ToIdentifier() to normalize flaggable enums

src/Microsoft.OpenApi/Extensions/OpenApiTypeMapper.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Microsoft.OpenApi.Exceptions;
 using Microsoft.OpenApi.Models;
 
@@ -19,7 +20,7 @@
         /// </summary>
         /// <param name="schemaType"></param>
         /// <returns></returns>
-        public static string? ToIdentifier(this JsonSchemaType? schemaType)
+        public static string[]? ToIdentifier(this JsonSchemaType? schemaType)
         {
             if (schemaType is null)
             {
@@ -33,20 +34,32 @@
         /// </summary>
         /// <param name="schemaType"></param>
         /// <returns></returns>
-        public static string? ToIdentifier(this JsonSchemaType schemaType)
+        public static string[] ToIdentifier(this JsonSchemaType schemaType)
         {
-            return schemaType switch
-            {
-                JsonSchemaType.Null => "null",
-                JsonSchemaType.Boolean => "boolean",
-                JsonSchemaType.Integer => "integer",
-                JsonSchemaType.Number => "number",
-                JsonSchemaType.String => "string",
-                JsonSchemaType.Array => "array",
-                JsonSchemaType.Object => "object",
-                _ => null,
-            };
+            var types = new List<string>();
+
+            if (schemaType.HasFlag(JsonSchemaType.Boolean)) types.Add("boolean");
+            if (schemaType.HasFlag(JsonSchemaType.Integer)) types.Add("integer");
+            if (schemaType.HasFlag(JsonSchemaType.Number)) types.Add("number");
+            if (schemaType.HasFlag(JsonSchemaType.String)) types.Add("string");
+            if (schemaType.HasFlag(JsonSchemaType.Object)) types.Add("object");
+            if (schemaType.HasFlag(JsonSchemaType.Array)) types.Add("array");
+            if (schemaType.HasFlag(JsonSchemaType.Null)) types.Add("null");
+
+            return types.ToArray();
         }
+
+        /// <summary>
+        /// Returns the first identifier from a string array.
+        /// </summary>
+        /// <param name="schemaType"></param>
+        /// <returns></returns>
+        internal static string FirstIdentifier(this JsonSchemaType schemaType)
+        {
+            var identifier = schemaType.ToIdentifier();
+            return identifier[0];
+        }
+
 #nullable restore
 
         /// <summary>
@@ -61,7 +74,7 @@
                 "null" => JsonSchemaType.Null,
                 "boolean" => JsonSchemaType.Boolean,
                 "integer" or "int" => JsonSchemaType.Integer,
                 "number" or "double" or "float" or "decimal"=> JsonSchemaType.Number,
                 "string" => JsonSchemaType.String,
                 "array" => JsonSchemaType.Array,
                 "object" => JsonSchemaType.Object,
@@ -70,18 +83,38 @@
             };
         }
 
+        /// <summary>
+        /// Converts a schema type's identifier into the enum equivalent
+        /// </summary>
+        /// <param name="identifier"></param>
+        /// <returns></returns>
+        public static JsonSchemaType? ToJsonSchemaType(this string[] identifier)
+        {
+            if (identifier == null)
+            {
+                return null;
+            }
+
+            JsonSchemaType type = 0;
+            foreach (var id in identifier)
+            {
+                type |= id.ToJsonSchemaType();
+            }
+            return type;
+        }
+
         private static readonly Dictionary<Type, Func<OpenApiSchema>> _simpleTypeToOpenApiSchema = new()
         {
             [typeof(bool)] = () => new() { Type = JsonSchemaType.Boolean },
             [typeof(byte)] = () => new() { Type = JsonSchemaType.String, Format = "byte" },
             [typeof(int)] = () => new() { Type = JsonSchemaType.Integer, Format = "int32" },
             [typeof(uint)] = () => new() { Type = JsonSchemaType.Integer, Format = "int32" },
             [typeof(long)] = () => new() { Type = JsonSchemaType.Integer, Format = "int64" },
             [typeof(ulong)] = () => new() { Type = JsonSchemaType.Integer, Format = "int64" },
             [typeof(float)] = () => new() { Type = JsonSchemaType.Number, Format = "float" },
             [typeof(double)] = () => new() { Type = JsonSchemaType.Number, Format = "double" },
             [typeof(decimal)] = () => new() { Type = JsonSchemaType.Number, Format = "double" },
             [typeof(DateTime)] = () => new() { Type = JsonSchemaType.String, Format = "date-time" },
             [typeof(DateTimeOffset)] = () => new() { Type = JsonSchemaType.String, Format = "date-time" },
             [typeof(Guid)] = () => new() { Type = JsonSchemaType.String, Format = "uuid" },
             [typeof(char)] = () => new() { Type = JsonSchemaType.String },
@@ -141,7 +174,7 @@
         }
 
         /// <summary>
-        /// Maps an JsonSchema data type and format to a simple type.
+        /// Maps a JsonSchema data type and format to a simple type.
         /// </summary>
         /// <param name="schema">The OpenApi data type</param>
         /// <returns>The simple type</returns>
@@ -152,21 +185,23 @@
             {
                 throw new ArgumentNullException(nameof(schema));
             }
+            var isNullable = (schema.Type & JsonSchemaType.Null) == JsonSchemaType.Null;
+            var nonNullable = (schema.Type & ~JsonSchemaType.Null)?.FirstIdentifier();
 
-            var type = ((schema.Type & ~JsonSchemaType.Null).ToIdentifier(), schema.Format?.ToLowerInvariant(), schema.Type & JsonSchemaType.Null) switch
+            var type = (nonNullable, schema.Format?.ToLowerInvariant(), isNullable) switch
             {
-                ("integer" or "number", "int32", JsonSchemaType.Null) => typeof(int?),
-                ("integer" or "number", "int64", JsonSchemaType.Null) => typeof(long?),
-                ("integer", null, JsonSchemaType.Null) => typeof(long?),
-                ("number", "float", JsonSchemaType.Null) => typeof(float?),
-                ("number", "double", JsonSchemaType.Null) => typeof(double?),
-                ("number", null, JsonSchemaType.Null) => typeof(double?),
-                ("number", "decimal", JsonSchemaType.Null) => typeof(decimal?),
-                ("string", "byte", JsonSchemaType.Null) => typeof(byte?),
-                ("string", "date-time", JsonSchemaType.Null) => typeof(DateTimeOffset?),
-                ("string", "uuid", JsonSchemaType.Null) => typeof(Guid?),
-                ("string", "char", JsonSchemaType.Null) => typeof(char?),
-                ("boolean", null, JsonSchemaType.Null) => typeof(bool?),
+                ("integer" or "number", "int32", true) => typeof(int?),
+                ("integer" or "number", "int64", true) => typeof(long?),
+                ("integer", null, true) => typeof(long?),
+                ("number", "float", true) => typeof(float?),
+                ("number", "double", true) => typeof(double?),
+                ("number", null, true) => typeof(double?),
+                ("number", "decimal", true) => typeof(decimal?),
+                ("string", "byte", true) => typeof(byte?),
+                ("string", "date-time", true) => typeof(DateTimeOffset?),
+                ("string", "uuid", true) => typeof(Guid?),
+                ("string", "char", true) => typeof(char?),
+                ("boolean", null, true) => typeof(bool?),
                 ("boolean", null, _) => typeof(bool),
                 // integer is technically not valid with format, but we must provide some compatibility
                 ("integer" or "number", "int32", _) => typeof(int),

src/Microsoft.OpenApi/Models/OpenApiSchema.cs

@@ -413,7 +413,7 @@ internal void WriteJsonSchemaKeywords(IOpenApiWriter writer)
         internal void WriteAsItemsProperties(IOpenApiWriter writer)
         {
             // type
-            writer.WriteProperty(OpenApiConstants.Type, (Type & ~JsonSchemaType.Null).ToIdentifier());
+            writer.WriteProperty(OpenApiConstants.Type, (Type & ~JsonSchemaType.Null)?.FirstIdentifier());
 
             // format
             WriteFormatProperty(writer);
@@ -629,10 +629,10 @@ private void SerializeAsV2(
         private void SerializeTypeProperty(JsonSchemaType? type, IOpenApiWriter writer, OpenApiSpecVersion version)
         {
             // check whether nullable is true for upcasting purposes
-            var isNullable = (Type.HasValue && Type.Value.HasFlag(JsonSchemaType.Null))  ||
+            var isNullable = (Type.HasValue && Type.Value.HasFlag(JsonSchemaType.Null)) ||
                                 Extensions is not null &&
                                 Extensions.TryGetValue(OpenApiConstants.NullableExtension, out var nullExtRawValue) && 
-                                nullExtRawValue is OpenApiAny { Node: JsonNode jsonNode} &&
+                                nullExtRawValue is OpenApiAny { Node: JsonNode jsonNode } &&
                                 jsonNode.GetValueKind() is JsonValueKind.True;
             if (type is null)
             {
@@ -651,14 +651,14 @@ Extensions is not null &&
                         break;
                     case OpenApiSpecVersion.OpenApi3_0 when isNullable && type.Value == JsonSchemaType.Null:
                         writer.WriteProperty(OpenApiConstants.Nullable, true);
-                        writer.WriteProperty(OpenApiConstants.Type, JsonSchemaType.Object.ToIdentifier());
+                        writer.WriteProperty(OpenApiConstants.Type, JsonSchemaType.Object.FirstIdentifier());
                         break;
                     case OpenApiSpecVersion.OpenApi3_0 when isNullable && type.Value != JsonSchemaType.Null:
                         writer.WriteProperty(OpenApiConstants.Nullable, true);
-                        writer.WriteProperty(OpenApiConstants.Type, type.Value.ToIdentifier());
+                        writer.WriteProperty(OpenApiConstants.Type, type.Value.FirstIdentifier());
                         break;
                     default:
-                        writer.WriteProperty(OpenApiConstants.Type, type.Value.ToIdentifier());
+                        writer.WriteProperty(OpenApiConstants.Type, type.Value.FirstIdentifier());
                         break;
                 }
             }
@@ -674,7 +674,13 @@ Extensions is not null &&
                     var list = (from JsonSchemaType flag in jsonSchemaTypeValues
                                 where type.Value.HasFlag(flag)
                                 select flag).ToList();
-                    writer.WriteOptionalCollection(OpenApiConstants.Type, list, (w, s) => w.WriteValue(s.ToIdentifier()));
+                    writer.WriteOptionalCollection(OpenApiConstants.Type, list, (w, s) =>
+                    {
+                        foreach(var item in s.ToIdentifier())
+                        {
+                            w.WriteValue(item);
+                        }
+                    });
                 }
             } 
         }
@@ -697,7 +703,7 @@ private static void UpCastSchemaTypeToV31(JsonSchemaType type, IOpenApiWriter wr
             var temporaryType = type | JsonSchemaType.Null;
             var list = (from JsonSchemaType flag in jsonSchemaTypeValues// Check if the flag is set in 'type' using a bitwise AND operation
                         where temporaryType.HasFlag(flag)
-                        select flag.ToIdentifier()).ToList();
+                        select flag.FirstIdentifier()).ToList();
             if (list.Count > 1)
             {
                 writer.WriteOptionalCollection(OpenApiConstants.Type, list, (w, s) => w.WriteValue(s));
@@ -734,7 +740,7 @@ private void DowncastTypeArrayToV2OrV3(JsonSchemaType schemaType, IOpenApiWriter
                     if (schemaType.HasFlag(flag) && flag != JsonSchemaType.Null)
                     {
                         // Write the non-null flag value to the writer
-                        writer.WriteProperty(OpenApiConstants.Type, flag.ToIdentifier());
+                        writer.WriteProperty(OpenApiConstants.Type, flag.FirstIdentifier());
                     }
                 }
                 writer.WriteProperty(nullableProp, true);
@@ -747,7 +753,7 @@ private void DowncastTypeArrayToV2OrV3(JsonSchemaType schemaType, IOpenApiWriter
                 }
                 else
                 {
-                    writer.WriteProperty(OpenApiConstants.Type, schemaType.ToIdentifier());
+                    writer.WriteProperty(OpenApiConstants.Type, schemaType.FirstIdentifier());
                 }
             }
         }

src/Microsoft.OpenApi/Validations/Rules/RuleHelpers.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
+using System.Linq;
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using Microsoft.OpenApi.Extensions;
@@ -55,7 +56,7 @@
             // convert value to JsonElement and access the ValueKind property to determine the type.
             var valueKind = value.GetValueKind();
 
-            var type = schema.Type.ToIdentifier();
+            var type = (schema.Type & ~JsonSchemaType.Null)?.FirstIdentifier();
             var format = schema.Format;
 
             // Before checking the type, check first if the schema allows null.
@@ -136,7 +137,7 @@
                 return;
             }
 
             if (type is "integer" or "number" && format is "int32")
             {
                 if (valueKind is not JsonValueKind.Number)
                 {

test/Microsoft.OpenApi.Readers.Tests/V31Tests/OpenApiSchemaTests.cs

@@ -9,6 +9,7 @@
 using FluentAssertions;
 using FluentAssertions.Equivalency;
 using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Extensions;
 using Microsoft.OpenApi.Models.Interfaces;
 using Microsoft.OpenApi.Reader;
 using Microsoft.OpenApi.Tests;
@@ -31,7 +32,7 @@ public static MemoryStream GetMemoryStream(string fileName)
 
         public OpenApiSchemaTests()
         {
-           OpenApiReaderRegistry.RegisterReader("yaml", new OpenApiYamlReader());
+            OpenApiReaderRegistry.RegisterReader("yaml", new OpenApiYamlReader());
         }
 
         [Fact]
@@ -298,8 +299,8 @@ public void CloningSchemaWithExamplesAndEnumsShouldSucceed()
             clone.Default = 6;
 
             // Assert
-            Assert.Equivalent(new int[] {1, 2, 3, 4}, clone.Enum.Select(static x => x.GetValue<int>()).ToArray());
-            Assert.Equivalent(new int[] {2, 3, 4}, clone.Examples.Select(static x => x.GetValue<int>()).ToArray());
+            Assert.Equivalent(new int[] { 1, 2, 3, 4 }, clone.Enum.Select(static x => x.GetValue<int>()).ToArray());
+            Assert.Equivalent(new int[] { 2, 3, 4 }, clone.Examples.Select(static x => x.GetValue<int>()).ToArray());
             Assert.Equivalent(6, clone.Default.GetValue<int>());
         }
 
@@ -398,7 +399,7 @@ public void SerializeSchemaWithTypeArrayAndNullableDoesntEmitType()
             schema.SerializeAsV2(new OpenApiYamlWriter(writer));
             var schemaString = writer.ToString();
 
-            Assert.Equal(expected.MakeLineBreaksEnvironmentNeutral(), schemaString.MakeLineBreaksEnvironmentNeutral()); 
+            Assert.Equal(expected.MakeLineBreaksEnvironmentNeutral(), schemaString.MakeLineBreaksEnvironmentNeutral());
         }
 
         [Theory]
@@ -506,7 +507,7 @@ public async Task ParseSchemaWithConstWorks()
         }
 
         [Fact]
-        public void ParseSchemaWithUnrecognizedKeywordsWorks() 
+        public void ParseSchemaWithUnrecognizedKeywordsWorks()
         {
             var input = @"{
     ""type"": ""string"",
@@ -520,5 +521,36 @@ public void ParseSchemaWithUnrecognizedKeywordsWorks()
             Assert.Equal(2, schema.UnrecognizedKeywords.Count);
         }
 
+        [Theory]
+        [InlineData(JsonSchemaType.Integer | JsonSchemaType.String, new[] { "integer", "string" })]
+        [InlineData(JsonSchemaType.Integer | JsonSchemaType.Null, new[] { "integer", "null" })]
+        [InlineData(JsonSchemaType.Integer, new[] { "integer" })]
+        public void NormalizeFlaggableJsonSchemaTypeEnumWorks(JsonSchemaType type, string[] expected)
+        {
+            var schema = new OpenApiSchema
+            {
+                Type = type
+            };
+
+            var actual = schema.Type.ToIdentifier();
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory]
+        [InlineData(new[] { "integer", "string" }, JsonSchemaType.Integer | JsonSchemaType.String)]
+        [InlineData(new[] { "integer", "null" }, JsonSchemaType.Integer | JsonSchemaType.Null)]
+        [InlineData(new[] { "integer" }, JsonSchemaType.Integer)]
+        public void ArrayIdentifierToEnumConversionWorks(string[] type, JsonSchemaType expected)
+        {
+            var actual = type.ToJsonSchemaType();
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void StringIdentifierToEnumConversionWorks()
+        {
+            var actual = "integer".ToJsonSchemaType();
+            Assert.Equal(JsonSchemaType.Integer, actual);
+        }
     }
 }

test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt

@@ -190,9 +190,10 @@ namespace Microsoft.OpenApi.Extensions
     {
         public static System.Type MapOpenApiPrimitiveTypeToSimpleType(this Microsoft.OpenApi.Models.OpenApiSchema schema) { }
         public static Microsoft.OpenApi.Models.OpenApiSchema MapTypeToOpenApiPrimitiveType(this System.Type type) { }
-        public static string? ToIdentifier(this Microsoft.OpenApi.Models.JsonSchemaType schemaType) { }
-        public static string? ToIdentifier(this Microsoft.OpenApi.Models.JsonSchemaType? schemaType) { }
+        public static string[] ToIdentifier(this Microsoft.OpenApi.Models.JsonSchemaType schemaType) { }
+        public static string[]? ToIdentifier(this Microsoft.OpenApi.Models.JsonSchemaType? schemaType) { }
         public static Microsoft.OpenApi.Models.JsonSchemaType ToJsonSchemaType(this string identifier) { }
+        public static Microsoft.OpenApi.Models.JsonSchemaType? ToJsonSchemaType(this string[] identifier) { }
     }
 }
 namespace Microsoft.OpenApi.Interfaces