Get the $ref pointer to a pathItem object and resolve the reference by returning the pathItem matching the reference Id in the components object

Author: MaggieKimani1

src/Microsoft.OpenApi.Readers/V3/OpenApiPathItemDeserializer.cs

@@ -56,6 +56,17 @@ public static OpenApiPathItem LoadPathItem(ParseNode node)
         {
             var mapNode = node.CheckMapNode("PathItem");
 
+            var pointer = mapNode.GetReferencePointer();
+
+            if (pointer != null)
+            {
+                return new OpenApiPathItem()
+                {
+                    UnresolvedReference = true,
+                    Reference = node.Context.VersionService.ConvertToOpenApiReference(pointer, ReferenceType.PathItem)
+                };
+            }
+
             var pathItem = new OpenApiPathItem();
 
             ParseMap(mapNode, pathItem, _pathItemFixedFields, _pathItemPatternFields);

src/Microsoft.OpenApi.Readers/V3/OpenApiV3VersionService.cs

@@ -165,7 +165,12 @@ private OpenApiReference ParseLocalReference(string localReference)
                 if (segments[1] == "components")
                 {
                     var referenceType = segments[2].GetEnumFromDisplayName<ReferenceType>();
-                    return new OpenApiReference { Type = referenceType, Id = segments[3] };
+                    var refId = segments[3];
+                    if (segments[2] == "pathItems")
+                    {
+                        refId = "/" + segments[3];
+                    };
+                    return new OpenApiReference { Type = referenceType, Id = refId };
                 }
             }
 

src/Microsoft.OpenApi/Models/OpenApiDocument.cs

@@ -505,7 +505,10 @@ internal IOpenApiReferenceable ResolveReference(OpenApiReference reference, bool
                 {
                     case ReferenceType.Schema:
                         return this.Components.Schemas[reference.Id];
-
+                        
+                    case ReferenceType.PathItem:
+                        return this.Components.PathItems[reference.Id];
+                        
                     case ReferenceType.Response:
                         return this.Components.Responses[reference.Id];
 

src/Microsoft.OpenApi/Services/OpenApiReferenceResolver.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license. 
 
 using System;
@@ -70,6 +70,7 @@ public override void Visit(OpenApiComponents components)
             ResolveMap(components.Callbacks);
             ResolveMap(components.Examples);
             ResolveMap(components.Schemas);
+            ResolveMap(components.PathItems);
             ResolveMap(components.SecuritySchemes);
             ResolveMap(components.Headers);
         }
@@ -83,6 +84,15 @@ public override void Visit(IDictionary<string, OpenApiCallback> callbacks)
             ResolveMap(callbacks);
         }
 
+        /// <summary>
+        /// Resolves all references used in webhooks
+        /// </summary>
+        /// <param name="webhooks"></param>
+        public override void Visit(IDictionary<string, OpenApiPathItem> webhooks)
+        {
+            ResolveMap(webhooks);
+        }
+
         /// <summary>
         /// Resolve all references used in an operation
         /// </summary>
@@ -301,7 +311,7 @@ private void ResolveTags(IList<OpenApiTag> tags)
 
         private bool IsUnresolvedReference(IOpenApiReferenceable possibleReference)
         {
-            return (possibleReference != null && possibleReference.UnresolvedReference);
+            return possibleReference != null && possibleReference.UnresolvedReference;
         }
     }
 }

src/Microsoft.OpenApi/Services/OpenApiWalker.cs

@@ -129,6 +129,17 @@ internal void Walk(OpenApiComponents components)
                 }
             });
 
+            Walk(OpenApiConstants.PathItems, () =>
+            {
+                if (components.PathItems != null)
+                {
+                    foreach (var path in components.PathItems)
+                    {
+                        Walk(path.Key, () => Walk(path.Value, isComponent: true));
+                    }
+                }
+            });
+
             Walk(OpenApiConstants.Parameters, () =>
             {
                 if (components.Parameters != null)
@@ -233,15 +244,17 @@ internal void Walk(IDictionary<string, OpenApiPathItem> webhooks)
             }
 
             _visitor.Visit(webhooks);
-            
+
             // Visit Webhooks
             if (webhooks != null)
             {
                 foreach (var pathItem in webhooks)
                 {
-                    Walk(pathItem.Key, () => Walk(pathItem.Value));
+                    _visitor.CurrentKeys.Path = pathItem.Key;
+                    Walk(pathItem.Key, () => Walk(pathItem.Value));// JSON Pointer uses ~1 as an escape character for /
+                    _visitor.CurrentKeys.Path = null;
                 }
-            }
+            };
         }
 
         /// <summary>
@@ -441,9 +454,9 @@ internal void Walk(OpenApiServerVariable serverVariable)
         /// <summary>
         /// Visits <see cref="OpenApiPathItem"/> and child objects
         /// </summary>
-        internal void Walk(OpenApiPathItem pathItem)
+        internal void Walk(OpenApiPathItem pathItem, bool isComponent = false)
         {
-            if (pathItem == null)
+            if (pathItem == null || ProcessAsReference(pathItem, isComponent))
             {
                 return;
             }