feat: adds parsing infrastructure for version 3.2

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

Author: baywet

src/Microsoft.OpenApi.Hidi/OpenApiService.cs

@@ -69,7 +69,7 @@ public static async Task TransformOpenApiDocumentAsync(HidiOptions options, ILog
 
                 // Default to yaml and OpenApiVersion 3_1 during csdl to OpenApi conversion
                 var openApiFormat = options.OpenApiFormat ?? (!string.IsNullOrEmpty(options.OpenApi) ? GetOpenApiFormat(options.OpenApi, logger) : OpenApiConstants.Yaml);
-                var openApiVersion = options.Version != null ? TryParseOpenApiSpecVersion(options.Version) : OpenApiSpecVersion.OpenApi3_1;
+                var openApiVersion = options.Version != null ? TryParseOpenApiSpecVersion(options.Version) : OpenApiSpecVersion.OpenApi3_2;
 
                 // If ApiManifest is provided, set the referenced OpenAPI document
                 var apiDependency = await FindApiDependencyAsync(options.FilterOptions.FilterByApiManifest, logger, cancellationToken).ConfigureAwait(false);

src/Microsoft.OpenApi.Hidi/OpenApiSpecVersionHelper.cs

@@ -35,8 +35,12 @@ public static OpenApiSpecVersion TryParseOpenApiSpecVersion(string value)
             {
                 return OpenApiSpecVersion.OpenApi3_1;
             }
+            else if (majorVersion == 3 && minorVersion == 2)
+            {
+                return OpenApiSpecVersion.OpenApi3_2;
+            }
 
-            return OpenApiSpecVersion.OpenApi3_1; // default
+            return OpenApiSpecVersion.OpenApi3_2; // default
         }
     }
 }

src/Microsoft.OpenApi.Workbench/MainModel.cs

@@ -155,6 +155,7 @@ public OpenApiSpecVersion Version
                 OnPropertyChanged(nameof(IsV2_0));
                 OnPropertyChanged(nameof(IsV3_0));
                 OnPropertyChanged(nameof(IsV3_1));
+                OnPropertyChanged(nameof(IsV3_2));
             }
         }
 
@@ -188,6 +189,12 @@ public bool IsV3_1
             set => Version = value ? OpenApiSpecVersion.OpenApi3_1 : Version;
         }
 
+        public bool IsV3_2
+        {
+            get => Version == OpenApiSpecVersion.OpenApi3_2;
+            set => Version = value ? OpenApiSpecVersion.OpenApi3_2 : Version;
+        }
+
         /// <summary>
         /// Handling method when the property with given name has changed.
         /// </summary>

src/Microsoft.OpenApi/Extensions/OpenApiSerializableExtensions.cs

@@ -111,6 +111,10 @@ public static Task SerializeAsync<T>(this T element, IOpenApiWriter writer, Open
 
             switch (specVersion)
             {
+                case OpenApiSpecVersion.OpenApi3_2:
+                    element.SerializeAsV32(writer);
+                    break;
+
                 case OpenApiSpecVersion.OpenApi3_1:
                     element.SerializeAsV31(writer);
                     break;

src/Microsoft.OpenApi/Models/OpenApiDocument.cs

@@ -162,6 +162,10 @@ public void SerializeAs(OpenApiSpecVersion version, IOpenApiWriter writer)
                     SerializeAsV31(writer);
                     break;
 
+                case OpenApiSpecVersion.OpenApi3_2:
+                    SerializeAsV32(writer);
+                    break;
+
                 default:
                     throw new ArgumentOutOfRangeException(nameof(version), version, string.Format(SRResource.OpenApiSpecVersionNotSupported, version));
             }

src/Microsoft.OpenApi/Reader/OpenApiVersionExtensionMethods.cs

@@ -57,5 +57,21 @@ public static bool is3_1(this string version)
 
             return result;
         }
+
+        /// <summary>
+        /// Extension method for Spec version 3.2
+        /// </summary>
+        /// <param name="version"></param>
+        /// <returns></returns>
+        public static bool is3_2(this string version)
+        {
+            bool result = false;
+            if (version.StartsWith("3.2", StringComparison.OrdinalIgnoreCase))
+            {
+                result = true;
+            }
+
+            return result;
+        }
     }
 }

src/Microsoft.OpenApi/Reader/ParsingContext.cs

@@ -8,6 +8,7 @@
 using Microsoft.OpenApi.Reader.V2;
 using Microsoft.OpenApi.Reader.V3;
 using Microsoft.OpenApi.Reader.V31;
+using Microsoft.OpenApi.Reader.V32;
 
 namespace Microsoft.OpenApi.Reader
 {
@@ -88,6 +89,12 @@ public OpenApiDocument Parse(JsonNode jsonNode, Uri location)
                     this.Diagnostic.SpecificationVersion = OpenApiSpecVersion.OpenApi3_1;
                     ValidateRequiredFields(doc, version);
                     break;
+                case string version when version.is3_2():
+                    VersionService = new OpenApiV32VersionService(Diagnostic);
+                    doc = VersionService.LoadDocument(RootNode, location);
+                    this.Diagnostic.SpecificationVersion = OpenApiSpecVersion.OpenApi3_2;
+                    ValidateRequiredFields(doc, version);
+                    break;
                 default:
                     throw new OpenApiUnsupportedSpecVersionException(inputVersion);
             }
@@ -123,6 +130,10 @@ public OpenApiDocument Parse(JsonNode jsonNode, Uri location)
                     this.VersionService = new OpenApiV31VersionService(Diagnostic);
                     element = this.VersionService.LoadElement<T>(node, openApiDocument);
                     break;
+                case OpenApiSpecVersion.OpenApi3_2:
+                    this.VersionService = new OpenApiV32VersionService(Diagnostic);
+                    element = this.VersionService.LoadElement<T>(node, openApiDocument);
+                    break;
             }
 
             return element;

src/Microsoft.OpenApi/Reader/V31/OpenApiV31VersionService.cs

@@ -15,7 +15,7 @@ internal class OpenApiV31VersionService : BaseOpenApiVersionService
         /// <summary>
         /// Create Parsing Context
         /// </summary>
-        /// <param name="diagnostic">Provide instance for diagnotic object for collecting and accessing information about the parsing.</param>
+        /// <param name="diagnostic">Provide instance for diagnostic object for collecting and accessing information about the parsing.</param>
         public OpenApiV31VersionService(OpenApiDiagnostic diagnostic):base(diagnostic)
         {
         }

src/Microsoft.OpenApi/Reader/V32/OpenApiCallbackDeserializer.cs

@@ -0,0 +1,41 @@
+using System;
+
+namespace Microsoft.OpenApi.Reader.V32
+{
+    /// <summary>
+    /// Class containing logic to deserialize Open API V3 document into
+    /// runtime Open API object model.
+    /// </summary>
+    internal static partial class OpenApiV32Deserializer
+    {
+        private static readonly FixedFieldMap<OpenApiCallback> _callbackFixedFields =
+            new();
+
+        private static readonly PatternFieldMap<OpenApiCallback> _callbackPatternFields =
+            new()
+            {
+            {s => !s.StartsWith(OpenApiConstants.ExtensionFieldNamePrefix, StringComparison.OrdinalIgnoreCase), (o, p, n, t) => o.AddPathItem(RuntimeExpression.Build(p), LoadPathItem(n, t))},
+            {s => s.StartsWith(OpenApiConstants.ExtensionFieldNamePrefix, StringComparison.OrdinalIgnoreCase), (o, p, n, _) => o.AddExtension(p, LoadExtension(p,n))},
+            };
+
+        public static IOpenApiCallback LoadCallback(ParseNode node, OpenApiDocument hostDocument)
+        {
+            var mapNode = node.CheckMapNode("callback");
+
+            if (mapNode.GetReferencePointer() is { } pointer)
+            {
+                var reference = GetReferenceIdAndExternalResource(pointer);
+                var callbackReference = new OpenApiCallbackReference(reference.Item1, hostDocument, reference.Item2);
+                callbackReference.Reference.SetMetadataFromMapNode(mapNode);
+                return callbackReference;
+            }
+
+            var domainObject = new OpenApiCallback();
+
+            ParseMap(mapNode, domainObject, _callbackFixedFields, _callbackPatternFields, hostDocument);
+
+            return domainObject;
+        }
+    }
+}
+

src/Microsoft.OpenApi/Reader/V32/OpenApiComponentsDeserializer.cs

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using System;
+
+namespace Microsoft.OpenApi.Reader.V32
+{
+    /// <summary>
+    /// Class containing logic to deserialize Open API V32 document into
+    /// runtime Open API object model.
+    /// </summary>
+    internal static partial class OpenApiV32Deserializer
+    {
+        private static readonly FixedFieldMap<OpenApiComponents> _componentsFixedFields = new()
+        {
+        {"schemas", (o, n, t) => o.Schemas = n.CreateMap(LoadSchema, t)},
+        {"responses", (o, n, t) => o.Responses = n.CreateMap(LoadResponse, t)},
+        {"parameters", (o, n, t) => o.Parameters = n.CreateMap(LoadParameter, t)},
+        {"examples", (o, n, t) => o.Examples = n.CreateMap(LoadExample, t)},
+        {"requestBodies", (o, n, t) => o.RequestBodies = n.CreateMap(LoadRequestBody, t)},
+        {"headers", (o, n, t) => o.Headers = n.CreateMap(LoadHeader, t)},
+        {"securitySchemes", (o, n, t) => o.SecuritySchemes = n.CreateMap(LoadSecurityScheme, t)},
+        {"links", (o, n, t) => o.Links = n.CreateMap(LoadLink, t)},
+        {"callbacks", (o, n, t) => o.Callbacks = n.CreateMap(LoadCallback, t)},
+        {"pathItems", (o, n, t) => o.PathItems = n.CreateMap(LoadPathItem, t)}
+    };
+
+        private static readonly PatternFieldMap<OpenApiComponents> _componentsPatternFields =
+            new()
+            {
+            {s => s.StartsWith(OpenApiConstants.ExtensionFieldNamePrefix, StringComparison.OrdinalIgnoreCase), (o, p, n, _) => o.AddExtension(p, LoadExtension(p, n))}
+            };
+
+        public static OpenApiComponents LoadComponents(ParseNode node, OpenApiDocument hostDocument)
+        {
+            var mapNode = node.CheckMapNode("components");
+            var components = new OpenApiComponents();
+
+            ParseMap(mapNode, components, _componentsFixedFields, _componentsPatternFields, hostDocument);
+
+            return components;
+        }
+    }
+}
+