fixes incompatibility with new odata primitive format.

CHANGELOG.md

@@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- Fixed incompatibility with detecting odata primitives after conversion library updates at [OpenAPI.NET.OData#581](https://github.com/microsoft/OpenAPI.NET.OData/issues/581);
 - Fixed cyclic dependencies in generated Go code. [#2834](https://github.com/microsoft/kiota/issues/2834)
 - Fixed a bug where default output folder is created on plugin edit and generate commands. [#5510](https://github.com/microsoft/kiota/issues/5429)
 

src/Kiota.Builder/Extensions/OpenApiSchemaExtensions.cs

@@ -89,7 +89,7 @@
         return schema.MergeIntersectionSchemaEntries(schemasToExclude, true, filter);
     }
 
     internal static OpenApiSchema? MergeIntersectionSchemaEntries(this OpenApiSchema? schema, HashSet<OpenApiSchema>? schemasToExclude = default, bool overrideIntersection = false, Func<OpenApiSchema, bool>? filter = default)
     {
         if (schema is null) return null;
         if (!schema.IsIntersection() && !overrideIntersection) return schema;
@@ -132,13 +132,13 @@
         "number",
         "integer",
     };
-    public static bool IsODataPrimitiveType(this OpenApiSchema schema)
+    private static bool IsODataPrimitiveTypeBackwardCompatible(this OpenApiSchema schema)
     {
         return schema.IsExclusiveUnion() &&
                 schema.OneOf.Count == 3 &&
                 schema.OneOf.Count(static x => x.Enum?.Any() ?? false) == 1 &&
                 schema.OneOf.Count(static x => oDataTypes.Contains(x.Type)) == 1 &&
                 schema.OneOf.Count(static x => "string".Equals(x.Type, StringComparison.OrdinalIgnoreCase)) == 1
                 ||
             schema.IsInclusiveUnion() &&
                 schema.AnyOf.Count == 3 &&
@@ -146,6 +146,22 @@
                 schema.AnyOf.Count(static x => oDataTypes.Contains(x.Type)) == 1 &&
                 schema.AnyOf.Count(static x => "string".Equals(x.Type, StringComparison.OrdinalIgnoreCase)) == 1;
     }
+    public static bool IsODataPrimitiveType(this OpenApiSchema schema)
+    {
+        return schema.IsExclusiveUnion() &&
+               schema.OneOf.Count == 3 &&
+               schema.OneOf.Count(static x => "string".Equals(x.Type, StringComparison.OrdinalIgnoreCase) && (x.Enum?.Any() ?? false)) == 1 &&
+               schema.OneOf.Count(static x => oDataTypes.Contains(x.Type)) == 1 &&
+               schema.OneOf.Count(static x => "string".Equals(x.Type, StringComparison.OrdinalIgnoreCase)) == 2
+               ||
+               schema.IsInclusiveUnion() &&
+               schema.AnyOf.Count == 3 &&
+               schema.AnyOf.Count(static x => "string".Equals(x.Type, StringComparison.OrdinalIgnoreCase) && (x.Enum?.Any() ?? false)) == 1 &&
+               schema.AnyOf.Count(static x => oDataTypes.Contains(x.Type)) == 1 &&
+               schema.AnyOf.Count(static x => "string".Equals(x.Type, StringComparison.OrdinalIgnoreCase)) == 2
+               ||
+               schema.IsODataPrimitiveTypeBackwardCompatible();
+    }
     public static bool IsEnum(this OpenApiSchema schema)
     {
         if (schema is null) return false;

tests/Kiota.Builder.Tests/Extensions/OpenApiSchemaExtensionsTests.cs

@@ -785,4 +785,66 @@ public void IsEnumDoesNotMaskUnions()
         };
         Assert.False(schema.IsEnum());
     }
+    [Fact]
+    public void IsOdataPrimitive()
+    {
+        var schema = new OpenApiSchema
+        {
+            OneOf = new List<OpenApiSchema>
+            {
+                new ()
+                {
+                    Type = "number",
+                    Format = "double",
+                    Nullable = true
+                },
+                new ()
+                {
+                    Type = "string",
+                    Nullable = true
+                },
+                new ()
+                {
+                    Enum = new List<IOpenApiAny>()
+                    {
+                        new OpenApiString("INF"),
+                        new OpenApiString("INF"),
+                        new OpenApiString("NaN"),
+                    },
+                    Type = "string",
+                    Nullable = true
+                }
+            }
+        };
+        Assert.True(schema.IsODataPrimitiveType());
+    }
+    [Fact]
+    public void IsOdataPrimitiveBackwardCompatible()
+    {
+        var schema = new OpenApiSchema
+        {
+            OneOf = new List<OpenApiSchema>
+            {
+                new ()
+                {
+                    Type = "number",
+                    Format = "double",
+                },
+                new ()
+                {
+                    Type = "string",
+                },
+                new ()
+                {
+                    Enum = new List<IOpenApiAny>()
+                    {
+                        new OpenApiString("INF"),
+                        new OpenApiString("INF"),
+                        new OpenApiString("NaN"),
+                    }
+                }
+            }
+        };
+        Assert.True(schema.IsODataPrimitiveType());
+    }
 }