Updated with latest Apimanifest changes

Author: darrelmiller

src/Microsoft.OpenApi.Hidi/OpenApiService.cs

@@ -67,21 +67,18 @@ public static async Task TransformOpenApiDocument(HidiOptions options, ILogger l
                 OpenApiFormat openApiFormat = options.OpenApiFormat ?? (!string.IsNullOrEmpty(options.OpenApi) ? GetOpenApiFormat(options.OpenApi, logger) : OpenApiFormat.Yaml);
                 OpenApiSpecVersion openApiVersion = options.Version != null ? TryParseOpenApiSpecVersion(options.Version) : OpenApiSpecVersion.OpenApi3_0;
 
-                // If API Manifest is provided, load it, use it get the OpenAPI path
-                ApiManifestDocument apiManifest = null;
-                if (!string.IsNullOrEmpty(options.FilterOptions?.FilterByApiManifest))
-                {
-                    using(var fileStream = await GetStream(options.FilterOptions.FilterByApiManifest, logger, cancellationToken)) {
-                        apiManifest = ApiManifestDocument.Load(JsonDocument.Parse(fileStream).RootElement);
-                    }
-                    options.OpenApi = apiManifest.ApiDependencies[0].ApiDescripionUrl;
+                // If ApiManifest is provided, set the referenced OpenAPI document
+                var apiDependency = await FindApiDependency(options.FilterOptions?.FilterByApiManifest, logger, cancellationToken);
+                if (apiDependency != null) {
+                    options.OpenApi = apiDependency.ApiDescripionUrl;
                 }
 
                 // If Postman Collection is provided, load it
                 JsonDocument postmanCollection = null;
                 if (!String.IsNullOrEmpty(options.FilterOptions?.FilterByCollection))
                 {
-                    using (var collectionStream = await GetStream(options.FilterOptions.FilterByCollection, logger, cancellationToken)) {
+                    using (var collectionStream = await GetStream(options.FilterOptions.FilterByCollection, logger, cancellationToken))
+                    {
                         postmanCollection = JsonDocument.Parse(collectionStream);
                     }
                 }
@@ -91,7 +88,7 @@ public static async Task TransformOpenApiDocument(HidiOptions options, ILogger l
 
                 if (options.FilterOptions != null)
                 {
-                    document = ApplyFilters(options, logger, apiManifest, postmanCollection, document, cancellationToken);
+                    document = ApplyFilters(options, logger, apiDependency, postmanCollection, document, cancellationToken);
                 }
 
                 var languageFormat = options.SettingsConfig?.GetSection("LanguageFormat")?.Value;
@@ -118,20 +115,50 @@ public static async Task TransformOpenApiDocument(HidiOptions options, ILogger l
             }
         }
 
-        private static OpenApiDocument ApplyFilters(HidiOptions options, ILogger logger, ApiManifestDocument apiManifest, JsonDocument postmanCollection, OpenApiDocument document, CancellationToken cancellationToken)
+        private static async Task<ApiDependency> FindApiDependency(string apiManifestPath, ILogger logger, CancellationToken cancellationToken)
+        {
+            ApiDependency apiDependency = null;
+            // If API Manifest is provided, load it, use it get the OpenAPI path
+            ApiManifestDocument apiManifest = null;
+            if (!string.IsNullOrEmpty(apiManifestPath))
+            {
+                // Extract fragment identifier if passed as the name of the ApiDependency
+                var apiManifestRef = apiManifestPath.Split('#');
+                string apiDependencyName = null;
+                if (apiManifestRef.Length > 1)
+                {
+                    apiDependencyName = apiManifestRef[1];
+                }
+                using (var fileStream = await GetStream(apiManifestRef[0], logger, cancellationToken))
+                {
+                    apiManifest = ApiManifestDocument.Load(JsonDocument.Parse(fileStream).RootElement);
+                }
+                if (apiDependencyName != null)
+                {
+                    apiDependency = apiManifest.ApiDependencies[apiDependencyName];
+                }
+                else
+                {
+                    apiDependency = apiManifest.ApiDependencies.First().Value;
+                }
+            }
+
+            return apiDependency;
+        }
+
+        private static OpenApiDocument ApplyFilters(HidiOptions options, ILogger logger, ApiDependency apiDependency, JsonDocument postmanCollection, OpenApiDocument document, CancellationToken cancellationToken)
         {
             Dictionary<string, List<string>> requestUrls = null;
-            if (apiManifest != null)
+            if (apiDependency != null)
             {
-                requestUrls = GetRequestUrlsFromManifest(apiManifest, document);
+                requestUrls = GetRequestUrlsFromManifest(apiDependency, document);
             }
             else if (postmanCollection != null)
             {
                 requestUrls = EnumerateJsonDocument(postmanCollection.RootElement, requestUrls);
                 logger.LogTrace("Finished fetching the list of paths and Http methods defined in the Postman collection.");
             }
 
-
             logger.LogTrace("Creating predicate from filter options.");
             var predicate = FilterOpenApiDocument(options.FilterOptions.FilterByOperationIds,
                                                     options.FilterOptions.FilterByTags,
@@ -253,15 +280,14 @@ private static async Task<OpenApiDocument> GetOpenApi(string openapi, string csd
             return predicate;
         }
 
-        private static Dictionary<string, List<string>> GetRequestUrlsFromManifest(ApiManifestDocument apiManifestDocument, OpenApiDocument document)
+        private static Dictionary<string, List<string>> GetRequestUrlsFromManifest(ApiDependency apiDependency, OpenApiDocument document)
         {
             // Get the request URLs from the API Dependencies in the API manifest that have a baseURL that matches the server URL in the OpenAPI document
             var serversUrls = document.Servers.Select(s => s.Url);
-            var requests = apiManifestDocument.ApiDependencies
-                    .Where(a => serversUrls.Any(s => s == a.BaseUrl))
-                    .SelectMany(ad => ad.Requests.Where(r => r.Exclude == false)
-                                .Select(r=> new { BaseUrl=ad.BaseUrl, UriTemplate= r.UriTemplate, Method=r.Method } ))
-                    .GroupBy(r => r.BaseUrl.TrimEnd('/') + r.UriTemplate)   // The OpenApiFilterService expects non-relative URLs.
+            var requests = apiDependency
+                    .Requests.Where(r => r.Exclude == false)
+                                .Select(r=> new { UriTemplate= r.UriTemplate, Method=r.Method } )
+                    .GroupBy(r => r.UriTemplate)
                     .ToDictionary(g => g.Key, g => g.Select(r => r.Method).ToList());
             // This makes the assumption that the UriTemplate in the ApiManifest matches exactly the UriTemplate in the OpenAPI document
             // This does not need to be the case.  The URI template in the API manifest could map to a set of OpenAPI paths.

src/Microsoft.OpenApi.Hidi/readme.md

@@ -80,6 +80,7 @@ This command accepts the following parameters:
 	• --filterByOperationIds(-op) - Slice document based on OperationId(s) provided. Accepts a comma delimited list of operation ids. 
 	• --filterByTags(-t) - Slice document based on tag(s) provided. Accepts a comma delimited list of tags. 
 	• --filterByCollection(-c) - Slices the OpenAPI document based on the Postman Collection file generated by Resource Explorer 
+    • --filterByManifest (-m) - Slices the OpenAPI document based on the requests defined in the API Manifest file referenced by the provided URI. For API manifests with multiple API Dependenties, use a fragment identifier to select the desired one. e.g ./apimanifest.json#example
 
  **Examples:**  
 
@@ -95,7 +96,7 @@ This command accepts the following parameters:
 	4. CSDL Filtering by EntitySets and Singletons 
 	hidi transform -cs dataverse.csdl --csdlFilter "appointments,opportunities" -o appointmentsAndOpportunities.yaml -ll trace 
 	 
-Run transform -h to see all the available usage options. 
+Run transform -h to see all the available usage options.
 
 ### Show
 

src/Microsoft.OpenApi/Services/OpenApiFilterService.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Text.RegularExpressions;
 using Microsoft.OpenApi.Models;
@@ -79,12 +80,13 @@ public static class OpenApiFilterService
                     foreach (var url in requestUrls)
                     {
                         var serverList = source.Servers;
+
                         var path = ExtractPath(url.Key, serverList);
 
                         var openApiOperations = GetOpenApiOperations(rootNode, path, apiVersion);
                         if (openApiOperations == null)
                         {
-                            Console.WriteLine($"The url {url.Key} could not be found in the OpenApi description");
+                            Debug.WriteLine($"The url {url.Key} could not be found in the OpenApi description");
                             continue;
                         }
 
@@ -345,20 +347,16 @@ private static bool AddReferences(OpenApiComponents newComponents, OpenApiCompon
 
         private static string ExtractPath(string url, IList<OpenApiServer> serverList)
         {
-            var queryPath = string.Empty;
-            foreach (var server in serverList)
-            {
-                var serverUrl = server.Url.TrimEnd('/');
-                if (!url.Contains(serverUrl))
-                {
-                    continue;
-                }
-
-                var urlComponents = url.Split(new[] { serverUrl }, StringSplitOptions.None);
-                queryPath = urlComponents[1];
+            // if OpenAPI has servers, then see if the url matches one of them
+            var baseUrl = serverList.Select(s => s.Url.TrimEnd('/')).Where(c => url.Contains(c)).FirstOrDefault();
+            
+            if (baseUrl == null) {
+                // if no match, then extract path from either the absolute or relative url
+                return new Uri(new Uri("http://localhost/"), url).GetComponents(UriComponents.Path | UriComponents.KeepDelimiter, UriFormat.Unescaped);
+            } else {
+                // if match, then extract path from the url relative to the matched server
+                return url.Split(new[] { baseUrl }, StringSplitOptions.None)[1];
             }
-
-            return queryPath;
         }
     }
 }

test/Microsoft.OpenApi.Hidi.Tests/Services/OpenApiFilterServiceTests.cs

@@ -11,7 +11,7 @@
 using Moq;
 using Xunit;
 
-namespace Microsoft.OpenApi.Tests.Services
+namespace Microsoft.OpenApi.Hidi.Tests
 {
     public class OpenApiFilterServiceTests
     {
@@ -69,6 +69,43 @@ public void ReturnFilteredOpenApiDocumentBasedOnPostmanCollection()
             Assert.Equal(3, subsetOpenApiDocument.Paths.Count);
         }
 
+        // Create predicate based RequestUrls
+        [Fact]
+        public void TestPredicateFiltersUsingRelativeRequestUrls()
+        {
+            var openApiDocument = new OpenApiDocument()
+            {
+                Info = new() { Title = "Test", Version = "1.0" },
+                Servers = new List<OpenApiServer>() { new() { Url = "https://localhost/" } },
+                Paths = new()
+                {
+                    {"/foo", new() { 
+                        Operations = new Dictionary<OperationType, OpenApiOperation>() {
+                            { OperationType.Get, new() },
+                            { OperationType.Patch, new() },
+                            { OperationType.Post, new() }
+                          } 
+                        }
+                    }
+                }
+            };
+
+            // Given a set of RequestUrls
+            var requestUrls = new Dictionary<string, List<string>>
+            {
+                    {"/foo", new List<string> {"GET","POST"}}
+            };
+            
+            // When
+            var predicate = OpenApiFilterService.CreatePredicate(requestUrls: requestUrls, source: openApiDocument);
+
+            // Then
+            Assert.True(predicate("/foo",OperationType.Get,null));
+            Assert.True(predicate("/foo",OperationType.Post,null));
+            Assert.False(predicate("/foo",OperationType.Patch,null));
+        }
+    
+
         [Fact]
         public void ShouldParseNestedPostmanCollection()
         {

test/Microsoft.OpenApi.Hidi.Tests/Services/OpenApiServiceTests.cs

@@ -13,7 +13,7 @@
 using Microsoft.OpenApi.Services;
 using Xunit;
 
-namespace Microsoft.OpenApi.Tests.Services
+namespace Microsoft.OpenApi.Hidi.Tests
 {
     public class OpenApiServiceTests
     {

test/Microsoft.OpenApi.Hidi.Tests/UtilityFiles/exampleapimanifest.json

@@ -3,10 +3,9 @@
         "name": "Alice",
         "contactEmail": "[email protected]"
     },
-    "apiDependencies": [
-        {
+    "apiDependencies": {
+        "moostodon" : {
             "apiDescripionUrl": "https://raw.githubusercontent.com/APIPatterns/Moostodon/main/spec/tsp-output/%40typespec/openapi3/openapi.yaml",
-            "baseUrl": "https://mastodon.example/",
             "auth": {
                 "clientIdentifier": "some-uuid-here",
                 "access": [ "resourceA.ReadWrite",
@@ -23,5 +22,5 @@
                 }
             ]
         }
-    ]
+    }
 }