Introduce GraphQLHttpMiddleware.HandleRequest and switch to IMiddleware (#735)

sungam3r · web-flow · commit cacb72fc63ed · 2022-02-18T00:47:35.000+03:00
diff --git a/README.md b/README.md
@@ -129,6 +129,8 @@ public void ConfigureServices(IServiceCollection services)
     // Add GraphQL services and configure options
     services.AddGraphQL(builder => builder
         .AddServer(true)
+        .AddHttpMiddleware<ChatSchema>()
+        .AddWebSocketsHttpMiddleware<ChatSchema>()
         // For subscriptions support
         .AddDocumentExecuter<SubscriptionDocumentExecuter>()
         .AddSchema<ChatSchema>()
@@ -189,6 +191,8 @@ public void ConfigureServices(IServiceCollection services)
     // Add GraphQL services and configure options
     services.AddGraphQL(builder => builder
         .AddServer(true)
+        .AddHttpMiddleware<ChatSchema>()
+        .AddWebSocketsHttpMiddleware<ChatSchema>()
         // For subscriptions support
         .AddDocumentExecuter<SubscriptionDocumentExecuter>()
         .AddSchema<ChatSchema>()
diff --git a/samples/Samples.Server/GraphQLHttpMiddlewareWithLogs.cs b/samples/Samples.Server/GraphQLHttpMiddlewareWithLogs.cs
@@ -16,9 +16,8 @@ public class GraphQLHttpMiddlewareWithLogs<TSchema> : GraphQLHttpMiddleware<TSch
 
         public GraphQLHttpMiddlewareWithLogs(
             ILogger<GraphQLHttpMiddleware<TSchema>> logger,
-            RequestDelegate next,
             IGraphQLTextSerializer requestDeserializer)
-            : base(next, requestDeserializer)
+            : base(requestDeserializer)
         {
             _logger = logger;
         }
diff --git a/samples/Samples.Server/Startup.cs b/samples/Samples.Server/Startup.cs
@@ -43,6 +43,8 @@ public void ConfigureServices(IServiceCollection services)
 
             services.AddGraphQL(builder => builder
                 .AddServer(true)
+                .AddHttpMiddleware<ChatSchema, GraphQLHttpMiddlewareWithLogs<ChatSchema>>()
+                .AddWebSocketsHttpMiddleware<ChatSchema>()
                 .AddSubscriptionExecutionStrategy()
                 .AddSchema<ChatSchema>()
                 .ConfigureExecutionOptions(options =>
diff --git a/samples/Samples.Server/StartupWithRouting.cs b/samples/Samples.Server/StartupWithRouting.cs
@@ -42,6 +42,8 @@ public void ConfigureServices(IServiceCollection services)
 
             services.AddGraphQL(builder => builder
                 .AddServer(true)
+                .AddHttpMiddleware<ChatSchema, GraphQLHttpMiddlewareWithLogs<ChatSchema>>()
+                .AddWebSocketsHttpMiddleware<ChatSchema>()
                 .AddSubscriptionExecutionStrategy()
                 .AddSchema<ChatSchema>()
                 .ConfigureExecutionOptions(options =>
diff --git a/src/Transports.AspNetCore/Extensions/GraphQLBuilderMiddlewareExtensions.cs b/src/Transports.AspNetCore/Extensions/GraphQLBuilderMiddlewareExtensions.cs
@@ -0,0 +1,29 @@
+#nullable enable
+
+using GraphQL.DI;
+using GraphQL.Server.Transports.AspNetCore;
+using GraphQL.Types;
+
+namespace GraphQL.Server
+{
+    /// <summary>
+    /// GraphQL specific extension methods for <see cref="IGraphQLBuilder"/>.
+    /// </summary>
+    public static class GraphQLBuilderMiddlewareExtensions
+    {
+        public static IGraphQLBuilder AddHttpMiddleware<TSchema>(this IGraphQLBuilder builder)
+          where TSchema : ISchema
+        {
+            builder.Services.Register<GraphQLHttpMiddleware<TSchema>, GraphQLHttpMiddleware<TSchema>>(ServiceLifetime.Singleton);
+            return builder;
+        }
+
+        public static IGraphQLBuilder AddHttpMiddleware<TSchema, TMiddleware>(this IGraphQLBuilder builder)
+            where TSchema : ISchema
+            where TMiddleware : GraphQLHttpMiddleware<TSchema>
+        {
+            builder.Services.Register<TMiddleware, TMiddleware>(ServiceLifetime.Singleton);
+            return builder;
+        }
+    }
+}
diff --git a/src/Transports.AspNetCore/GraphQLHttpMiddleware.cs b/src/Transports.AspNetCore/GraphQLHttpMiddleware.cs
@@ -26,25 +26,23 @@ namespace GraphQL.Server.Transports.AspNetCore
     /// Attention! The current implementation does not impose such a restriction and allows mutations in GET requests.
     /// </summary>
     /// <typeparam name="TSchema">Type of GraphQL schema that is used to validate and process requests.</typeparam>
-    public class GraphQLHttpMiddleware<TSchema>
+    public class GraphQLHttpMiddleware<TSchema> : IMiddleware
         where TSchema : ISchema
     {
         private const string DOCS_URL = "See: http://graphql.org/learn/serving-over-http/.";
 
-        private readonly RequestDelegate _next;
         private readonly IGraphQLTextSerializer _serializer;
 
-        public GraphQLHttpMiddleware(RequestDelegate next, IGraphQLTextSerializer serializer)
+        public GraphQLHttpMiddleware(IGraphQLTextSerializer serializer)
         {
-            _next = next;
             _serializer = serializer;
         }
 
-        public async Task InvokeAsync(HttpContext context)
+        public async Task InvokeAsync(HttpContext context, RequestDelegate next)
         {
             if (context.WebSockets.IsWebSocketRequest)
             {
-                await _next(context);
+                await next(context);
                 return;
             }
 
@@ -53,7 +51,6 @@ public async Task InvokeAsync(HttpContext context)
             var httpRequest = context.Request;
             var httpResponse = context.Response;
 
-            var serializer = context.RequestServices.GetRequiredService<IGraphQLSerializer>();
             var cancellationToken = GetCancellationToken(context);
 
             // GraphQL HTTP only supports GET and POST methods
@@ -149,7 +146,17 @@ public async Task InvokeAsync(HttpContext context)
                 : await userContextBuilder.BuildUserContext(context);
 
             var executer = context.RequestServices.GetRequiredService<IGraphQLExecuter<TSchema>>();
+            await HandleRequestAsync(context, userContext, bodyGQLBatchRequest, gqlRequest, executer, cancellationToken);
+        }
 
+        protected virtual async Task HandleRequestAsync(
+            HttpContext context,
+            IDictionary<string, object> userContext,
+            GraphQLRequest[] bodyGQLBatchRequest,
+            GraphQLRequest gqlRequest,
+            IGraphQLExecuter<TSchema> executer,
+            CancellationToken cancellationToken)
+        {
             // Normal execution with single graphql request
             if (bodyGQLBatchRequest == null)
             {
@@ -159,7 +166,7 @@ public async Task InvokeAsync(HttpContext context)
 
                 await RequestExecutedAsync(new GraphQLRequestExecutionResult(gqlRequest, result, stopwatch.Elapsed));
 
-                await WriteResponseAsync(httpResponse, serializer, cancellationToken, result);
+                await WriteResponseAsync(context.Response, _serializer, cancellationToken, result);
             }
             // Execute multiple graphql requests in one batch
             else
@@ -178,7 +185,7 @@ public async Task InvokeAsync(HttpContext context)
                     executionResults[i] = result;
                 }
 
-                await WriteResponseAsync(httpResponse, serializer, cancellationToken, executionResults);
+                await WriteResponseAsync(context.Response, _serializer, cancellationToken, executionResults);
             }
         }
 
diff --git a/src/Transports.Subscriptions.WebSockets/Extensions/GraphQLBuilderWebSocketsExtensions.cs b/src/Transports.Subscriptions.WebSockets/Extensions/GraphQLBuilderWebSocketsExtensions.cs
@@ -1,6 +1,7 @@
 using GraphQL.DI;
 using GraphQL.Server.Transports.Subscriptions.Abstractions;
 using GraphQL.Server.Transports.WebSockets;
+using GraphQL.Types;
 
 namespace GraphQL.Server
 {
@@ -18,5 +19,20 @@ public static IGraphQLBuilder AddWebSockets(this IGraphQLBuilder builder)
 
             return builder;
         }
+
+        public static IGraphQLBuilder AddWebSocketsHttpMiddleware<TSchema>(this IGraphQLBuilder builder)
+            where TSchema : ISchema
+        {
+            builder.Services.Register<GraphQLWebSocketsMiddleware<TSchema>, GraphQLWebSocketsMiddleware<TSchema>>(ServiceLifetime.Singleton);
+            return builder;
+        }
+
+        public static IGraphQLBuilder AddWebSocketsHttpMiddleware<TSchema, TMiddleware>(this IGraphQLBuilder builder)
+            where TSchema : ISchema
+            where TMiddleware : GraphQLWebSocketsMiddleware<TSchema>
+        {
+            builder.Services.Register<TMiddleware, TMiddleware>(ServiceLifetime.Singleton);
+            return builder;
+        }
     }
 }
diff --git a/src/Transports.Subscriptions.WebSockets/GraphQLWebSocketsMiddleware.cs b/src/Transports.Subscriptions.WebSockets/GraphQLWebSocketsMiddleware.cs
@@ -12,19 +12,17 @@ namespace GraphQL.Server.Transports.WebSockets
     /// ASP.NET Core middleware for processing GraphQL web socket requests. This middleware useful with and without ASP.NET Core routing.
     /// </summary>
     /// <typeparam name="TSchema">Type of GraphQL schema that is used to process requests.</typeparam>
-    public class GraphQLWebSocketsMiddleware<TSchema>
+    public class GraphQLWebSocketsMiddleware<TSchema> : IMiddleware
         where TSchema : ISchema
     {
-        private readonly RequestDelegate _next;
         private readonly ILogger<GraphQLWebSocketsMiddleware<TSchema>> _logger;
 
-        public GraphQLWebSocketsMiddleware(RequestDelegate next, ILogger<GraphQLWebSocketsMiddleware<TSchema>> logger)
+        public GraphQLWebSocketsMiddleware(ILogger<GraphQLWebSocketsMiddleware<TSchema>> logger)
         {
-            _next = next;
             _logger = logger;
         }
 
-        public async Task InvokeAsync(HttpContext context)
+        public async Task InvokeAsync(HttpContext context, RequestDelegate next)
         {
             using (_logger.BeginScope(new Dictionary<string, object>
             {
@@ -35,7 +33,7 @@ public async Task InvokeAsync(HttpContext context)
                 if (!context.WebSockets.IsWebSocketRequest)
                 {
                     _logger.LogDebug("Request is not a valid websocket request");
-                    await _next(context);
+                    await next(context);
 
                     return;
                 }
diff --git a/tests/ApiApprovalTests/GraphQL.Server.Transports.AspNetCore.approved.txt b/tests/ApiApprovalTests/GraphQL.Server.Transports.AspNetCore.approved.txt
@@ -1,5 +1,13 @@
 namespace GraphQL.Server
 {
+    public static class GraphQLBuilderMiddlewareExtensions
+    {
+        public static GraphQL.DI.IGraphQLBuilder AddHttpMiddleware<TSchema>(this GraphQL.DI.IGraphQLBuilder builder)
+            where TSchema : GraphQL.Types.ISchema { }
+        public static GraphQL.DI.IGraphQLBuilder AddHttpMiddleware<TSchema, TMiddleware>(this GraphQL.DI.IGraphQLBuilder builder)
+            where TSchema : GraphQL.Types.ISchema
+            where TMiddleware : GraphQL.Server.Transports.AspNetCore.GraphQLHttpMiddleware<TSchema> { }
+    }
     public static class GraphQLBuilderUserContextExtensions
     {
         public static GraphQL.DI.IGraphQLBuilder AddDefaultEndpointSelectorPolicy(this GraphQL.DI.IGraphQLBuilder builder) { }
@@ -13,17 +21,18 @@ namespace GraphQL.Server
 }
 namespace GraphQL.Server.Transports.AspNetCore
 {
-    public class GraphQLHttpMiddleware<TSchema>
+    public class GraphQLHttpMiddleware<TSchema> : Microsoft.AspNetCore.Http.IMiddleware
         where TSchema : GraphQL.Types.ISchema
     {
-        public GraphQLHttpMiddleware(Microsoft.AspNetCore.Http.RequestDelegate next, GraphQL.IGraphQLTextSerializer serializer) { }
+        public GraphQLHttpMiddleware(GraphQL.IGraphQLTextSerializer serializer) { }
         protected virtual System.Threading.CancellationToken GetCancellationToken(Microsoft.AspNetCore.Http.HttpContext context) { }
         protected virtual System.Threading.Tasks.Task HandleContentTypeCouldNotBeParsedErrorAsync(Microsoft.AspNetCore.Http.HttpContext context) { }
         protected virtual System.Threading.Tasks.ValueTask<bool> HandleDeserializationErrorAsync(Microsoft.AspNetCore.Http.HttpContext context, System.Exception ex) { }
         protected virtual System.Threading.Tasks.Task HandleInvalidContentTypeErrorAsync(Microsoft.AspNetCore.Http.HttpContext context) { }
         protected virtual System.Threading.Tasks.Task HandleInvalidHttpMethodErrorAsync(Microsoft.AspNetCore.Http.HttpContext context) { }
         protected virtual System.Threading.Tasks.Task HandleNoQueryErrorAsync(Microsoft.AspNetCore.Http.HttpContext context) { }
-        public System.Threading.Tasks.Task InvokeAsync(Microsoft.AspNetCore.Http.HttpContext context) { }
+        protected virtual System.Threading.Tasks.Task HandleRequestAsync(Microsoft.AspNetCore.Http.HttpContext context, System.Collections.Generic.IDictionary<string, object> userContext, GraphQL.Transport.GraphQLRequest[] bodyGQLBatchRequest, GraphQL.Transport.GraphQLRequest gqlRequest, GraphQL.Server.IGraphQLExecuter<TSchema> executer, System.Threading.CancellationToken cancellationToken) { }
+        public System.Threading.Tasks.Task InvokeAsync(Microsoft.AspNetCore.Http.HttpContext context, Microsoft.AspNetCore.Http.RequestDelegate next) { }
         protected virtual System.Threading.Tasks.Task RequestExecutedAsync(in GraphQL.Server.Transports.AspNetCore.GraphQLRequestExecutionResult requestExecutionResult) { }
         protected virtual System.Threading.Tasks.Task RequestExecutingAsync(GraphQL.Transport.GraphQLRequest request, int? indexInBatch = default) { }
         protected virtual System.Threading.Tasks.Task WriteErrorResponseAsync(Microsoft.AspNetCore.Http.HttpContext context, string errorMessage, System.Net.HttpStatusCode httpStatusCode) { }
diff --git a/tests/ApiApprovalTests/GraphQL.Server.Transports.Subscriptions.WebSockets.approved.txt b/tests/ApiApprovalTests/GraphQL.Server.Transports.Subscriptions.WebSockets.approved.txt
@@ -3,15 +3,20 @@ namespace GraphQL.Server
     public static class GraphQLBuilderWebSocketsExtensions
     {
         public static GraphQL.DI.IGraphQLBuilder AddWebSockets(this GraphQL.DI.IGraphQLBuilder builder) { }
+        public static GraphQL.DI.IGraphQLBuilder AddWebSocketsHttpMiddleware<TSchema>(this GraphQL.DI.IGraphQLBuilder builder)
+            where TSchema : GraphQL.Types.ISchema { }
+        public static GraphQL.DI.IGraphQLBuilder AddWebSocketsHttpMiddleware<TSchema, TMiddleware>(this GraphQL.DI.IGraphQLBuilder builder)
+            where TSchema : GraphQL.Types.ISchema
+            where TMiddleware : GraphQL.Server.Transports.WebSockets.GraphQLWebSocketsMiddleware<TSchema> { }
     }
 }
 namespace GraphQL.Server.Transports.WebSockets
 {
-    public class GraphQLWebSocketsMiddleware<TSchema>
+    public class GraphQLWebSocketsMiddleware<TSchema> : Microsoft.AspNetCore.Http.IMiddleware
         where TSchema : GraphQL.Types.ISchema
     {
-        public GraphQLWebSocketsMiddleware(Microsoft.AspNetCore.Http.RequestDelegate next, Microsoft.Extensions.Logging.ILogger<GraphQL.Server.Transports.WebSockets.GraphQLWebSocketsMiddleware<TSchema>> logger) { }
-        public System.Threading.Tasks.Task InvokeAsync(Microsoft.AspNetCore.Http.HttpContext context) { }
+        public GraphQLWebSocketsMiddleware(Microsoft.Extensions.Logging.ILogger<GraphQL.Server.Transports.WebSockets.GraphQLWebSocketsMiddleware<TSchema>> logger) { }
+        public System.Threading.Tasks.Task InvokeAsync(Microsoft.AspNetCore.Http.HttpContext context, Microsoft.AspNetCore.Http.RequestDelegate next) { }
     }
     public interface IWebSocketConnectionFactory<TSchema>
         where TSchema : GraphQL.Types.ISchema
diff --git a/tests/Transports.Subscriptions.WebSockets.Tests/TestStartup.cs b/tests/Transports.Subscriptions.WebSockets.Tests/TestStartup.cs
@@ -10,7 +10,7 @@ public class TestStartup
         public void ConfigureServices(IServiceCollection services)
         {
             services
-                .AddGraphQL(builder => builder.AddWebSockets())
+                .AddGraphQL(builder => builder.AddWebSockets().AddWebSocketsHttpMiddleware<TestSchema>())
                 .AddSingleton<TestSchema>()
                 .AddLogging(builder =>
                 {

Original file line number	Diff line number	Diff line change
`@@ -16,9 +16,8 @@ public class GraphQLHttpMiddlewareWithLogs<TSchema> : GraphQLHttpMiddleware<TSch`
`16`	`16`
`17`	`17`	`public GraphQLHttpMiddlewareWithLogs(`
`18`	`18`	`ILogger<GraphQLHttpMiddleware<TSchema>> logger,`
`19`		`- RequestDelegate next,`
`20`	`19`	`IGraphQLTextSerializer requestDeserializer)`
`21`		`- : base(next, requestDeserializer)`
	`20`	`+ : base(requestDeserializer)`
`22`	`21`	`{`
`23`	`22`	`_logger = logger;`
`24`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,25 +26,23 @@ namespace GraphQL.Server.Transports.AspNetCore`
`26`	`26`	`/// Attention! The current implementation does not impose such a restriction and allows mutations in GET requests.`
`27`	`27`	`/// </summary>`
`28`	`28`	`/// <typeparam name="TSchema">Type of GraphQL schema that is used to validate and process requests.</typeparam>`
`29`		`- public class GraphQLHttpMiddleware<TSchema>`
	`29`	`+ public class GraphQLHttpMiddleware<TSchema> : IMiddleware`
`30`	`30`	`where TSchema : ISchema`
`31`	`31`	`{`
`32`	`32`	`private const string DOCS_URL = "See: http://graphql.org/learn/serving-over-http/.";`
`33`	`33`
`34`		`- private readonly RequestDelegate _next;`
`35`	`34`	`private readonly IGraphQLTextSerializer _serializer;`
`36`	`35`
`37`		`- public GraphQLHttpMiddleware(RequestDelegate next, IGraphQLTextSerializer serializer)`
	`36`	`+ public GraphQLHttpMiddleware(IGraphQLTextSerializer serializer)`
`38`	`37`	`{`
`39`		`- _next = next;`
`40`	`38`	`_serializer = serializer;`
`41`	`39`	`}`
`42`	`40`
`43`		`- public async Task InvokeAsync(HttpContext context)`
	`41`	`+ public async Task InvokeAsync(HttpContext context, RequestDelegate next)`
`44`	`42`	`{`
`45`	`43`	`if (context.WebSockets.IsWebSocketRequest)`
`46`	`44`	`{`
`47`		`- await _next(context);`
	`45`	`+ await next(context);`
`48`	`46`	`return;`
`49`	`47`	`}`
`50`	`48`
`@@ -53,7 +51,6 @@ public async Task InvokeAsync(HttpContext context)`
`53`	`51`	`var httpRequest = context.Request;`
`54`	`52`	`var httpResponse = context.Response;`
`55`	`53`
`56`		`- var serializer = context.RequestServices.GetRequiredService<IGraphQLSerializer>();`
`57`	`54`	`var cancellationToken = GetCancellationToken(context);`
`58`	`55`
`59`	`56`	`// GraphQL HTTP only supports GET and POST methods`
`@@ -149,7 +146,17 @@ public async Task InvokeAsync(HttpContext context)`
`149`	`146`	`: await userContextBuilder.BuildUserContext(context);`
`150`	`147`
`151`	`148`	`var executer = context.RequestServices.GetRequiredService<IGraphQLExecuter<TSchema>>();`
	`149`	`+ await HandleRequestAsync(context, userContext, bodyGQLBatchRequest, gqlRequest, executer, cancellationToken);`
	`150`	`+ }`
`152`	`151`
	`152`	`+ protected virtual async Task HandleRequestAsync(`
	`153`	`+ HttpContext context,`
	`154`	`+ IDictionary<string, object> userContext,`
	`155`	`+ GraphQLRequest[] bodyGQLBatchRequest,`
	`156`	`+ GraphQLRequest gqlRequest,`
	`157`	`+ IGraphQLExecuter<TSchema> executer,`
	`158`	`+ CancellationToken cancellationToken)`
	`159`	`+ {`
`153`	`160`	`// Normal execution with single graphql request`
`154`	`161`	`if (bodyGQLBatchRequest == null)`
`155`	`162`	`{`
`@@ -159,7 +166,7 @@ public async Task InvokeAsync(HttpContext context)`
`159`	`166`
`160`	`167`	`await RequestExecutedAsync(new GraphQLRequestExecutionResult(gqlRequest, result, stopwatch.Elapsed));`
`161`	`168`
`162`		`- await WriteResponseAsync(httpResponse, serializer, cancellationToken, result);`
	`169`	`+ await WriteResponseAsync(context.Response, _serializer, cancellationToken, result);`
`163`	`170`	`}`
`164`	`171`	`// Execute multiple graphql requests in one batch`
`165`	`172`	`else`
`@@ -178,7 +185,7 @@ public async Task InvokeAsync(HttpContext context)`
`178`	`185`	`executionResults[i] = result;`
`179`	`186`	`}`
`180`	`187`
`181`		`- await WriteResponseAsync(httpResponse, serializer, cancellationToken, executionResults);`
	`188`	`+ await WriteResponseAsync(context.Response, _serializer, cancellationToken, executionResults);`
`182`	`189`	`}`
`183`	`190`	`}`
`184`	`191`
Original file line number	Diff line number	Diff line change
`@@ -12,19 +12,17 @@ namespace GraphQL.Server.Transports.WebSockets`
`12`	`12`	`/// ASP.NET Core middleware for processing GraphQL web socket requests. This middleware useful with and without ASP.NET Core routing.`
`13`	`13`	`/// </summary>`
`14`	`14`	`/// <typeparam name="TSchema">Type of GraphQL schema that is used to process requests.</typeparam>`
`15`		`- public class GraphQLWebSocketsMiddleware<TSchema>`
	`15`	`+ public class GraphQLWebSocketsMiddleware<TSchema> : IMiddleware`
`16`	`16`	`where TSchema : ISchema`
`17`	`17`	`{`
`18`		`- private readonly RequestDelegate _next;`
`19`	`18`	`private readonly ILogger<GraphQLWebSocketsMiddleware<TSchema>> _logger;`
`20`	`19`
`21`		`- public GraphQLWebSocketsMiddleware(RequestDelegate next, ILogger<GraphQLWebSocketsMiddleware<TSchema>> logger)`
	`20`	`+ public GraphQLWebSocketsMiddleware(ILogger<GraphQLWebSocketsMiddleware<TSchema>> logger)`
`22`	`21`	`{`
`23`		`- _next = next;`
`24`	`22`	`_logger = logger;`
`25`	`23`	`}`
`26`	`24`
`27`		`- public async Task InvokeAsync(HttpContext context)`
	`25`	`+ public async Task InvokeAsync(HttpContext context, RequestDelegate next)`
`28`	`26`	`{`
`29`	`27`	`using (_logger.BeginScope(new Dictionary<string, object>`
`30`	`28`	`{`
`@@ -35,7 +33,7 @@ public async Task InvokeAsync(HttpContext context)`
`35`	`33`	`if (!context.WebSockets.IsWebSocketRequest)`
`36`	`34`	`{`
`37`	`35`	`_logger.LogDebug("Request is not a valid websocket request");`
`38`		`- await _next(context);`
	`36`	`+ await next(context);`
`39`	`37`
`40`	`38`	`return;`
`41`	`39`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3,15 +3,20 @@ namespace GraphQL.Server`
`3`	`3`	`public static class GraphQLBuilderWebSocketsExtensions`
`4`	`4`	`{`
`5`	`5`	`public static GraphQL.DI.IGraphQLBuilder AddWebSockets(this GraphQL.DI.IGraphQLBuilder builder) { }`
	`6`	`+ public static GraphQL.DI.IGraphQLBuilder AddWebSocketsHttpMiddleware<TSchema>(this GraphQL.DI.IGraphQLBuilder builder)`
	`7`	`+ where TSchema : GraphQL.Types.ISchema { }`
	`8`	`+ public static GraphQL.DI.IGraphQLBuilder AddWebSocketsHttpMiddleware<TSchema, TMiddleware>(this GraphQL.DI.IGraphQLBuilder builder)`
	`9`	`+ where TSchema : GraphQL.Types.ISchema`
	`10`	`+ where TMiddleware : GraphQL.Server.Transports.WebSockets.GraphQLWebSocketsMiddleware<TSchema> { }`
`6`	`11`	`}`
`7`	`12`	`}`
`8`	`13`	`namespace GraphQL.Server.Transports.WebSockets`
`9`	`14`	`{`
`10`		`- public class GraphQLWebSocketsMiddleware<TSchema>`
	`15`	`+ public class GraphQLWebSocketsMiddleware<TSchema> : Microsoft.AspNetCore.Http.IMiddleware`
`11`	`16`	`where TSchema : GraphQL.Types.ISchema`
`12`	`17`	`{`
`13`		`- public GraphQLWebSocketsMiddleware(Microsoft.AspNetCore.Http.RequestDelegate next, Microsoft.Extensions.Logging.ILogger<GraphQL.Server.Transports.WebSockets.GraphQLWebSocketsMiddleware<TSchema>> logger) { }`
`14`		`- public System.Threading.Tasks.Task InvokeAsync(Microsoft.AspNetCore.Http.HttpContext context) { }`
	`18`	`+ public GraphQLWebSocketsMiddleware(Microsoft.Extensions.Logging.ILogger<GraphQL.Server.Transports.WebSockets.GraphQLWebSocketsMiddleware<TSchema>> logger) { }`
	`19`	`+ public System.Threading.Tasks.Task InvokeAsync(Microsoft.AspNetCore.Http.HttpContext context, Microsoft.AspNetCore.Http.RequestDelegate next) { }`
`15`	`20`	`}`
`16`	`21`	`public interface IWebSocketConnectionFactory<TSchema>`
`17`	`22`	`where TSchema : GraphQL.Types.ISchema`