Upgrade graphql to 7.7.2

src/OrchardCore.Build/Dependencies.props

@@ -21,10 +21,10 @@
     <PackageManagement Include="Castle.Core" Version="5.1.1" />
     <PackageManagement Include="DocumentFormat.OpenXml" Version="3.0.1" />
     <PackageManagement Include="Fluid.Core" Version="2.5.0" />
-    <PackageManagement Include="GraphQL" Version="4.8.0" />
-    <PackageManagement Include="GraphQL.DataLoader" Version="4.8.0" />
-    <PackageManagement Include="GraphQL.MicrosoftDI" Version="4.8.0" />
-    <PackageManagement Include="GraphQL.SystemTextJson" Version="4.8.0" />
+    <PackageManagement Include="GraphQL" Version="7.7.2" />
+    <PackageManagement Include="GraphQL.DataLoader" Version="7.7.2" />
+    <PackageManagement Include="GraphQL.MicrosoftDI" Version="7.7.2" />
+    <PackageManagement Include="GraphQL.SystemTextJson" Version="7.7.2" />
     <PackageManagement Include="Jint" Version="3.0.0" />
     <PackageManagement Include="HtmlSanitizer" Version="8.1.839-beta" />
     <PackageManagement Include="Irony.Core" Version="1.0.7" />

src/OrchardCore.Modules/OrchardCore.Apis.GraphQL/Extensions/DocumentWriterExtensions.cs

@@ -9,7 +9,7 @@ namespace OrchardCore.Apis.GraphQL
 {
     internal static class DocumentWriterExtensions
     {
-        public static async Task WriteErrorAsync(this IDocumentWriter documentWriter, HttpContext context, string message, Exception e = null)
+        public static async Task WriteErrorAsync(this IGraphQLSerializer graphQLSerializer, HttpContext context, string message, Exception e = null)
         {
             ArgumentNullException.ThrowIfNull(message);
 
@@ -30,7 +30,7 @@ public static async Task WriteErrorAsync(this IDocumentWriter documentWriter, Ht
             context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
             context.Response.ContentType = MediaTypeNames.Application.Json;
 
-            await documentWriter.WriteAsync(context.Response.Body, errorResult);
+            await graphQLSerializer.WriteAsync(context.Response.Body, errorResult);
         }
     }
 }

src/OrchardCore.Modules/OrchardCore.Apis.GraphQL/GraphQLMiddleware.cs

@@ -11,72 +11,73 @@
 using GraphQL.SystemTextJson;
 using GraphQL.Validation;
 using GraphQL.Validation.Complexity;
+using GraphQL.Validation.Rules.Custom;
 using Microsoft.AspNetCore.Authentication;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc.Formatters;
+using Microsoft.CodeAnalysis;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 using OrchardCore.Apis.GraphQL.Queries;
 using OrchardCore.Apis.GraphQL.ValidationRules;
 using OrchardCore.Routing;
 
 namespace OrchardCore.Apis.GraphQL
 {
-    public class GraphQLMiddleware
+    public class GraphQLMiddleware : IMiddleware
     {
-        private readonly RequestDelegate _next;
         private readonly GraphQLSettings _settings;
+        private readonly IGraphQLSerializer _serializer;
         private readonly IDocumentExecuter _executer;
         internal static readonly Encoding _utf8Encoding = new UTF8Encoding(false);
         private static readonly MediaType _jsonMediaType = new("application/json");
         private static readonly MediaType _graphQlMediaType = new("application/graphql");
 
         public GraphQLMiddleware(
-            RequestDelegate next,
-            GraphQLSettings settings,
-            IDocumentExecuter executer)
+            IOptions<GraphQLSettings> settingsOption,
+            IDocumentExecuter executer,
+            IGraphQLSerializer serializer)
         {
-            _next = next;
-            _settings = settings;
+            _settings = settingsOption.Value;
             _executer = executer;
+            _serializer = serializer;
         }
-
-        public async Task Invoke(HttpContext context, IAuthorizationService authorizationService, IAuthenticationService authenticationService, ISchemaFactory schemaService, IDocumentWriter documentWriter)
+        public async Task InvokeAsync(HttpContext context, RequestDelegate next)
         {
             if (!IsGraphQLRequest(context))
             {
-                await _next(context);
+                await next(context);
             }
             else
             {
+                var authenticationService = context.RequestServices.GetService<IAuthenticationService>();
                 var authenticateResult = await authenticationService.AuthenticateAsync(context, "Api");
-
                 if (authenticateResult.Succeeded)
                 {
                     context.User = authenticateResult.Principal;
                 }
-
+                var authorizationService = context.RequestServices.GetService<IAuthorizationService>();
                 var authorized = await authorizationService.AuthorizeAsync(context.User, Permissions.ExecuteGraphQL);
 
                 if (authorized)
                 {
-                    await ExecuteAsync(context, schemaService, documentWriter);
+                    await ExecuteAsync(context);
                 }
                 else
                 {
                     await context.ChallengeAsync("Api");
                 }
             }
         }
-
         private bool IsGraphQLRequest(HttpContext context)
         {
             return context.Request.Path.StartsWithNormalizedSegments(_settings.Path, StringComparison.OrdinalIgnoreCase);
         }
 
-        private async Task ExecuteAsync(HttpContext context, ISchemaFactory schemaService, IDocumentWriter documentWriter)
+        private async Task ExecuteAsync(HttpContext context)
         {
-            GraphQLRequest request = null;
+            GraphQLNamedQueryRequest request = null;
 
             // c.f. https://graphql.org/learn/serving-over-http/#post-request
 
@@ -93,14 +94,14 @@ private async Task ExecuteAsync(HttpContext context, ISchemaFactory schemaServic
                         {
                             using var sr = new StreamReader(context.Request.Body);
 
-                            request = new GraphQLRequest
+                            request = new GraphQLNamedQueryRequest
                             {
                                 Query = await sr.ReadToEndAsync()
                             };
                         }
                         else
                         {
-                            request = await JsonSerializer.DeserializeAsync<GraphQLRequest>(context.Request.Body, JOptions.CamelCase);
+                            request = await JsonSerializer.DeserializeAsync<GraphQLNamedQueryRequest>(context.Request.Body, JOptions.CamelCase);
                         }
                     }
                     else
@@ -120,7 +121,7 @@ private async Task ExecuteAsync(HttpContext context, ISchemaFactory schemaServic
             }
             catch (Exception e)
             {
-                await documentWriter.WriteErrorAsync(context, "An error occurred while processing the GraphQL query", e);
+                await _serializer.WriteErrorAsync(context, "An error occurred while processing the GraphQL query", e);
                 return;
             }
 
@@ -137,25 +138,26 @@ private async Task ExecuteAsync(HttpContext context, ISchemaFactory schemaServic
                 queryToExecute = queries[request.NamedQuery];
             }
 
+            var schemaService = context.RequestServices.GetService<ISchemaFactory>();
             var schema = await schemaService.GetSchemaAsync();
             var dataLoaderDocumentListener = context.RequestServices.GetRequiredService<IDocumentExecutionListener>();
-            var result = await _executer.ExecuteAsync(_ =>
+            var result = await _executer.ExecuteAsync(options =>
             {
-                _.Schema = schema;
-                _.Query = queryToExecute;
-                _.OperationName = request.OperationName;
-                _.Inputs = request.Variables.ToInputs();
-                _.UserContext = _settings.BuildUserContext?.Invoke(context);
-                _.ValidationRules = DocumentValidator.CoreRules
-                                    .Concat(context.RequestServices.GetServices<IValidationRule>());
-                _.ComplexityConfiguration = new ComplexityConfiguration
-                {
-                    MaxDepth = _settings.MaxDepth,
-                    MaxComplexity = _settings.MaxComplexity,
-                    FieldImpact = _settings.FieldImpact
-                };
-                _.Listeners.Add(dataLoaderDocumentListener);
-                _.RequestServices = context.RequestServices;
+                options.Schema = schema;
+                options.Query = queryToExecute;
+                options.OperationName = request.OperationName;
+                options.Variables = request.Variables;
+                options.UserContext = _settings.BuildUserContext?.Invoke(context);
+                options.ValidationRules = DocumentValidator.CoreRules
+                    .Concat(context.RequestServices.GetServices<IValidationRule>())
+                    .Append(new ComplexityValidationRule(new ComplexityConfiguration
+                    {
+                        MaxDepth = _settings.MaxDepth,
+                        MaxComplexity = _settings.MaxComplexity,
+                        FieldImpact = _settings.FieldImpact
+                    }));
+                options.Listeners.Add(dataLoaderDocumentListener);
+                options.RequestServices = context.RequestServices;
             });
 
             context.Response.StatusCode = (int)(result.Errors == null || result.Errors.Count == 0
@@ -166,10 +168,10 @@ private async Task ExecuteAsync(HttpContext context, ISchemaFactory schemaServic
 
             context.Response.ContentType = MediaTypeNames.Application.Json;
 
-            await documentWriter.WriteAsync(context.Response.Body, result);
+            await _serializer.WriteAsync(context.Response.Body, result);
         }
 
-        private static GraphQLRequest CreateRequestFromQueryString(HttpContext context, bool validateQueryKey = false)
+        private GraphQLNamedQueryRequest CreateRequestFromQueryString(HttpContext context, bool validateQueryKey = false)
         {
             if (!context.Request.Query.ContainsKey("query"))
             {
@@ -181,14 +183,14 @@ private static GraphQLRequest CreateRequestFromQueryString(HttpContext context,
                 return null;
             }
 
-            var request = new GraphQLRequest
+            var request = new GraphQLNamedQueryRequest
             {
                 Query = context.Request.Query["query"]
             };
 
             if (context.Request.Query.ContainsKey("variables"))
             {
-                request.Variables = JConvert.DeserializeObject<JsonElement>(context.Request.Query["variables"], JOptions.CamelCase);
+                request.Variables = JsonSerializer.Deserialize<Inputs>(context.Request.Query["variables"], JOptions.CamelCase);
             }
 
             if (context.Request.Query.ContainsKey("operationName"))

src/OrchardCore.Modules/OrchardCore.Apis.GraphQL/GraphQLNamedQueryRequest.cs

@@ -0,0 +1,10 @@
+
+using GraphQL.Transport;
+
+namespace OrchardCore.Apis.GraphQL
+{
+    public class GraphQLNamedQueryRequest : GraphQLRequest
+    {
+        public string NamedQuery { get; set; }
+    }
+}

src/OrchardCore.Modules/OrchardCore.Apis.GraphQL/Startup.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Text.Json;
 using GraphQL;
 using GraphQL.DataLoader;
 using GraphQL.Execution;
@@ -36,7 +37,6 @@ public Startup(IOptions<AdminOptions> adminOptions, IHostEnvironment hostingEnvi
         public override void ConfigureServices(IServiceCollection services)
         {
             services.AddSingleton<IDocumentExecuter, DocumentExecuter>();
-            services.AddSingleton<IDocumentWriter, DocumentWriter>();
             services.AddSingleton<IDataLoaderContextAccessor, DataLoaderContextAccessor>();
             services.AddSingleton<IDocumentExecutionListener, DataLoaderDocumentListener>();
 
@@ -47,11 +47,13 @@ public override void ConfigureServices(IServiceCollection services)
             services.AddSingleton<IErrorInfoProvider>(services =>
             {
                 var settings = services.GetRequiredService<IOptions<GraphQLSettings>>();
-                return new ErrorInfoProvider(new ErrorInfoProviderOptions { ExposeExceptionStackTrace = settings.Value.ExposeExceptions });
+                return new ErrorInfoProvider(new ErrorInfoProviderOptions { ExposeExceptionDetails = settings.Value.ExposeExceptions });
             });
 
             services.AddScoped<IPermissionProvider, Permissions>();
             services.AddTransient<INavigationProvider, AdminMenu>();
+            services.AddSingleton<GraphQLMiddleware>();
+            services.AddGraphQL(builder => builder.AddSystemTextJson());
 
             services.AddOptions<GraphQLSettings>().Configure<IShellConfiguration>((c, configuration) =>
             {
@@ -72,7 +74,7 @@ public override void ConfigureServices(IServiceCollection services)
                     User = ctx.User,
                 };
                 c.ExposeExceptions = exposeExceptions;
-                c.MaxDepth = configuration.GetValue<int?>($"OrchardCore_Apis_GraphQL:{nameof(GraphQLSettings.MaxDepth)}") ?? 20;
+                c.MaxDepth = configuration.GetValue<int?>($"OrchardCore_Apis_GraphQL:{nameof(GraphQLSettings.MaxDepth)}") ?? 100;
                 c.MaxComplexity = configuration.GetValue<int?>($"OrchardCore_Apis_GraphQL:{nameof(GraphQLSettings.MaxComplexity)}");
                 c.FieldImpact = configuration.GetValue<double?>($"OrchardCore_Apis_GraphQL:{nameof(GraphQLSettings.FieldImpact)}");
                 c.MaxNumberOfResults = configuration.GetValue<int?>($"OrchardCore_Apis_GraphQL:{nameof(GraphQLSettings.MaxNumberOfResults)}") ?? 1000;
@@ -90,7 +92,7 @@ public override void Configure(IApplicationBuilder app, IEndpointRouteBuilder ro
                 defaults: new { controller = typeof(AdminController).ControllerName(), action = nameof(AdminController.Index) }
             );
 
-            app.UseMiddleware<GraphQLMiddleware>(serviceProvider.GetService<IOptions<GraphQLSettings>>().Value);
+            app.UseMiddleware<GraphQLMiddleware>();
         }
     }
 }

src/OrchardCore.Modules/OrchardCore.Apis.GraphQL/ValidationRules/MaxNumberOfResultsValidationRule.cs

@@ -1,6 +1,7 @@
+using System;
 using System.Threading.Tasks;
-using GraphQL.Language.AST;
 using GraphQL.Validation;
+using GraphQLParser.AST;
 using Microsoft.Extensions.Localization;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -26,24 +27,24 @@ public MaxNumberOfResultsValidationRule(
             _logger = logger;
         }
 
-        public Task<INodeVisitor> ValidateAsync(ValidationContext validationContext)
+        public ValueTask<INodeVisitor> ValidateAsync(ValidationContext validationContext)
         {
-            return Task.FromResult((INodeVisitor)new NodeVisitors(
-            new MatchingNodeVisitor<Argument>((arg, visitorContext) =>
+            return ValueTask.FromResult((INodeVisitor)new NodeVisitors(
+            new MatchingNodeVisitor<GraphQLArgument>((arg, visitorContext) =>
             {
                 if ((arg.Name == "first" || arg.Name == "last") && arg.Value != null)
                 {
                     var context = (GraphQLUserContext)validationContext.UserContext;
 
                     int? value = null;
 
-                    if (arg.Value is IntValue)
+                    if (arg.Value is GraphQLIntValue)
                     {
-                        value = ((IntValue)arg.Value)?.Value;
+                        value = int.Parse((arg.Value as GraphQLIntValue).Value);
                     }
                     else
                     {
-                        if (validationContext.Inputs.TryGetValue(arg.Value.ToString(), out var input))
+                        if (validationContext.Variables.TryGetValue(arg.Value.ToString(), out var input))
                         {
                             value = (int?)input;
                         }
@@ -56,20 +57,16 @@ public Task<INodeVisitor> ValidateAsync(ValidationContext validationContext)
                         if (_maxNumberOfResultsValidationMode == MaxNumberOfResultsValidationMode.Enabled)
                         {
                             validationContext.ReportError(new ValidationError(
-                                validationContext.Document.OriginalQuery,
+                                validationContext.Document.Source,
                                 "ArgumentInputError",
                                 errorMessage,
                                 arg));
                         }
                         else
                         {
-                            _logger.LogInformation("'{IntValue}' exceeds the maximum number of results for '{ArgumentName}' ({MaxNumber})",
-                                value.Value,
-                                arg.Name,
-                                _maxNumberOfResults);
+                            _logger.LogInformation(errorMessage);
 
-                            // If disabled mode we just log info and override the arg to be maxvalue.
-                            arg = new Argument(arg.NameNode, new IntValue(_maxNumberOfResults));
+                            arg = new GraphQLArgument(arg.Name, new GraphQLIntValue(_maxNumberOfResults)); // if disabled mode we just log info and override the arg to be maxvalue
                         }
                     }
                 }