Merge pull request #1603 from microsoft/mk/use-proxy-reference-for-ref-resolution

Use proxy references to resolve references

Author: MaggieKimani1

src/Microsoft.OpenApi.Hidi/OpenApiService.cs

@@ -60,8 +60,10 @@ public static async Task TransformOpenApiDocument(HidiOptions options, ILogger l
                 if (options.Output == null)
                 {
 #pragma warning disable CA1308 // Normalize strings to uppercase
-                    var inputExtension = string.Concat(".", options.OpenApiFormat?.GetDisplayName().ToLowerInvariant())
-                        ?? GetInputPathExtension(options.OpenApi, options.Csdl);
+                    var extension = options.OpenApiFormat?.GetDisplayName().ToLowerInvariant();
+                    var inputExtension = !string.IsNullOrEmpty(extension) ? string.Concat(".", extension) 
+                        : GetInputPathExtension(options.OpenApi, options.Csdl);
+
 #pragma warning restore CA1308 // Normalize strings to uppercase
                     options.Output = new($"./output{inputExtension}");
                 };

src/Microsoft.OpenApi/Interfaces/IEffective.cs

@@ -26,8 +26,9 @@ internal interface IOpenApiVersionService
         /// </summary>
         /// <typeparam name="T">Type of element to load</typeparam>
         /// <param name="node">document fragment node</param>
+        /// <param name="doc">A host document instance.</param>
         /// <returns>Instance of OpenAPIElement</returns>
-        T LoadElement<T>(ParseNode node) where T : IOpenApiElement;
+        T LoadElement<T>(ParseNode node, OpenApiDocument doc = null) where T : IOpenApiElement;
 
         /// <summary>
         /// Converts a generic RootNode instance into a strongly typed OpenApiDocument

src/Microsoft.OpenApi/Interfaces/IOpenApiVersionService.cs

@@ -12,7 +12,7 @@ namespace Microsoft.OpenApi.Models
     /// <summary>
     /// Callback Object: A map of possible out-of band callbacks related to the parent operation.
     /// </summary>
-    public class OpenApiCallback : IOpenApiReferenceable, IOpenApiExtensible, IEffective<OpenApiCallback>
+    public class OpenApiCallback : IOpenApiReferenceable, IOpenApiExtensible
     {
         /// <summary>
         /// A Path Item Object used to define a callback request and expected responses.
@@ -61,10 +61,7 @@ public void AddPathItem(RuntimeExpression expression, OpenApiPathItem pathItem)
             Utils.CheckArgumentNull(expression);
             Utils.CheckArgumentNull(pathItem);
 
-            if (PathItems == null)
-            {
-                PathItems = new();
-            }
+            PathItems ??= new();
 
             PathItems.Add(expression, pathItem);
         }
@@ -102,40 +99,9 @@ private void SerializeInternal(IOpenApiWriter writer,
             Utils.CheckArgumentNull(writer);
 
             var target = this;
-            
-            if (Reference != null)
-            {
-                if (!writer.GetSettings().ShouldInlineReference(Reference))
-                {
-                    callback(writer, Reference);
-                    return;
-                }
-                else
-                {
-                    target = GetEffective(Reference.HostDocument);
-                }
-            }
-            
             action(writer, target);
         }
 
-        /// <summary>
-        /// Returns an effective OpenApiCallback object based on the presence of a $ref
-        /// </summary>
-        /// <param name="doc">The host OpenApiDocument that contains the reference.</param>
-        /// <returns>OpenApiCallback</returns>
-        public OpenApiCallback GetEffective(OpenApiDocument doc)
-        {
-            if (Reference != null)
-            {
-                return doc.ResolveReferenceTo<OpenApiCallback>(Reference);
-            }
-            else
-            {
-                return this;
-            }
-        }
-
         /// <summary>
         /// Serialize to OpenAPI V31 document without using reference.
         /// </summary>

src/Microsoft.OpenApi/Models/OpenApiCallback.cs

@@ -455,6 +455,16 @@ public IEnumerable<OpenApiError> ResolveReferences()
             return resolver.Errors;
         }
 
+        /// <summary>
+        /// Walks the OpenApiDocument and sets the host document for all referenceable objects
+        /// </summary>
+        public void SetHostDocument()
+        {
+            var resolver = new HostDocumentResolver(this);
+            var walker = new OpenApiWalker(resolver);
+            walker.Walk(this);
+        }
+
         /// <summary>
         /// Load the referenced <see cref="IOpenApiReferenceable"/> object from a <see cref="OpenApiReference"/> object
         /// </summary>
@@ -562,49 +572,30 @@ internal IOpenApiReferenceable ResolveReference(OpenApiReference reference, bool
                 switch (reference.Type)
                 {
                     case ReferenceType.PathItem:
-                        var resolvedPathItem = this.Components.PathItems[reference.Id];
-                        resolvedPathItem.Description = reference.Description ?? resolvedPathItem.Description;
-                        resolvedPathItem.Summary = reference.Summary ?? resolvedPathItem.Summary;
-                        return resolvedPathItem;
-
+                        return Components.PathItems[reference.Id];
                     case ReferenceType.Response:
-                        var resolvedResponse = this.Components.Responses[reference.Id];
-                        resolvedResponse.Description = reference.Description ?? resolvedResponse.Description;
-                        return resolvedResponse;
+                        return Components.Responses[reference.Id];
 
                     case ReferenceType.Parameter:
-                        var resolvedParameter = this.Components.Parameters[reference.Id];
-                        resolvedParameter.Description = reference.Description ?? resolvedParameter.Description;
-                        return resolvedParameter;
+                        return Components.Parameters[reference.Id];
 
                     case ReferenceType.Example:
-                        var resolvedExample = this.Components.Examples[reference.Id];
-                        resolvedExample.Summary = reference.Summary ?? resolvedExample.Summary;
-                        resolvedExample.Description = reference.Description ?? resolvedExample.Description;
-                        return resolvedExample;
+                        return Components.Examples[reference.Id];
 
                     case ReferenceType.RequestBody:
-                        var resolvedRequestBody = this.Components.RequestBodies[reference.Id];
-                        resolvedRequestBody.Description = reference.Description ?? resolvedRequestBody.Description;
-                        return resolvedRequestBody;
+                        return Components.RequestBodies[reference.Id];
 
                     case ReferenceType.Header:
-                        var resolvedHeader = this.Components.Headers[reference.Id];
-                        resolvedHeader.Description = reference.Description ?? resolvedHeader.Description;
-                        return resolvedHeader;
+                        return Components.Headers[reference.Id];
 
                     case ReferenceType.SecurityScheme:
-                        var resolvedSecurityScheme = this.Components.SecuritySchemes[reference.Id];
-                        resolvedSecurityScheme.Description = reference.Description ?? resolvedSecurityScheme.Description;
-                        return resolvedSecurityScheme;
+                        return Components.SecuritySchemes[reference.Id];
 
                     case ReferenceType.Link:
-                        var resolvedLink = this.Components.Links[reference.Id];
-                        resolvedLink.Description = reference.Description ?? resolvedLink.Description;
-                        return resolvedLink;
+                        return Components.Links[reference.Id];
 
                     case ReferenceType.Callback:
-                        return this.Components.Callbacks[reference.Id];
+                        return Components.Callbacks[reference.Id];
 
                     default:
                         throw new OpenApiException(Properties.SRResource.InvalidReferenceType);
@@ -716,6 +707,12 @@ public JsonSchema FindSubschema(Json.Pointer.JsonPointer pointer, EvaluationOpti
         {
             throw new NotImplementedException();
         }
+
+        internal JsonSchema ResolveJsonSchemaReference(Uri reference)
+        {
+            var referencePath = string.Concat("https://registry", reference.OriginalString.Split('#').Last());
+            return (JsonSchema)SchemaRegistry.Global.Get(new Uri(referencePath));
+        }
     }
 
     internal class FindSchemaReferences : OpenApiVisitorBase

src/Microsoft.OpenApi/Models/OpenApiDocument.cs

@@ -13,7 +13,7 @@ namespace Microsoft.OpenApi.Models
     /// <summary>
     /// Example Object.
     /// </summary>
-    public class OpenApiExample : IOpenApiReferenceable, IOpenApiExtensible, IEffective<OpenApiExample>
+    public class OpenApiExample : IOpenApiReferenceable, IOpenApiExtensible
     {
         /// <summary>
         /// Short description for the example.
@@ -101,39 +101,9 @@ internal virtual void SerializeInternal(IOpenApiWriter writer, Action<IOpenApiWr
             Utils.CheckArgumentNull(writer);
 
             var target = this;
-
-            if (Reference != null)
-            {
-                if (!writer.GetSettings().ShouldInlineReference(Reference))
-                {
-                    callback(writer, Reference);
-                    return;
-                }
-                else
-                {
-                    target = GetEffective(Reference.HostDocument);
-                }
-            }
             action(writer, target);
         }
 
-        /// <summary>
-        /// Returns an effective OpenApiExample object based on the presence of a $ref
-        /// </summary>
-        /// <param name="doc">The host OpenApiDocument that contains the reference.</param>
-        /// <returns>OpenApiExample</returns>
-        public OpenApiExample GetEffective(OpenApiDocument doc)
-        {
-            if (Reference != null)
-            {
-                return doc.ResolveReferenceTo<OpenApiExample>(this.Reference);
-            }
-            else
-            {
-                return this;
-            }
-        }
-
         /// <summary>
         /// Serialize to OpenAPI V31 example without using reference.
         /// </summary>

src/Microsoft.OpenApi/Models/OpenApiExample.cs

@@ -16,7 +16,7 @@ namespace Microsoft.OpenApi.Models
     /// Header Object.
     /// The Header Object follows the structure of the Parameter Object.
     /// </summary>
-    public class OpenApiHeader : IOpenApiReferenceable, IOpenApiExtensible, IEffective<OpenApiHeader>
+    public class OpenApiHeader : IOpenApiReferenceable, IOpenApiExtensible
     {
         private JsonSchema _schema;
 
@@ -145,40 +145,9 @@ private void SerializeInternal(IOpenApiWriter writer, Action<IOpenApiWriter, IOp
             Utils.CheckArgumentNull(writer);;
 
             var target = this;
-
-            if (Reference != null)
-            {
-                if (!writer.GetSettings().ShouldInlineReference(Reference))
-                {
-                    callback(writer, Reference);
-                    return;
-                }
-                else
-                {
-                    target = GetEffective(Reference.HostDocument);
-                }
-            }
-
             action(writer, target);
         }
 
-        /// <summary>
-        /// Returns an effective OpenApiHeader object based on the presence of a $ref
-        /// </summary>
-        /// <param name="doc">The host OpenApiDocument that contains the reference.</param>
-        /// <returns>OpenApiHeader</returns>
-        public OpenApiHeader GetEffective(OpenApiDocument doc)
-        {
-            if (Reference != null)
-            {
-                return doc.ResolveReferenceTo<OpenApiHeader>(Reference);
-            }
-            else
-            {
-                return this;
-            }
-        }
-
         /// <summary>
         /// Serialize to OpenAPI V31 document without using reference.
         /// </summary>
@@ -244,24 +213,11 @@ internal virtual void SerializeInternalWithoutReference(IOpenApiWriter writer, O
         /// <summary>
         /// Serialize <see cref="OpenApiHeader"/> to Open Api v2.0
         /// </summary>
-        public void SerializeAsV2(IOpenApiWriter writer)
+        public virtual void SerializeAsV2(IOpenApiWriter writer)
         {
-            Utils.CheckArgumentNull(writer);;
+            Utils.CheckArgumentNull(writer);
 
             var target = this;
-
-            if (Reference != null)
-            {
-                if (!writer.GetSettings().ShouldInlineReference(Reference))
-                {
-                    Reference.SerializeAsV2(writer);
-                    return;
-                }
-                else
-                {
-                    target = GetEffective(Reference.HostDocument);
-                }
-            }
             target.SerializeAsV2WithoutReference(writer);
         }
 

src/Microsoft.OpenApi/Models/OpenApiHeader.cs

@@ -11,7 +11,7 @@ namespace Microsoft.OpenApi.Models
     /// <summary>
     /// Link Object.
     /// </summary>
-    public class OpenApiLink : IOpenApiReferenceable, IOpenApiExtensible, IEffective<OpenApiLink>
+    public class OpenApiLink : IOpenApiReferenceable, IOpenApiExtensible
     {
         /// <summary>
         /// A relative or absolute reference to an OAS operation.
@@ -106,39 +106,9 @@ private void SerializeInternal(IOpenApiWriter writer, Action<IOpenApiWriter, IOp
             Utils.CheckArgumentNull(writer);
 
             var target = this;
-
-            if (Reference != null)
-            {
-                if (!writer.GetSettings().ShouldInlineReference(Reference))
-                {
-                    callback(writer, Reference);
-                    return;
-                }
-                else
-                {
-                    target = GetEffective(Reference.HostDocument);
-                }
-            }
             action(writer, target);
         }
 
-        /// <summary>
-        /// Returns an effective OpenApiLink object based on the presence of a $ref
-        /// </summary>
-        /// <param name="doc">The host OpenApiDocument that contains the reference.</param>
-        /// <returns>OpenApiLink</returns>
-        public OpenApiLink GetEffective(OpenApiDocument doc)
-        {
-            if (Reference != null)
-            {
-                return doc.ResolveReferenceTo<OpenApiLink>(Reference);
-            }
-            else
-            {
-                return this;
-            }
-        }
-
         /// <summary>
         /// Serialize to OpenAPI V31 document without using reference.
         /// </summary>