Support custom [Tags] for SignalR hubs in plugin

Enhance the JS plugin to map custom operation tags to hub paths, enabling the connection bar and UI to work when hub methods use custom [Tags] attributes. Add AllCustomTagsHub and new tests to verify correct tag-to-hub mapping and OpenAPI extension data. Also, add a className to the event log status span for improved styling.

Author: icnocop

src/SignalR.OpenApi.SwaggerUi/Resources/signalr-openapi-plugin.js

@@ -437,17 +437,66 @@ var SignalROpenApiPlugin = function (system) {
     });
   };
 
-  // Get the hub path associated with a given tag name.
-  // Tags correspond to hub names in the generated OpenAPI spec.
-  var _getHubPathForTag = function (tagName) {
-    var hubs = _getHubPaths();
-    for (var i = 0; i < hubs.length; i++) {
-      if (hubs[i].hubName === tagName) {
-        return hubs[i].hubPath;
-      }
+  // Build a mapping from tag names to hub paths by scanning all SignalR
+  // operations in the spec. Each operation's tags are associated with
+  // the hub path from its x-signalr extension. This handles custom
+  // [Tags] attributes where the tag name differs from the hub name.
+  var _cachedTagHubMap = null;
+  var _cachedTagHubMapVersion = null;
+
+  var _getTagHubMap = function () {
+    var specIm = system.specSelectors.specJson();
+    if (specIm === _cachedTagHubMapVersion) {
+      return _cachedTagHubMap;
+    }
+
+    var tagMap = {};
+    var pathsIm = specIm.get("paths");
+    if (pathsIm) {
+      pathsIm.keySeq().forEach(function (path) {
+        if (!_isSignalRPath(path)) {
+          return;
+        }
+
+        var methods = ["post", "get"];
+        for (var mi = 0; mi < methods.length; mi++) {
+          var opIm = specIm.getIn(["paths", path, methods[mi]]);
+          if (!opIm) {
+            continue;
+          }
+
+          var ext = opIm.get("x-signalr");
+          if (!ext) {
+            continue;
+          }
+
+          var hubName = ext.get("hub");
+          var hubPath = ext.get("hubPath") || ("/" + hubName.toLowerCase());
+
+          var tagsIm = opIm.get("tags");
+          if (tagsIm) {
+            tagsIm.forEach(function (tag) {
+              var tagStr = typeof tag === "string" ? tag : (tag.get ? tag.get("name") || tag : tag);
+              if (typeof tagStr === "string" && !tagMap[tagStr]) {
+                tagMap[tagStr] = hubPath;
+              }
+            });
+          }
+        }
+      });
     }
 
-    return null;
+    _cachedTagHubMapVersion = specIm;
+    _cachedTagHubMap = tagMap;
+    return tagMap;
+  };
+
+  // Get the hub path associated with a given tag name.
+  // Looks up the tag-to-hubPath mapping built from operation tags,
+  // which handles both default tags (hub name) and custom [Tags].
+  var _getHubPathForTag = function (tagName) {
+    var tagMap = _getTagHubMap();
+    return tagMap[tagName] || null;
   };
 
    // Parse request body from the SwaggerUI OAS3 state.
@@ -689,6 +738,7 @@ var SignalROpenApiPlugin = function (system) {
             onClick: clearLog,
           }, "Clear Log"),
           React.createElement("span", {
+            className: "signalr-status",
             style: { marginLeft: "10px", fontSize: "12px", color: "#888" },
           }, logs.length + " event(s) received")
         ),

test/SignalR.OpenApi.Tests/SignalROpenApiDocumentGeneratorTests.cs

@@ -1379,6 +1379,41 @@ public void GenerateDocument_WhenObjectAndStringParametersThenWrappedJsonOnlySch
         Assert.IsFalse(flattenedBody.Value, "flattenedBody should be false for mixed parameters.");
     }
 
+    /// <summary>
+    /// Verifies that when all hub methods have custom [Tags], the operation tags
+    /// differ from the hub name but the x-signalr extension still contains the
+    /// correct hub name and hubPath, enabling tag-to-hub mapping in the JS plugin.
+    /// </summary>
+    [TestMethod]
+    public void GenerateDocument_AllMethodsHaveCustomTags_ExtensionStillContainsHubInfo()
+    {
+        var (discoverer, generator) = CreateServices(o =>
+        {
+            o.HubRoutes[typeof(AllCustomTagsHub)] = "/hubs/custom-tags";
+        });
+
+        var hubs = discoverer.DiscoverHubs();
+        var doc = generator.GenerateDocument(hubs);
+
+        // Both methods should be tagged with "Greetings", not the hub name
+        var sayHello = doc.Paths["/hubs/AllCustomTags/SayHello"]
+            .Operations[OperationType.Post];
+        var sayHelloTags = sayHello.Tags.Select(t => t.Name).ToList();
+        CollectionAssert.Contains(sayHelloTags, "Greetings");
+        CollectionAssert.DoesNotContain(sayHelloTags, "AllCustomTags");
+
+        var sayGoodbye = doc.Paths["/hubs/AllCustomTags/SayGoodbye"]
+            .Operations[OperationType.Post];
+        var sayGoodbyeTags = sayGoodbye.Tags.Select(t => t.Name).ToList();
+        CollectionAssert.Contains(sayGoodbyeTags, "Greetings");
+        CollectionAssert.DoesNotContain(sayGoodbyeTags, "AllCustomTags");
+
+        // x-signalr extension should still reference the hub name and custom hubPath
+        var ext = (Microsoft.OpenApi.Any.OpenApiObject)sayHello.Extensions["x-signalr"];
+        Assert.AreEqual("AllCustomTags", ((Microsoft.OpenApi.Any.OpenApiString)ext["hub"]).Value);
+        Assert.AreEqual("/hubs/custom-tags", ((Microsoft.OpenApi.Any.OpenApiString)ext["hubPath"]).Value);
+    }
+
     private static (ReflectionHubDiscoverer Discoverer, SignalROpenApiDocumentGenerator Generator) CreateServices(
         Action<SignalROpenApiOptions>? configure = null)
     {

test/SignalR.OpenApi.Tests/SwaggerUiIntegrationTests.cs

@@ -531,6 +531,23 @@ public async Task PluginJs_ContainsOperationTagWrapper()
         Assert.IsTrue(content.Contains("OperationTag"), "Plugin JS should contain OperationTag wrapper component");
     }
 
+    /// <summary>
+    /// Verifies that the plugin JS contains the _getTagHubMap function
+    /// which builds a tag-to-hub mapping for custom [Tags] support.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous test.</returns>
+    [TestMethod]
+    public async Task PluginJs_ContainsTagHubMapFunction()
+    {
+        using var host = await CreateTestHost();
+        using var client = host.GetTestClient();
+
+        using var response = await client.GetAsync("/signalr-swagger/_resources/signalr-openapi-plugin.js");
+        var content = await response.Content.ReadAsStringAsync();
+
+        Assert.IsTrue(content.Contains("_getTagHubMap"), "Plugin JS should contain _getTagHubMap function for custom [Tags] support");
+    }
+
     /// <summary>
     /// Verifies that the CSS contains connection bar styles.
     /// </summary>

test/SignalR.OpenApi.Tests/TestHubs/AllCustomTagsHub.cs

@@ -0,0 +1,36 @@
+// Copyright (c) SignalR.OpenApi Contributors. Licensed under the MIT License.
+
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.SignalR;
+
+namespace SignalR.OpenApi.Tests.TestHubs;
+
+/// <summary>
+/// A hub where every method has a custom <see cref="TagsAttribute"/>
+/// that differs from the hub name. Used to verify the connection bar
+/// still appears when no operation tag matches the hub name.
+/// </summary>
+public class AllCustomTagsHub : Hub
+{
+    /// <summary>
+    /// Sends a greeting.
+    /// </summary>
+    /// <param name="name">The name to greet.</param>
+    /// <returns>A greeting message.</returns>
+    [Tags("Greetings")]
+    public Task<string> SayHello(string name)
+    {
+        return Task.FromResult($"Hello, {name}!");
+    }
+
+    /// <summary>
+    /// Sends a farewell.
+    /// </summary>
+    /// <param name="name">The name to bid farewell.</param>
+    /// <returns>A farewell message.</returns>
+    [Tags("Greetings")]
+    public Task<string> SayGoodbye(string name)
+    {
+        return Task.FromResult($"Goodbye, {name}!");
+    }
+}