adds support for OpenAPI 3.1 descriptions

src/Kiota.Builder/Configuration/LanguagesInformation.cs

@@ -1,31 +1,22 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.OpenApi.Any;
+using System.Text.Json.Nodes;
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Writers;
 
 namespace Kiota.Builder.Configuration;
 
 public class LanguagesInformation : Dictionary<string, LanguageInformation>, IOpenApiSerializable, ICloneable
 {
-    public void SerializeAsV2(IOpenApiWriter writer) => SerializeAsV3(writer);
-    public void SerializeAsV3(IOpenApiWriter writer)
+    public void SerializeAsV2(IOpenApiWriter writer) => SerializeAsV31(writer);
+    public void SerializeAsV3(IOpenApiWriter writer) => SerializeAsV31(writer);
+    public static LanguagesInformation Parse(JsonObject jsonNode)
     {
-        ArgumentNullException.ThrowIfNull(writer);
-        writer.WriteStartObject();
-        foreach (var entry in this.OrderBy(static x => x.Key, StringComparer.OrdinalIgnoreCase))
-        {
-            writer.WriteRequiredObject(entry.Key, entry.Value, (w, x) => x.SerializeAsV3(w));
-        }
-        writer.WriteEndObject();
-    }
-    public static LanguagesInformation Parse(IOpenApiAny source)
-    {
-        if (source is not OpenApiObject rawObject) throw new ArgumentOutOfRangeException(nameof(source));
         var extension = new LanguagesInformation();
-        foreach (var property in rawObject)
-            extension.Add(property.Key, LanguageInformation.Parse(property.Value));
+        foreach (var property in jsonNode.Where(static property => property.Value is JsonObject))
+            extension.Add(property.Key, LanguageInformation.Parse(property.Value!));
+
         return extension;
     }
 
@@ -36,4 +27,15 @@ public object Clone()
             result.Add(entry.Key, entry.Value);// records don't need to be cloned as they are immutable
         return result;
     }
+
+    public void SerializeAsV31(IOpenApiWriter writer)
+    {
+        ArgumentNullException.ThrowIfNull(writer);
+        writer.WriteStartObject();
+        foreach (var entry in this.OrderBy(static x => x.Key, StringComparer.OrdinalIgnoreCase))
+        {
+            writer.WriteRequiredObject(entry.Key, entry.Value, (w, x) => x.SerializeAsV3(w));
+        }
+        writer.WriteEndObject();
+    }
 }

src/Kiota.Builder/Extensions/OpenApiDeprecationExtensionExtensions.cs

@@ -24,15 +24,15 @@ internal static DeprecationInformation GetDeprecationInformation(this OpenApiPar
             return deprecatedValue.ToDeprecationInformation();
         else if (parameter.Schema != null && !parameter.Schema.IsReferencedSchema() && parameter.Schema.Deprecated)
             return parameter.Schema.GetDeprecationInformation();
-        else if (parameter.Content.Values.Select(static x => x.Schema).Where(static x => x != null && !x.IsReferencedSchema() && x.Deprecated).Select(static x => x.GetDeprecationInformation()).FirstOrDefault(static x => x.IsDeprecated) is DeprecationInformation contentDeprecationInformation)
+        else if (parameter.Content.Values.Select(static x => x.Schema).Where(static x => x != null && !x.IsReferencedSchema() && x.Deprecated).Select(static x => x!.GetDeprecationInformation()).FirstOrDefault(static x => x.IsDeprecated) is DeprecationInformation contentDeprecationInformation)
             return contentDeprecationInformation;
         return new(null, null, null, null, parameter.Deprecated);
     }
     internal static DeprecationInformation GetDeprecationInformation(this OpenApiOperation operation)
     {
-        if (operation.Deprecated && operation.Extensions.TryGetValue(OpenApiDeprecationExtension.Name, out var deprecatedExtension) && deprecatedExtension is OpenApiDeprecationExtension deprecatedValue)
+        if (operation.Deprecated && operation.Extensions is not null && operation.Extensions.TryGetValue(OpenApiDeprecationExtension.Name, out var deprecatedExtension) && deprecatedExtension is OpenApiDeprecationExtension deprecatedValue)
             return deprecatedValue.ToDeprecationInformation();
-        else if (operation.Responses.Values
+        else if (operation.Responses?.Values
                                 .SelectMany(static x => x.Content.Values)
                                 .Select(static x => x?.Schema)
                                 .OfType<OpenApiSchema>()

src/Kiota.Builder/Extensions/OpenApiDocumentExtensions.cs

@@ -31,7 +31,7 @@ internal static void InitializeInheritanceIndex(this OpenApiDocument openApiDocu
     {
         ArgumentNullException.ThrowIfNull(openApiDocument);
         var candidateUrl = openApiDocument.Servers
-                                        .GroupBy(static x => x, new OpenApiServerComparer()) //group by protocol relative urls
+                                        ?.GroupBy(static x => x, new OpenApiServerComparer()) //group by protocol relative urls
                                         .FirstOrDefault()
                                         ?.OrderByDescending(static x => x.Url, StringComparer.OrdinalIgnoreCase) // prefer https over http
                                         ?.FirstOrDefault()

src/Kiota.Builder/Extensions/OpenApiOperationExtensions.cs

@@ -30,6 +30,7 @@ private static string vendorSpecificCleanup(string input)
     }
     internal static IEnumerable<OpenApiSchema> GetResponseSchemas(this OpenApiOperation operation, HashSet<string> successCodesToUse, StructuredMimeTypesCollection structuredMimeTypes)
     {
+        if (operation.Responses is null) return [];
         // Return Schema that represents all the possible success responses!
         return operation.Responses.Where(r => successCodesToUse.Contains(r.Key))
                             .OrderBy(static x => x.Key, StringComparer.OrdinalIgnoreCase)
@@ -67,7 +68,7 @@ internal static IEnumerable<OpenApiSchema> GetValidSchemas(this IDictionary<stri
                     .Select(static c => (Key: c.Key.Split(';', StringSplitOptions.RemoveEmptyEntries)[0], c.Value))
                     .Where(c => structuredMimeTypes.Contains(c.Key) || structuredMimeTypes.Contains(vendorSpecificCleanup(c.Key)))
                     .Select(static co => co.Value.Schema)
-                    .Where(static s => s is not null);
+                    .OfType<OpenApiSchema>();
     }
     internal static OpenApiSchema? GetResponseSchema(this OpenApiResponse response, StructuredMimeTypesCollection structuredMimeTypes)
     {

src/Kiota.Builder/Extensions/OpenApiSchemaExtensions.cs

@@ -2,7 +2,7 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
-using Microsoft.OpenApi.Any;
+using System.Text.Json;
 using Microsoft.OpenApi.Models;
 
 namespace Kiota.Builder.Extensions;
@@ -53,7 +53,7 @@ public static bool IsReferencedSchema(this OpenApiSchema schema)
 
     public static bool IsArray(this OpenApiSchema? schema)
     {
-        return "array".Equals(schema?.Type, StringComparison.OrdinalIgnoreCase) && schema.Items != null &&
+        return schema is { Type: JsonSchemaType.Array or (JsonSchemaType.Array | JsonSchemaType.Null) } && schema.Items is not null &&
             (schema.Items.IsComposedEnum() ||
             schema.Items.IsEnum() ||
             schema.Items.IsSemanticallyMeaningful() ||
@@ -62,7 +62,7 @@ public static bool IsArray(this OpenApiSchema? schema)
 
     public static bool IsObjectType(this OpenApiSchema? schema)
     {
-        return "object".Equals(schema?.Type, StringComparison.OrdinalIgnoreCase);
+        return schema is { Type: JsonSchemaType.Object or (JsonSchemaType.Object | JsonSchemaType.Null) };
     }
     public static bool HasAnyProperty(this OpenApiSchema? schema)
     {
@@ -80,7 +80,7 @@ public static bool IsInherited(this OpenApiSchema? schema)
         var meaningfulMemberSchemas = schema.AllOf.FlattenSchemaIfRequired(static x => x.AllOf)
                                                                 .Where(static x => x.IsSemanticallyMeaningful(ignoreEnums: true, ignoreArrays: true, ignoreType: true))
                                                                 // the next line ensures the meaningful schema are objects as it won't make sense inheriting from a primitive despite it being meaningful.
-                                                                .Where(static x => string.IsNullOrEmpty(x.Reference?.Id) || string.IsNullOrEmpty(x.Type) || "object".Equals(x.Type, StringComparison.OrdinalIgnoreCase))
+                                                                .Where(static x => string.IsNullOrEmpty(x.Reference?.Id) || x.Type is null || !x.Type.HasValue || (x.Type.Value & JsonSchemaType.Object) is JsonSchemaType.Object)
                                                                 .ToArray();
         var isRootSchemaMeaningful = schema.IsSemanticallyMeaningful(ignoreEnums: true, ignoreArrays: true, ignoreType: true);
         return meaningfulMemberSchemas.Count(static x => !string.IsNullOrEmpty(x.Reference?.Id)) == 1 &&
@@ -162,45 +162,48 @@ public static bool IsExclusiveUnion(this OpenApiSchema? schema, uint exclusiveMi
         return schema?.OneOf?.Count(static x => IsSemanticallyMeaningful(x, true)) > exclusiveMinimumNumberOfEntries;
         // so we don't consider one of object/nullable as a union type
     }
-    private static readonly HashSet<string> oDataTypes = new(StringComparer.OrdinalIgnoreCase) {
-        "number",
-        "integer",
-    };
+    private static readonly HashSet<JsonSchemaType> oDataTypes = [
+        JsonSchemaType.Number,
+        JsonSchemaType.Integer,
+    ];
+    private static readonly Func<OpenApiSchema, bool> isODataType = static x => x.Type is not null && oDataTypes.Contains(x.Type.Value);
+    private static readonly Func<OpenApiSchema, bool> isStringType = static x => x is { Type: JsonSchemaType.String or (JsonSchemaType.String | JsonSchemaType.Null) };
     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.OneOf.Count(isODataType) == 1 &&
+                schema.OneOf.Count(isStringType) == 1
                 ||
             schema.IsInclusiveUnion() &&
                 schema.AnyOf.Count == 3 &&
                 schema.AnyOf.Count(static x => 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)) == 1;
+                schema.AnyOf.Count(isODataType) == 1 &&
+                schema.AnyOf.Count(isStringType) == 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.OneOf.Count(static x => isStringType(x) && (x.Enum?.Any() ?? false)) == 1 &&
+               schema.OneOf.Count(isODataType) == 1 &&
+               schema.OneOf.Count(isStringType) == 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.AnyOf.Count(static x => isStringType(x) && (x.Enum?.Any() ?? false)) == 1 &&
+               schema.AnyOf.Count(isODataType) == 1 &&
+               schema.AnyOf.Count(isStringType) == 2
                ||
                schema.IsODataPrimitiveTypeBackwardCompatible();
     }
     public static bool IsEnum(this OpenApiSchema schema)
     {
         if (schema is null) return false;
-        return schema.Enum.OfType<OpenApiString>().Any(static x => !string.IsNullOrEmpty(x.Value)) &&
-                (string.IsNullOrEmpty(schema.Type) || "string".Equals(schema.Type, StringComparison.OrdinalIgnoreCase)); // number and boolean enums are not supported
+        return schema.Enum.Any(static x => x.GetValueKind() is JsonValueKind.String &&
+                                    x.GetValue<string>() is string value &&
+                                    !string.IsNullOrEmpty(value)); // number and boolean enums are not supported
     }
     public static bool IsComposedEnum(this OpenApiSchema schema)
     {
@@ -214,8 +217,8 @@ public static bool IsSemanticallyMeaningful(this OpenApiSchema schema, bool igno
         return schema.HasAnyProperty() ||
                 (!ignoreEnums && schema.Enum is { Count: > 0 }) ||
                 (!ignoreArrays && schema.Items != null) ||
-                (!ignoreType && !string.IsNullOrEmpty(schema.Type) &&
-                    ((ignoreNullableObjects && !"object".Equals(schema.Type, StringComparison.OrdinalIgnoreCase)) ||
+                (!ignoreType && schema.Type is not null &&
+                    ((ignoreNullableObjects && !schema.IsObjectType()) ||
                     !ignoreNullableObjects)) ||
                 !string.IsNullOrEmpty(schema.Format) ||
                 !string.IsNullOrEmpty(schema.Reference?.Id);
@@ -306,7 +309,7 @@ internal static string GetDiscriminatorPropertyName(this OpenApiSchema schema, H
     internal static IEnumerable<KeyValuePair<string, string>> GetDiscriminatorMappings(this OpenApiSchema schema, ConcurrentDictionary<string, ConcurrentDictionary<string, bool>> inheritanceIndex)
     {
         if (schema == null)
-            return Enumerable.Empty<KeyValuePair<string, string>>();
+            return [];
         if (!(schema.Discriminator?.Mapping?.Any() ?? false))
             if (schema.OneOf.Any())
                 return schema.OneOf.SelectMany(x => GetDiscriminatorMappings(x, inheritanceIndex));
@@ -319,9 +322,9 @@ internal static IEnumerable<KeyValuePair<string, string>> GetDiscriminatorMappin
                 return GetAllInheritanceSchemaReferences(schema.Reference.Id, inheritanceIndex)
                            .Where(static x => !string.IsNullOrEmpty(x))
                            .Select(x => KeyValuePair.Create(x, x))
-                           .Union(new[] { KeyValuePair.Create(schema.Reference.Id, schema.Reference.Id) });
+                           .Union([KeyValuePair.Create(schema.Reference.Id, schema.Reference.Id)]);
             else
-                return Enumerable.Empty<KeyValuePair<string, string>>();
+                return [];
 
         return schema.Discriminator
                 .Mapping;

src/Kiota.Builder/Extensions/OpenApiSettingsExtensions.cs

@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Kiota.Builder.OpenApiExtensions;
-using Microsoft.OpenApi.Readers;
+using Microsoft.OpenApi.Reader;
 
 namespace Kiota.Builder.Extensions;
 public static class OpenApiSettingsExtensions

src/Kiota.Builder/Extensions/OpenApiUrlTreeNodeExtensions.cs

@@ -69,7 +69,7 @@ internal static string CleanupParametersFromPath(string pathSegment)
     private static IEnumerable<OpenApiParameter> GetParametersForPathItem(OpenApiPathItem pathItem, string nodeSegment)
     {
         return pathItem.Parameters
-                    .Union(pathItem.Operations.SelectMany(static x => x.Value.Parameters))
+                    .Union(pathItem.Operations.SelectMany(static x => x.Value.Parameters ?? Enumerable.Empty<OpenApiParameter>()))
                     .Where(static x => x.In == ParameterLocation.Path)
                     .Where(x => nodeSegment.Contains($"{{{x.Name}}}", StringComparison.OrdinalIgnoreCase));
     }
@@ -193,7 +193,7 @@ public static bool HasRequiredQueryParametersAcrossOperations(this OpenApiUrlTre
         if (!currentNode.PathItems.TryGetValue(Constants.DefaultOpenApiLabel, out var pathItem))
             return false;
 
-        var operationQueryParameters = pathItem.Operations.SelectMany(static x => x.Value.Parameters);
+        var operationQueryParameters = pathItem.Operations.SelectMany(static x => x.Value.Parameters ?? Enumerable.Empty<OpenApiParameter>());
         return operationQueryParameters.Union(pathItem.Parameters).Where(static x => x.In == ParameterLocation.Query)
             .Any(static x => x.Required);
     }
@@ -207,9 +207,9 @@ public static string GetUrlTemplate(this OpenApiUrlTreeNode currentNode, Operati
             var pathItem = currentNode.PathItems[Constants.DefaultOpenApiLabel];
             var operationQueryParameters = (operationType, pathItem.Operations.Any()) switch
             {
-                (OperationType ot, _) when pathItem.Operations.TryGetValue(ot, out var operation) => operation.Parameters,
-                (null, true) => pathItem.Operations.SelectMany(static x => x.Value.Parameters).Where(static x => x.In == ParameterLocation.Query),
-                _ => Enumerable.Empty<OpenApiParameter>(),
+                (OperationType ot, _) when pathItem.Operations.TryGetValue(ot, out var operation) && operation.Parameters is not null => operation.Parameters,
+                (null, true) => pathItem.Operations.SelectMany(static x => x.Value.Parameters ?? Enumerable.Empty<OpenApiParameter>()).Where(static x => x.In == ParameterLocation.Query),
+                _ => [],
             };
             var parameters = pathItem.Parameters
                                     .Union(operationQueryParameters)
@@ -234,7 +234,7 @@ public static string GetUrlTemplate(this OpenApiUrlTreeNode currentNode, Operati
         }
         var pathReservedPathParametersIds = currentNode.PathItems.TryGetValue(Constants.DefaultOpenApiLabel, out var pItem) ?
                                                 pItem.Parameters
-                                                        .Union(pItem.Operations.SelectMany(static x => x.Value.Parameters))
+                                                        .Union(pItem.Operations.SelectMany(static x => x.Value.Parameters ?? Enumerable.Empty<OpenApiParameter>()))
                                                         .Where(static x => x.In == ParameterLocation.Path && x.Extensions.TryGetValue(OpenApiReservedParameterExtension.Name, out var ext) && ext is OpenApiReservedParameterExtension reserved && reserved.IsReserved.HasValue && reserved.IsReserved.Value)
                                                         .Select(static x => x.Name)
                                                         .ToHashSet(StringComparer.OrdinalIgnoreCase) :
@@ -356,7 +356,7 @@ private static void ReplaceParameterInPathForAllChildNodes(OpenApiUrlTreeNode no
                 if (node.PathItems.TryGetValue(Constants.DefaultOpenApiLabel, out var pathItem))
                 {
                     foreach (var pathParameter in pathItem.Parameters
-                                                    .Union(pathItem.Operations.SelectMany(static x => x.Value.Parameters))
+                                                    .Union(pathItem.Operations.SelectMany(static x => x.Value.Parameters ?? Enumerable.Empty<OpenApiParameter>()))
                                                     .Where(x => x.In == ParameterLocation.Path && oldName.Equals(x.Name, StringComparison.Ordinal)))
                     {
                         pathParameter.Name = newParameterName;
@@ -386,7 +386,7 @@ private static void CopyNodeIntoOtherNode(OpenApiUrlTreeNode source, OpenApiUrlT
                                             pathItem
                                                 .Value
                                                 .Operations
-                                                .SelectMany(static x => x.Value.Parameters)
+                                                .SelectMany(static x => x.Value.Parameters ?? Enumerable.Empty<OpenApiParameter>())
                                                 .Where(x => x.In == ParameterLocation.Path && pathParameterNameToReplace.Equals(x.Name, StringComparison.Ordinal))
                                         ))
             {