Creates component registries in the OpenApiWorkspace for $ref resolution

src/Microsoft.OpenApi/Models/OpenApiDocument.cs

@@ -5,12 +5,12 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Security.Cryptography;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Json.Schema;
-using Microsoft.OpenApi.Exceptions;
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Reader;
 using Microsoft.OpenApi.Services;
@@ -94,8 +94,12 @@
         /// <summary>
         /// Parameter-less constructor
         /// </summary>
-        public OpenApiDocument() { }
-
+        public OpenApiDocument() 
+        {
+            Workspace = new OpenApiWorkspace();
+            Workspace.AddDocument("/", this);
+        }
+
         /// <summary>
         /// Initializes a copy of an an <see cref="OpenApiDocument"/> object
         /// </summary>
@@ -124,7 +128,7 @@
 
             writer.WriteStartObject();
 
             // openApi;
             writer.WriteProperty(OpenApiConstants.OpenApi, "3.1.0");
 
             // jsonSchemaDialect
@@ -478,6 +482,29 @@
             return ResolveReference(reference, false);
         }
 
+        /// <summary>
+        /// Resolves JsonSchema refs
+        /// </summary>
+        /// <param name="referenceUri"></param>
+        /// <returns>A JsonSchema ref.</returns>
+        public JsonSchema ResolveJsonSchemaReference(Uri referenceUri)
+        {
+            if (referenceUri == null) return null;
+
+            OpenApiReference reference = new OpenApiReference() 
+            {
+                ExternalResource = referenceUri.OriginalString, 
+                Id = referenceUri.OriginalString.Split('/').Last(),
+                Type = ReferenceType.Schema
+            };
+
+            JsonSchema resolvedSchema = reference.ExternalResource.StartsWith("#")
+                ? (JsonSchema)Workspace.ResolveReference<IBaseDocument>(reference.Id, reference.Type, Components) // local ref
+                : Workspace.ResolveReference<JsonSchema>(reference); // external ref
+
+            return resolvedSchema;
+        }
+
         /// <summary>
         /// Takes in an OpenApi document instance and generates its hash value
         /// </summary>
@@ -522,14 +549,14 @@
                 return null;
             }
 
             // Todo: Verify if we need to check to see if this external reference is actually targeted at this document.
             if (useExternal)
             {
-                if (this.Workspace == null)
+                if (Workspace == null)
                 {
                     throw new ArgumentException(Properties.SRResource.WorkspaceRequredForExternalReferenceResolution);
                 }
-                return this.Workspace.ResolveReference(reference);
+                return Workspace.ResolveReference<IOpenApiReferenceable>(reference);
             }
 
             if (!reference.Type.HasValue)
@@ -552,68 +579,7 @@
                 return null;
             }
 
-            if (this.Components == null)
-            {
-                throw new OpenApiException(string.Format(Properties.SRResource.InvalidReferenceId, reference.Id));
-            }
-
-            try
-            {
-                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;
-
-                    case ReferenceType.Response:
-                        var resolvedResponse = this.Components.Responses[reference.Id];
-                        resolvedResponse.Description = reference.Description ?? resolvedResponse.Description;
-                        return resolvedResponse;
-
-                    case ReferenceType.Parameter:
-                        var resolvedParameter = this.Components.Parameters[reference.Id];
-                        resolvedParameter.Description = reference.Description ?? resolvedParameter.Description;
-                        return resolvedParameter;
-
-                    case ReferenceType.Example:
-                        var resolvedExample = this.Components.Examples[reference.Id];
-                        resolvedExample.Summary = reference.Summary ?? resolvedExample.Summary;
-                        resolvedExample.Description = reference.Description ?? resolvedExample.Description;
-                        return resolvedExample;
-
-                    case ReferenceType.RequestBody:
-                        var resolvedRequestBody = this.Components.RequestBodies[reference.Id];
-                        resolvedRequestBody.Description = reference.Description ?? resolvedRequestBody.Description;
-                        return resolvedRequestBody;
-
-                    case ReferenceType.Header:
-                        var resolvedHeader = this.Components.Headers[reference.Id];
-                        resolvedHeader.Description = reference.Description ?? resolvedHeader.Description;
-                        return resolvedHeader;
-
-                    case ReferenceType.SecurityScheme:
-                        var resolvedSecurityScheme = this.Components.SecuritySchemes[reference.Id];
-                        resolvedSecurityScheme.Description = reference.Description ?? resolvedSecurityScheme.Description;
-                        return resolvedSecurityScheme;
-
-                    case ReferenceType.Link:
-                        var resolvedLink = this.Components.Links[reference.Id];
-                        resolvedLink.Description = reference.Description ?? resolvedLink.Description;
-                        return resolvedLink;
-
-                    case ReferenceType.Callback:
-                        return this.Components.Callbacks[reference.Id];
-
-                    default:
-                        throw new OpenApiException(Properties.SRResource.InvalidReferenceType);
-                }
-            }
-            catch (KeyNotFoundException)
-            {
-                throw new OpenApiException(string.Format(Properties.SRResource.InvalidReferenceId, reference.Id));
-            }
+            return Workspace.ResolveReference<IOpenApiReferenceable>(reference.Id, reference.Type, Components);
         }
 
         /// <summary>

src/Microsoft.OpenApi/Models/References/OpenApiCallbackReference.cs

@@ -34,7 +34,7 @@ private OpenApiCallback Target
         /// <param name="hostDocument">The host OpenAPI document.</param>
         /// <param name="externalResource">Optional: External resource in the reference.
         /// It may be:
-        /// 1. a absolute/relative file path, for example:  ../commons/pet.json
+        /// 1. an absolute/relative file path, for example:  ../commons/pet.json
         /// 2. a Url, for example: http://localhost/pet.json
         /// </param>
         public OpenApiCallbackReference(string referenceId, OpenApiDocument hostDocument, string externalResource = null)

src/Microsoft.OpenApi/Reader/Services/OpenApiRemoteReferenceCollector.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
+using System;
 using System.Collections.Generic;
 using Microsoft.OpenApi.Interfaces;
 using Microsoft.OpenApi.Models;
@@ -14,9 +15,10 @@
     internal class OpenApiRemoteReferenceCollector : OpenApiVisitorBase
     {
         private readonly Dictionary<string, OpenApiReference> _references = new();
+        private Guid _guid = new();
 
         /// <summary>
-        /// List of external references collected from OpenApiDocument
+        /// List of all internal and external references collected from OpenApiDocument
         /// </summary>
         public IEnumerable<OpenApiReference> References
         {
@@ -32,19 +34,28 @@
         /// <param name="referenceable"></param>
         public override void Visit(IOpenApiReferenceable referenceable)
         {
-            AddReference(referenceable.Reference);
+            AddReferences(referenceable.Reference);
         }
 
         /// <summary>
-        /// Collect external reference
+        /// Collect internal and external references
         /// </summary>
-        private void AddReference(OpenApiReference reference)
+        private void AddReferences(OpenApiReference reference)
         {
+            // External refs
             if (reference is {IsExternal: true} &&
                 !_references.ContainsKey(reference.ExternalResource))
             {
                 _references.Add(reference.ExternalResource, reference);
             }
+
+            // Local refs
+            if (reference is { IsExternal: false } &&
+                !_references.ContainsKey(reference.ReferenceV3))
+            {
+                reference.ExternalResource = _guid.ToString();
+                _references.Add(reference.ReferenceV3, reference);
+            }
         }
     }
 }

src/Microsoft.OpenApi/Reader/Services/OpenApiWorkspaceLoader.cs

@@ -39,21 +39,32 @@ internal async Task<OpenApiDiagnostic> LoadAsync(OpenApiReference reference,
             // Walk references
             foreach (var item in referenceCollector.References)
             {
+
                 // If not already in workspace, load it and process references
                 if (!_workspace.Contains(item.ExternalResource))
                 {
-                    var input = await _loader.LoadAsync(new(item.ExternalResource, UriKind.RelativeOrAbsolute));
-                    var result = await OpenApiDocument.LoadAsync(input, format, _readerSettings, cancellationToken);
-                    // Merge diagnostics
-                    if (result.OpenApiDiagnostic != null)
+                    if (!Guid.TryParse(item.ExternalResource, out _))
                     {
-                        diagnostic.AppendDiagnostic(result.OpenApiDiagnostic, item.ExternalResource);
+                        var input = await _loader.LoadAsync(new(item.ExternalResource, UriKind.RelativeOrAbsolute));
+                        var result = await OpenApiDocument.LoadAsync(input, format, _readerSettings, cancellationToken);
+                        // Merge diagnostics
+                        if (result.OpenApiDiagnostic != null)
+                        {
+                            diagnostic.AppendDiagnostic(result.OpenApiDiagnostic, item.ExternalResource);
+                        }
+                        if (result.OpenApiDocument != null)
+                        {
+                            var loadDiagnostic = await LoadAsync(item, result.OpenApiDocument, format, diagnostic, cancellationToken);
+                            diagnostic = loadDiagnostic;
+                        }
                     }
-                    if (result.OpenApiDocument != null)
+                    else // local ref in an external file, add this to the documents registry
                     {
-                        var loadDiagnostic = await LoadAsync(item, result.OpenApiDocument, format,  diagnostic, cancellationToken);
-                        diagnostic = loadDiagnostic;
-                    }
+                        if (!_workspace.Contains(item.ExternalResource))
+                        {
+                            _workspace.AddDocument(reference.ExternalResource, document);
+                        }
+                    }                    
                 }
             }
 

src/Microsoft.OpenApi/Reader/V2/OpenApiDocumentDeserializer.cs

@@ -263,7 +263,12 @@
             MakeServers(openApidoc.Servers, openApiNode.Context, rootNode);
 
             FixRequestBodyReferences(openApidoc);
-            RegisterComponentsSchemasInGlobalRegistry(openApidoc.Components?.Schemas);
+
+            // Register components
+            //if (openApidoc.Components != null)
+            //{
+            //    openApidoc.Workspace.RegisterComponents(openApidoc.BaseUri, openApidoc.Components);
+            //}
 
             return openApidoc;
         }

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

@@ -44,13 +44,6 @@ public static OpenApiComponents LoadComponents(ParseNode node)
             var components = new OpenApiComponents();
 
             ParseMap(mapNode, components, _componentsFixedFields, _componentsPatternFields);
-
-            foreach (var schema in components.Schemas)
-            {
-                var refUri = new Uri(OpenApiConstants.V3ReferenceUri + schema.Key);
-                SchemaRegistry.Global.Register(refUri, schema.Value);
-            }
-
             return components;
         }
     }

src/Microsoft.OpenApi/Reader/V3/OpenApiDocumentDeserializer.cs

@@ -51,6 +51,11 @@
 
             ParseMap(openApiNode, openApidoc, _openApiFixedFields, _openApiPatternFields);
 
+            //if (openApidoc.Components != null)
+            //{
+            //    openApidoc.Workspace.RegisterComponents(openApidoc);
+            //}
+
             return openApidoc;
         }
     }

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

@@ -42,12 +42,6 @@ public static OpenApiComponents LoadComponents(ParseNode node)
 
             ParseMap(mapNode, components, _componentsFixedFields, _componentsPatternFields);
 
-            foreach (var schema in components.Schemas)
-            {
-                var refUri = new Uri(OpenApiConstants.V3ReferenceUri + schema.Key);
-                SchemaRegistry.Global.Register(refUri, schema.Value);
-            }
-
             return components;
         }
     }

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

@@ -9,7 +9,7 @@ namespace Microsoft.OpenApi.Reader.V31
     /// runtime Open API object model.
     /// </summary>
     internal static partial class OpenApiV31Deserializer
-    {
+  {
         private static readonly FixedFieldMap<OpenApiDocument> _openApiFixedFields = new()
         {
             {

src/Microsoft.OpenApi/Services/OpenApiReferenceResolver.cs

@@ -251,9 +251,8 @@
         /// <param name="summary">The schema's summary.</param>
         /// <returns></returns>
         public JsonSchema ResolveJsonSchemaReference(Uri reference, string description = null, string summary = null)
-        {
-            var refUri = $"https://registry{reference.OriginalString.Split('#').LastOrDefault()}";
-            var resolvedSchema = (JsonSchema)SchemaRegistry.Global.Get(new Uri(refUri));
+        {            
+            var resolvedSchema = _currentDocument.ResolveJsonSchemaReference(reference);
 
             if (resolvedSchema != null)
             {
@@ -410,7 +409,7 @@
             }
             // The concept of merging references with their target at load time is going away in the next major version
             // External references will not support this approach.
             //else if (_resolveRemoteReferences == true)
             //{
             //    if (_currentDocument.Workspace == null)
             //    {
@@ -424,7 +423,7 @@
             //    }
             //    var target = _currentDocument.Workspace.ResolveReference(reference);
 
             //    // TODO:  If it is a document fragment, then we should resolve it within the current context
 
             //    return target as T;
             //}