feat: lookup document is being passed to all handlers

Signed-off-by: Vincent Biret <[email protected]>

Author: baywet

src/Microsoft.OpenApi.OData.Reader/Generator/OpenApiPathItemGenerator.cs

@@ -22,8 +22,9 @@ internal static class OpenApiPathItemGenerator
         /// Create a map of <see cref="OpenApiPathItem"/>.
         /// </summary>
         /// <param name="context">The OData context.</param>
+        /// <param name="document">The Open API document to use to lookup references.</param>
         /// <returns>The created map of <see cref="OpenApiPathItem"/>.</returns>
-        public static IDictionary<string, OpenApiPathItem> CreatePathItems(this ODataContext context)
+        public static IDictionary<string, OpenApiPathItem> CreatePathItems(this ODataContext context, OpenApiDocument document)
         {
             Utils.CheckArgumentNull(context, nameof(context));
 
@@ -37,7 +38,7 @@ public static IDictionary<string, OpenApiPathItem> CreatePathItems(this ODataCon
             settings.EnableKeyAsSegment = context.KeyAsSegment;
             foreach (ODataPath path in context.AllPaths)
             {
-                IPathItemHandler handler = context.PathItemHandlerProvider.GetHandler(path.Kind);
+                IPathItemHandler handler = context.PathItemHandlerProvider.GetHandler(path.Kind, document);
                 if (handler == null)
                 {
                     continue;

src/Microsoft.OpenApi.OData.Reader/Generator/OpenApiPathsGenerator.cs

@@ -22,16 +22,17 @@ internal static class OpenApiPathsGenerator
         /// and whose value is a Path Item Object.
         /// </summary>
         /// <param name="context">The OData context.</param>
+        /// <param name="document">The Open API document to use to lookup references.</param>
         /// <returns>The created <see cref="OpenApiPaths"/> object.</returns>
-        public static OpenApiPaths CreatePaths(this ODataContext context)
+        public static OpenApiPaths CreatePaths(this ODataContext context, OpenApiDocument document)
         {
             Utils.CheckArgumentNull(context, nameof(context));
 
             // Due to the power and flexibility of OData a full representation of all service capabilities
             // in the Paths Object is typically not feasible, so this mapping only describes the minimum
             // information desired in the Paths Object.
-            OpenApiPaths paths = new();
-            foreach (var item in context.CreatePathItems())
+            OpenApiPaths paths = [];
+            foreach (var item in context.CreatePathItems(document))
             {
                 paths.Add(item.Key, item.Value);
             }

src/Microsoft.OpenApi.OData.Reader/Operation/IOperationHandlerProvider.cs

@@ -18,7 +18,8 @@ internal interface IOperationHandlerProvider
         /// </summary>
         /// <param name="pathKind">The path kind.</param>
         /// <param name="operationType">The operation type.</param>
+        /// <param name="document">The Open API document to use to lookup references.</param>
         /// <returns>The corresponding <see cref="IOperationHandler"/>.</returns>
-        IOperationHandler GetHandler(ODataPathKind pathKind, OperationType operationType);
+        IOperationHandler GetHandler(ODataPathKind pathKind, OperationType operationType, OpenApiDocument document);
     }
 }

src/Microsoft.OpenApi.OData.Reader/Operation/OperationHandlerProvider.cs

@@ -15,7 +15,7 @@ namespace Microsoft.OpenApi.OData.Operation
     internal class OperationHandlerProvider : IOperationHandlerProvider
     {
         /// <inheritdoc/>
-        public IOperationHandler GetHandler(ODataPathKind pathKind, OperationType operationType)
+        public IOperationHandler GetHandler(ODataPathKind pathKind, OperationType operationType, OpenApiDocument document)
         {
             return (pathKind, operationType) switch
             {

src/Microsoft.OpenApi.OData.Reader/PathItem/IPathItemHandlerProvider.cs

@@ -3,6 +3,7 @@
 //  Licensed under the MIT License (MIT). See LICENSE in the repo root for license information.
 // ------------------------------------------------------------
 
+using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.OData.Edm;
 
 namespace Microsoft.OpenApi.OData.PathItem
@@ -16,7 +17,8 @@ internal interface IPathItemHandlerProvider
         /// Get the <see cref="IPathItemHandler"/> based on the path type.
         /// </summary>
         /// <param name="pathKind">The path kind.</param>
+        /// <param name="document">The Open API document to use to lookup references.</param>
         /// <returns>The <see cref="IPathItemHandler"/>.</returns>
-        IPathItemHandler GetHandler(ODataPathKind pathKind);
+        IPathItemHandler GetHandler(ODataPathKind pathKind, OpenApiDocument document);
     }
 }

src/Microsoft.OpenApi.OData.Reader/PathItem/PathItemHandlerProvider.cs

@@ -3,7 +3,7 @@
 //  Licensed under the MIT License (MIT). See LICENSE in the repo root for license information.
 // ------------------------------------------------------------
 
-using System.Collections.Generic;
+using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.OData.Edm;
 
 namespace Microsoft.OpenApi.OData.PathItem
@@ -13,52 +13,49 @@ namespace Microsoft.OpenApi.OData.PathItem
     /// </summary>
     internal class PathItemHandlerProvider : IPathItemHandlerProvider
     {
-        private readonly IDictionary<ODataPathKind, IPathItemHandler> _handlers = new Dictionary<ODataPathKind, IPathItemHandler>
+        /// <inheritdoc/>
+        public IPathItemHandler GetHandler(ODataPathKind pathKind, OpenApiDocument document)
         {
+            return pathKind switch {
             // EntitySet
-            { ODataPathKind.EntitySet, new EntitySetPathItemHandler() },
+            ODataPathKind.EntitySet => new EntitySetPathItemHandler(document),
 
             // Entity
-            { ODataPathKind.Entity, new EntityPathItemHandler() },
+            ODataPathKind.Entity => new EntityPathItemHandler(document),
 
             // Singleton
-            { ODataPathKind.Singleton, new SingletonPathItemHandler() },
+            ODataPathKind.Singleton => new SingletonPathItemHandler(document),
 
             // Navigation property
-            { ODataPathKind.NavigationProperty, new NavigationPropertyPathItemHandler() },
+            ODataPathKind.NavigationProperty => new NavigationPropertyPathItemHandler(document),
 
             // Edm Operation
-            { ODataPathKind.Operation, new OperationPathItemHandler() },
+            ODataPathKind.Operation => new OperationPathItemHandler(document),
 
             // Edm OperationImport
-            { ODataPathKind.OperationImport, new OperationImportPathItemHandler() },
+            ODataPathKind.OperationImport => new OperationImportPathItemHandler(document),
 
             // Edm Ref
-            { ODataPathKind.Ref, new RefPathItemHandler() },
+            ODataPathKind.Ref => new RefPathItemHandler(document),
 
             // Media Entity
-            { ODataPathKind.MediaEntity, new MediaEntityPathItemHandler() },
+            ODataPathKind.MediaEntity => new MediaEntityPathItemHandler(document),
 
             // $Metadata
-            { ODataPathKind.Metadata, new MetadataPathItemHandler() },
+            ODataPathKind.Metadata => new MetadataPathItemHandler(document),
 
             // $count
-            { ODataPathKind.DollarCount, new DollarCountPathItemHandler() },
+            ODataPathKind.DollarCount => new DollarCountPathItemHandler(document),
 
             // ~/groups/{id}/members/microsoft.graph.user
-            { ODataPathKind.TypeCast, new ODataTypeCastPathItemHandler() },
+            ODataPathKind.TypeCast => new ODataTypeCastPathItemHandler(document),
 
             // ~/users/{id}/mailboxSettings
-            { ODataPathKind.ComplexProperty, new ComplexPropertyItemHandler() },
+            ODataPathKind.ComplexProperty => new ComplexPropertyItemHandler(document),
 
             // Unknown
-            { ODataPathKind.Unknown, null },
-        };
-
-        /// <inheritdoc/>
-        public IPathItemHandler GetHandler(ODataPathKind pathKind)
-        {
-            return _handlers[pathKind];
+                _ => null,
+            };
         }
     }
 }