Refactor readers to reduce surface area

src/Microsoft.OpenApi.Readers/OpenApiYamlReader.cs

@@ -49,7 +49,7 @@ public ReadResult Read(MemoryStream input,
             if (settings is null) throw new ArgumentNullException(nameof(settings));
             JsonNode jsonNode;
 
-            // Parse the YAML text in the TextReader into a sequence of JsonNodes
+            // Parse the YAML text in the stream into a sequence of JsonNodes
             try
             {
                 using var stream = new StreamReader(input, default, true, -1, settings.LeaveStreamOpen);

src/Microsoft.OpenApi/Interfaces/IOpenApiReader.cs

@@ -17,7 +17,7 @@ public interface IOpenApiReader
         /// <summary>
         /// Async method to reads the stream and parse it into an Open API document.
         /// </summary>
-        /// <param name="input">The TextReader input.</param>
+        /// <param name="input">The stream input.</param>
         /// <param name="settings"> The OpenApi reader settings.</param>
         /// <param name="cancellationToken">Propagates notification that an operation should be cancelled.</param>
         /// <returns></returns>
@@ -43,7 +43,7 @@ public interface IOpenApiReader
         /// <summary>
         /// Reads the MemoryStream and parses the fragment of an OpenAPI description into an Open API Element.
         /// </summary>
-        /// <param name="input">TextReader containing OpenAPI description to parse.</param>
+        /// <param name="input">Memory stream containing OpenAPI description to parse.</param>
         /// <param name="version">Version of the OpenAPI specification that the fragment conforms to.</param>
         /// <param name="diagnostic">Returns diagnostic object containing errors detected during parsing.</param>
         /// <param name="settings">The OpenApiReader settings.</param>
@@ -53,7 +53,7 @@ public interface IOpenApiReader
         /// <summary>
         /// Reads the JsonNode input and parses the fragment of an OpenAPI description into an Open API Element.
         /// </summary>
-        /// <param name="input">TextReader containing OpenAPI description to parse.</param>
+        /// <param name="input">Memory stream containing OpenAPI description to parse.</param>
         /// <param name="version">Version of the OpenAPI specification that the fragment conforms to.</param>
         /// <param name="diagnostic">Returns diagnostic object containing errors detected during parsing.</param>
         /// <param name="settings">The OpenApiReader settings.</param>

src/Microsoft.OpenApi/Reader/OpenApiJsonReader.cs

@@ -12,6 +12,7 @@
 using Microsoft.OpenApi.Validations;
 using System.Linq;
 using Microsoft.OpenApi.Interfaces;
+using System;
 
 namespace Microsoft.OpenApi.Reader
 {
@@ -23,17 +24,20 @@ public class OpenApiJsonReader : IOpenApiReader
         /// <summary>
         /// Reads the memory stream input and parses it into an Open API document.
         /// </summary>
-        /// <param name="input">TextReader containing OpenAPI description to parse.</param>
+        /// <param name="input">Memory stream containing OpenAPI description to parse.</param>
         /// <param name="settings">The Reader settings to be used during parsing.</param>
         /// <returns></returns>
         public ReadResult Read(MemoryStream input,
                                OpenApiReaderSettings settings)
         {
+            if (input is null) throw new ArgumentNullException(nameof(input));
+            if (settings is null) throw new ArgumentNullException(nameof(settings));
+
             JsonNode jsonNode;
             var diagnostic = new OpenApiDiagnostic();
             settings ??= new OpenApiReaderSettings();
 
-            // Parse the JSON text in the TextReader into JsonNodes
+            // Parse the JSON text in the stream into JsonNodes
             try
             {
                 jsonNode = JsonNode.Parse(input);
@@ -62,6 +66,9 @@ public ReadResult Read(JsonNode jsonNode,
                                OpenApiReaderSettings settings,
                                string format = null)
         {
+            if (jsonNode is null) throw new ArgumentNullException(nameof(jsonNode));
+            if (settings is null) throw new ArgumentNullException(nameof(settings));
+
             var diagnostic = new OpenApiDiagnostic();
             var context = new ParsingContext(diagnostic)
             {
@@ -106,19 +113,21 @@ public ReadResult Read(JsonNode jsonNode,
         /// <summary>
         /// Reads the stream input asynchronously and parses it into an Open API document.
         /// </summary>
-        /// <param name="input">TextReader containing OpenAPI description to parse.</param>
+        /// <param name="input">Memory stream containing OpenAPI description to parse.</param>
         /// <param name="settings">The Reader settings to be used during parsing.</param>
         /// <param name="cancellationToken">Propagates notifications that operations should be cancelled.</param>
         /// <returns></returns>
         public async Task<ReadResult> ReadAsync(Stream input,
                                                 OpenApiReaderSettings settings,
                                                 CancellationToken cancellationToken = default)
         {
+            if (input is null) throw new ArgumentNullException(nameof(input));
+            if (settings is null) throw new ArgumentNullException(nameof(settings));
+
             JsonNode jsonNode;
             var diagnostic = new OpenApiDiagnostic();
-            settings ??= new OpenApiReaderSettings();
 
-            // Parse the JSON text in the TextReader into JsonNodes
+            // Parse the JSON text in the stream into JsonNodes
             try
             {
                 jsonNode = await JsonNode.ParseAsync(input, cancellationToken: cancellationToken).ConfigureAwait(false);
@@ -142,6 +151,8 @@ public T ReadFragment<T>(MemoryStream input,
                                  out OpenApiDiagnostic diagnostic,
                                  OpenApiReaderSettings settings = null) where T : IOpenApiElement
         {
+            if (input is null) throw new ArgumentNullException(nameof(input));
+
             JsonNode jsonNode;
 
             // Parse the JSON
@@ -195,7 +206,5 @@ public T ReadFragment<T>(JsonNode input,
 
             return (T)element;
         }
-
-
     }
 }

src/Microsoft.OpenApi/Reader/OpenApiModelFactory.cs

@@ -39,6 +39,7 @@
                                       string format = null,
                                       OpenApiReaderSettings settings = null)
         {
+            if (stream is null) throw new ArgumentNullException(nameof(stream));
             settings ??= new OpenApiReaderSettings();
 
             // Get the format of the stream if not provided
@@ -53,35 +54,6 @@
             return result;
         }
 
-        /// <summary>
-        /// Reads the stream input and ensures it is buffered before passing it to the Load method.
-        /// </summary>
-        /// <typeparam name="T"></typeparam>
-        /// <param name="input"></param>
-        /// <param name="version"></param>
-        /// <param name="format"></param>
-        /// <param name="diagnostic"></param>
-        /// <param name="settings"></param>
-        /// <returns></returns>
-        public static T Load<T>(Stream input,
-                                OpenApiSpecVersion version,
-                                out OpenApiDiagnostic diagnostic,
-                                string format = null,
-                                OpenApiReaderSettings settings = null) where T : IOpenApiElement
-        {
-            if (input is MemoryStream memoryStream)
-            {
-                return Load<T>(memoryStream, version, format, out diagnostic, settings);
-            }
-            else
-            {
-                memoryStream = new MemoryStream();
-                input.CopyTo(memoryStream);
-                memoryStream.Position = 0;
-                return Load<T>(memoryStream, version, format, out diagnostic, settings);
-            }
-        }
-
         /// <summary>
         /// Reads the stream input and parses the fragment of an OpenAPI description into an Open API Element.
         /// </summary>
@@ -104,11 +76,12 @@
         /// </summary>
         /// <param name="url">The path to the OpenAPI file</param>
         /// <param name="settings"> The OpenApi reader settings.</param>
+        /// <param name="token"></param>
         /// <returns></returns>
-        public static async Task<ReadResult> LoadAsync(string url, OpenApiReaderSettings settings = null)
+        public static async Task<ReadResult> LoadAsync(string url, OpenApiReaderSettings settings = null, CancellationToken token = default)
         {
-            var result = await RetrieveStreamAndFormatAsync(url);
-            return await LoadAsync(result.Item1, result.Item2, settings).ConfigureAwait(false);
+            var result = await RetrieveStreamAndFormatAsync(url, token).ConfigureAwait(false);
+            return await LoadAsync(result.Item1, result.Item2, settings, token).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -118,12 +91,13 @@
         /// <param name="url">The path to the OpenAPI file</param>
         /// <param name="version">Version of the OpenAPI specification that the fragment conforms to.</param>
         /// <param name="settings">The OpenApiReader settings.</param>
+        /// <param name="token"></param>
         /// <returns>Instance of newly created IOpenApiElement.</returns>
         /// <returns>The OpenAPI element.</returns>
-        public static async Task<T> LoadAsync<T>(string url, OpenApiSpecVersion version, OpenApiReaderSettings settings = null) where T : IOpenApiElement
+        public static async Task<T> LoadAsync<T>(string url, OpenApiSpecVersion version, OpenApiReaderSettings settings = null, CancellationToken token = default) where T : IOpenApiElement
         {
-            var result = await RetrieveStreamAndFormatAsync(url).ConfigureAwait(false);
-            return Load<T>(result.Item1, version, out var _, result.Item2, settings);
+            var result = await RetrieveStreamAndFormatAsync(url, token).ConfigureAwait(false);
+            return await LoadAsync<T>(result.Item1, version, result.Item2, settings);
         }
 
         /// <summary>
@@ -136,7 +110,9 @@
         /// <returns></returns>
         public static async Task<ReadResult> LoadAsync(Stream input, string format = null, OpenApiReaderSettings settings = null, CancellationToken cancellationToken = default)
         {
+            if (input is null) throw new ArgumentNullException(nameof(input));
             settings ??= new OpenApiReaderSettings();
+
             Stream preparedStream;
             if (format is null)
             {
@@ -150,7 +126,7 @@
             }
 
             // Use StreamReader to process the prepared stream (buffered for YAML, direct for JSON)
-            var result = await InternalLoadAsync(preparedStream, format, settings, cancellationToken);
+            var result = await InternalLoadAsync(preparedStream, format, settings, cancellationToken).ConfigureAwait(false);
             if (!settings.LeaveStreamOpen)
             {
                 input.Dispose();
@@ -159,6 +135,34 @@
             return result;
         }
 
+        /// <summary>
+        /// Reads the stream input and ensures it is buffered before passing it to the Load method.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="input"></param>
+        /// <param name="version"></param>
+        /// <param name="format"></param>
+        /// <param name="settings"></param>
+        /// <returns></returns>
+        public static async Task<T> LoadAsync<T>(Stream input,
+                                                 OpenApiSpecVersion version,
+                                                 string format = null,
+                                                 OpenApiReaderSettings settings = null) where T : IOpenApiElement
+        {
+            if (input is null) throw new ArgumentNullException(nameof(input));
+            if (input is MemoryStream memoryStream)
+            {
+                return Load<T>(memoryStream, version, format, out var _, settings);
+            }
+            else
+            {
+                memoryStream = new MemoryStream();
+                await input.CopyToAsync(memoryStream).ConfigureAwait(false);
+                memoryStream.Position = 0;
+                return Load<T>(memoryStream, version, format, out var _, settings);
+            }
+        }
+
         /// <summary>
         /// Reads the input string and parses it into an Open API document.
         /// </summary>
@@ -170,6 +174,7 @@
                                        string format = null,
                                        OpenApiReaderSettings settings = null)
         {
+            if (input is null) throw new ArgumentNullException(nameof(input));
             format ??= InspectInputFormat(input);
             settings ??= new OpenApiReaderSettings();
 
@@ -194,6 +199,7 @@
                                  string format = null,
                                  OpenApiReaderSettings settings = null) where T : IOpenApiElement
         {
+            if (input is null) throw new ArgumentNullException(nameof(input));
             format ??= InspectInputFormat(input);
             settings ??= new OpenApiReaderSettings();
             using var stream = new MemoryStream(Encoding.UTF8.GetBytes(input));
@@ -209,7 +215,7 @@
 
             if (settings?.LoadExternalRefs ?? DefaultReaderSettings.LoadExternalRefs)
             {
-                var diagnosticExternalRefs = await LoadExternalRefsAsync(readResult.Document, cancellationToken, settings, format);
+                var diagnosticExternalRefs = await LoadExternalRefsAsync(readResult.Document, settings, format, cancellationToken).ConfigureAwait(false);
                 // Merge diagnostics of external reference
                 if (diagnosticExternalRefs != null)
                 {
@@ -221,7 +227,7 @@
             return readResult;
         }
 
-        private static async Task<OpenApiDiagnostic> LoadExternalRefsAsync(OpenApiDocument document, CancellationToken cancellationToken, OpenApiReaderSettings settings, string format = null)
+        private static async Task<OpenApiDiagnostic> LoadExternalRefsAsync(OpenApiDocument document, OpenApiReaderSettings settings, string format = null, CancellationToken token = default)
         {
             // Create workspace for all documents to live in.
             var baseUrl = settings.BaseUrl ?? new Uri(OpenApiConstants.BaseRegistryUri);
@@ -230,7 +236,7 @@
             // Load this root document into the workspace
             var streamLoader = new DefaultStreamLoader(settings.BaseUrl);
             var workspaceLoader = new OpenApiWorkspaceLoader(openApiWorkSpace, settings.CustomExternalLoader ?? streamLoader, settings);
-            return await workspaceLoader.LoadAsync(new OpenApiReference() { ExternalResource = "/" }, document, format ?? OpenApiConstants.Json, null, cancellationToken).ConfigureAwait(false);
+            return await workspaceLoader.LoadAsync(new OpenApiReference() { ExternalResource = "/" }, document, format ?? OpenApiConstants.Json, null, token).ConfigureAwait(false);
         }
 
         private static ReadResult InternalLoad(MemoryStream input, string format, OpenApiReaderSettings settings)
@@ -246,7 +252,7 @@
             return readResult;
         }
 
-        private static async Task<(Stream, string)> RetrieveStreamAndFormatAsync(string url)
+        private static async Task<(Stream, string)> RetrieveStreamAndFormatAsync(string url, CancellationToken token = default)
         {
             if (!string.IsNullOrEmpty(url))
             {
@@ -256,11 +262,15 @@
                 if (url.StartsWith("http", StringComparison.OrdinalIgnoreCase)
                     || url.StartsWith("https", StringComparison.OrdinalIgnoreCase))
                 {
-                    var response = await _httpClient.GetAsync(url);
+                    var response = await _httpClient.GetAsync(url, token).ConfigureAwait(false);
                     var mediaType = response.Content.Headers.ContentType.MediaType;
                     var contentType = mediaType.Split(";".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)[0];
                     format = contentType.Split('/').LastOrDefault();
+#if NETSTANDARD2_0
                     stream = await response.Content.ReadAsStreamAsync();
+#else
+                    stream = await response.Content.ReadAsStreamAsync(token).ConfigureAwait(false);;
+#endif
                     return (stream, format);
                 }
                 else
@@ -341,7 +351,7 @@
                 else
                 {
                     // YAML or other non-JSON format; copy remaining input to a new stream.
                     preparedStream = new MemoryStream();
                     bufferStream.Position = 0;
                     await bufferStream.CopyToAsync(preparedStream, 81920, token).ConfigureAwait(false); // Copy buffered portion
                     await input.CopyToAsync(preparedStream, 81920, token).ConfigureAwait(false); // Copy remaining data
@@ -355,7 +365,7 @@
                 if (!format.Equals(OpenApiConstants.Json, StringComparison.OrdinalIgnoreCase))
                 {
                     // Buffer stream for non-JSON formats (e.g., YAML) since they require synchronous reading
                     preparedStream = new MemoryStream();
                     await input.CopyToAsync(preparedStream, 81920, token).ConfigureAwait(false);
                     preparedStream.Position = 0;
                 }

test/Microsoft.OpenApi.Readers.Tests/V3Tests/OpenApiEncodingTests.cs

@@ -35,12 +35,12 @@ public async Task ParseBasicEncodingShouldSucceed()
         }
 
         [Fact]
-        public void ParseAdvancedEncodingShouldSucceed()
+        public async Task ParseAdvancedEncodingShouldSucceed()
         {
             using var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "advancedEncoding.yaml"));
 
             // Act
-            var encoding = OpenApiModelFactory.Load<OpenApiEncoding>(stream, OpenApiSpecVersion.OpenApi3_0, out _);
+            var encoding = await OpenApiModelFactory.LoadAsync<OpenApiEncoding>(stream, OpenApiSpecVersion.OpenApi3_0);
 
             // Assert
             encoding.Should().BeEquivalentTo(

test/Microsoft.OpenApi.Readers.Tests/V3Tests/OpenApiInfoTests.cs

@@ -109,12 +109,12 @@ public async Task ParseBasicInfoShouldSucceed()
         }
 
         [Fact]
-        public void ParseMinimalInfoShouldSucceed()
+        public async Task ParseMinimalInfoShouldSucceed()
         {
             using var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "minimalInfo.yaml"));
 
             // Act
-            var openApiInfo = OpenApiModelFactory.Load<OpenApiInfo>(stream, OpenApiSpecVersion.OpenApi3_0, out _, "yaml");
+            var openApiInfo = await OpenApiModelFactory.LoadAsync<OpenApiInfo>(stream, OpenApiSpecVersion.OpenApi3_0);
 
             // Assert
             openApiInfo.Should().BeEquivalentTo(