- Added support to control Persisted Query payload field name for other GraphQL servers (e.g. Relay server) which may be different than HotChocolate .NET GraphQL Server.

- Added global configuration support via FlurlGraphQLConfig.ConfigureDefaults(config => ...) so that configurable options can be set once globlly with current support for Persisted Query Field Name and Json Serializer Settings.

Author: cajuncoding

FlurlGraphQL.Querying/Flurl/FlurlGraphQLConfig.cs

@@ -0,0 +1,45 @@
+using System;
+using Newtonsoft.Json;
+
+namespace FlurlGraphQL.Querying
+{
+    public interface IFlurlGraphQLConfig
+    {
+        JsonSerializerSettings NewtonsoftJsonSerializerSettings { get; }
+        string PersistedQueryPayloadFieldName { get; }
+    }
+
+    public sealed class FlurlGraphQLConfig : IFlurlGraphQLConfig
+    {
+        public const string DefaultPersistedQueryFieldName = "id";
+
+        private FlurlGraphQLConfig()
+        {
+            NewtonsoftJsonSerializerSettings = JsonConvert.DefaultSettings?.Invoke();
+            PersistedQueryPayloadFieldName = DefaultPersistedQueryFieldName;
+        }
+
+        public static IFlurlGraphQLConfig DefaultConfig { get; private set; } = new FlurlGraphQLConfig();
+
+        /// <summary>
+        /// Configure the Default values for Sql Bulk Helpers and Materialized Data Helpers.
+        /// </summary>
+        /// <param name="configAction"></param>
+        public static void ConfigureDefaults(Action<FlurlGraphQLConfig> configAction)
+        {
+            configAction.AssertArgIsNotNull(nameof(configAction));
+
+            var newConfig = new FlurlGraphQLConfig();
+            configAction.Invoke(newConfig);
+            DefaultConfig = newConfig;
+        }
+
+        public static void ResetDefaults()
+        {
+            DefaultConfig = new FlurlGraphQLConfig();
+        }
+
+        public JsonSerializerSettings NewtonsoftJsonSerializerSettings { get; set; }
+        public string PersistedQueryPayloadFieldName { get; set; }
+    }
+}

FlurlGraphQL.Querying/Flurl/FlurlGraphQLRequest.cs

@@ -12,6 +12,7 @@
 using Flurl.Http.Content;
 using Flurl.Util;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using NullValueHandling = Flurl.NullValueHandling;
 
 namespace FlurlGraphQL.Querying
@@ -214,9 +215,7 @@ public async Task<IFlurlGraphQLResponse> PostGraphQLQueryAsync<TVariables>(
             //Execute the Request with shared Exception handling...
             return await ExecuteRequestWithExceptionHandling(async () =>
             {
-                //Execute the Query with the GraphQL Server...
-                var graphqlPayload = new FlurlGraphQLRequestPayload(graphqlQueryType, graphqlQueryOrId, this.GraphQLVariablesInternal);
-                var jsonPayload = SerializeToJsonWithOptionalGraphQLSerializerSettings(graphqlPayload);
+                var jsonPayload = BuildPostRequestJsonPayload();
 
                 //Since we have our own GraphQL Serializer Settings, our payload is already serialized so we can just send it!
                 //NOTE: Borrowed directly from the Flurl.PostJsonAsync() method but 
@@ -232,6 +231,29 @@ public async Task<IFlurlGraphQLResponse> PostGraphQLQueryAsync<TVariables>(
             }).ConfigureAwait(false);
         }
 
+        protected string BuildPostRequestJsonPayload()
+        {
+            //Execute the Query with the GraphQL Server...
+            //var graphqlPayload = new FlurlGraphQLRequestPayloadBuilder(graphqlQueryType, graphqlQueryOrId, this.GraphQLVariablesInternal);
+            var graphqlPayload = new Dictionary<string, object>();
+            graphqlPayload.Add("variables", this.GraphQLVariablesInternal);
+
+            switch (GraphQLQueryType)
+            {
+                case GraphQLQueryType.Query: 
+                    graphqlPayload.Add("query", this.GraphQLQuery);
+                    break;
+                case GraphQLQueryType.PersistedQuery:
+                    graphqlPayload.Add(GetPersistedQueryPayloadFieldName(), this.GraphQLQuery);
+                    break;
+                default: 
+                    throw new ArgumentOutOfRangeException(nameof(this.GraphQLQueryType), $"GraphQL payload for Query Type [{this.GraphQLQueryType}] cannot be initialized.");
+            }
+
+            var json = SerializeToJsonWithOptionalGraphQLSerializerSettings(graphqlPayload);
+            return json;
+        }
+
         /// <summary>
         /// STRONGLY DISCOURAGED -- Execute the GraphQL query with the Server using GET request.
         /// This is Strongly Discouraged as POST requests are much more robust. But this is provided for edge cases where GET requests must be used.
@@ -267,9 +289,14 @@ public async Task<IFlurlGraphQLResponse> GetGraphQLQueryAsync<TVariables>(
             {
                 switch (this.GraphQLQueryType)
                 {
-                    case GraphQLQueryType.Query: this.SetQueryParam("query", this.GraphQLQuery); break;
-                    case GraphQLQueryType.PersistedQuery: this.SetQueryParam("id", this.GraphQLQuery); break;
-                    default: throw new ArgumentOutOfRangeException(nameof(graphqlQueryType), $"GraphQL Query Type [{graphqlQueryType}] cannot be initialized.");
+                    case GraphQLQueryType.Query: 
+                        this.SetQueryParam("query", this.GraphQLQuery); 
+                        break;
+                    case GraphQLQueryType.PersistedQuery: 
+                        this.SetQueryParam(GetPersistedQueryPayloadFieldName(), this.GraphQLQuery); 
+                        break;
+                    default: 
+                        throw new ArgumentOutOfRangeException(nameof(graphqlQueryType), $"GraphQL Query Type [{graphqlQueryType}] cannot be initialized.");
                 }
 
                 if (this.GraphQLVariablesInternal?.Any() ?? false)
@@ -288,6 +315,26 @@ public async Task<IFlurlGraphQLResponse> GetGraphQLQueryAsync<TVariables>(
             }).ConfigureAwait(false);
         }
 
+        protected string GetPersistedQueryPayloadFieldName()
+        {
+            return ContextBag.TryGetValue(ContextItemKeys.PersistedQueryPayloadFieldName, out var fieldName)
+                ? fieldName.ToString()
+                : FlurlGraphQLConfig.DefaultConfig.PersistedQueryPayloadFieldName ?? FlurlGraphQLConfig.DefaultPersistedQueryFieldName;
+        }
+
+        protected string SerializeToJsonWithOptionalGraphQLSerializerSettings(object obj)
+        {
+            var jsonSerializerSettings = ContextBag?.TryGetValue(nameof(JsonSerializerSettings), out var serializerSettings) ?? false
+                ? serializerSettings as JsonSerializerSettings
+                : null;
+
+            //Ensure that all json parsing uses a Serializer with the GraphQL Contract Resolver...
+            //NOTE: We still support normal Serializer Default settings via Newtonsoft framework!
+            //var jsonSerializer = JsonSerializer.CreateDefault(jsonSerializerSettings);
+            var json = JsonConvert.SerializeObject(obj, jsonSerializerSettings);
+            return json;
+        }
+
         protected async Task<FlurlGraphQLResponse> ExecuteRequestWithExceptionHandling(Func<Task<FlurlGraphQLResponse>> sendRequestFunc)
         {
             sendRequestFunc.AssertArgIsNotNull(nameof(sendRequestFunc));
@@ -312,20 +359,6 @@ protected async Task<FlurlGraphQLResponse> ExecuteRequestWithExceptionHandling(F
             }
         }
 
-        protected string SerializeToJsonWithOptionalGraphQLSerializerSettings(object obj)
-        {
-            var jsonSerializerSettings = ContextBag?.TryGetValue(nameof(JsonSerializerSettings), out var serializerSettings) ?? false
-                ? serializerSettings as JsonSerializerSettings
-                : null;
-
-            //Ensure that all json parsing uses a Serializer with the GraphQL Contract Resolver...
-            //NOTE: We still support normal Serializer Default settings via Newtonsoft framework!
-            //var jsonSerializer = JsonSerializer.CreateDefault(jsonSerializerSettings);
-            var json = JsonConvert.SerializeObject(obj, jsonSerializerSettings);
-            return json;
-        }
-
-
         #endregion
 
         #region IFlurlRequest Interface Implementations

FlurlGraphQL.Querying/Flurl/FlurlGraphQLRequestExtensions.cs

@@ -10,6 +10,12 @@
 
 namespace FlurlGraphQL.Querying
 {
+    public static class ContextItemKeys
+    {
+        public const string NewtonsoftJsonSerializerSettings = nameof(NewtonsoftJsonSerializerSettings);
+        public const string PersistedQueryPayloadFieldName = nameof(PersistedQueryPayloadFieldName);
+    }
+
     public static class FlurlGraphQLRequestExtensions
     {
         #region ToGraphQLRequest() Internal Helpers...
@@ -212,7 +218,8 @@ public static IFlurlGraphQLRequest SetGraphQLVariables(this IFlurlRequest reques
 
         #endregion
 
-        #region NewtonsoftJson Serializer Settings (ONLY Available after an IFlurlRequest is initialized...
+        #region Configuration Extension - NewtonsoftJson Serializer Settings (ONLY Available after an IFlurlRequest is initialized)...
+
 
         /// <summary>
         /// Initialize the query body for a GraphQL query request.
@@ -222,11 +229,27 @@ public static IFlurlGraphQLRequest SetGraphQLVariables(this IFlurlRequest reques
         /// <returns>Returns an IFlurlGraphQLRequest for ready to chain for further initialization or execution.</returns>
         public static IFlurlGraphQLRequest SetGraphQLNewtonsoftJsonSerializerSettings(this IFlurlRequest request, JsonSerializerSettings jsonSerializerSettings)
         {
+            jsonSerializerSettings.AssertArgIsNotNull(nameof(jsonSerializerSettings));
             var graphqlRequest = (FlurlGraphQLRequest)request.ToGraphQLRequest();
-            graphqlRequest.SetContextItem(nameof(JsonSerializerSettings), jsonSerializerSettings);
+            graphqlRequest.SetContextItem(ContextItemKeys.NewtonsoftJsonSerializerSettings, jsonSerializerSettings);
             return graphqlRequest;
         }
 
+        /// <summary>
+        /// Initialize the query body for a GraphQL query request.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="fieldName"></param>
+        /// <returns>Returns an IFlurlGraphQLRequest for ready to chain for further initialization or execution.</returns>
+        public static IFlurlGraphQLRequest SetPersistedQueryPayloadFieldName(this IFlurlRequest request, string fieldName)
+        {
+            fieldName.AssertArgIsNotNullOrBlank(nameof(fieldName));
+            var graphqlRequest = (FlurlGraphQLRequest)request.ToGraphQLRequest();
+            graphqlRequest.SetContextItem(ContextItemKeys.PersistedQueryPayloadFieldName, fieldName);
+            return graphqlRequest;
+        }
+
+
         #endregion
 
         #region PostGraphQLQueryAsnc()...

FlurlGraphQL.Querying/Flurl/InternalClasses/FlurlGraphQLRequestPayload.cs

@@ -34,7 +34,7 @@ public IGraphQLQueryResults<TResult> LoadTypedResults<TResult>(string queryOpera
                 ? queryResultJson.FirstField()
                 : queryResultJson.Field(queryOperationName);
 
-            var jsonSerializerSettings = ContextBag?.TryGetValue(nameof(JsonSerializerSettings), out var serializerSettings) ?? false
+            var jsonSerializerSettings = ContextBag?.TryGetValue(ContextItemKeys.NewtonsoftJsonSerializerSettings, out var serializerSettings) ?? false
                 ? serializerSettings as JsonSerializerSettings
                 : null;
 

FlurlGraphQL.Querying/Flurl/InternalClasses/FlurlGraphQLResponsePayload.cs

@@ -2,9 +2,9 @@
 
 	<PropertyGroup>
 		<TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
-		<Version>1.1.0</Version>
-		<AssemblyVersion>1.1.0</AssemblyVersion>
-		<FileVersion>1.1.0</FileVersion>
+		<Version>1.2.0</Version>
+		<AssemblyVersion>1.2.0</AssemblyVersion>
+		<FileVersion>1.2.0</FileVersion>
 		<Authors>BBernard / CajunCoding</Authors>
 		<Company>CajunCoding</Company>
 		<Description>GraphQL client querying extensions for Flurl.Http -- lightweight, simplified, asynchronous, fluent GraphQL client querying API extensions for the amazing Flurl Http library!</Description>
@@ -14,13 +14,15 @@
 		<RepositoryUrl>https://github.com/cajuncoding/FlurlGraphQL</RepositoryUrl>
 		<PackageReleaseNotes>
 			Release Notes:
-			- Added support for Persisted Queries via .WithGraphQLPersistedQuery() api.
-			- Added support to execute GraphQL as GET requests for edge cases, though POST requests are highly encouraged.
-			- Improved consistency of use of (optional) custom Json Serialization settings when SetGraphQLNewtonsoftJsonSerializerSettings() is used to override the default GraphQL settings; 
-				now initial query payloads sent also use these instead of the default Flurl settings. Some edge cases in GraphQL may require more advanced control over the Json serialization process 
-				than the default Flurl Serializer interface offers and the default settings are internal and not accessible so we provide a way to control this for GraphQL specifically.
+			- Added support to control the Persisted Query payload field name for other GraphQL servers (e.g. Relay server) which may be different than HotChocolate .NET GraphQL Server.
+			- Added global configuration support via FlurlGraphQLConfig.ConfigureDefaults(config => ...) so that configurable options can be set once globlly with current support for Persisted Query Field Name and Json Serializer Settings.
 
 			Prior Release Notes:
+			- Added support for Persisted Queries via .WithGraphQLPersistedQuery() api.
+			- Added support to execute GraphQL as GET requests for edge cases, though POST requests are highly encouraged.
+			- Improved consistency of use of (optional) custom Json Serialization settings when SetGraphQLNewtonsoftJsonSerializerSettings() is used to override the default GraphQL settings;
+			now initial query payloads sent also use these instead of the default Flurl settings. Some edge cases in GraphQL may require more advanced control over the Json serialization process
+			than the default Flurl Serializer interface offers and the default settings are internal and not accessible so we provide a way to control this for GraphQL specifically.
 			- Initial release of the GraphQL Querying (only) extensions for Flurl.Http.
 			- Supporting querying of typed data results with support for Relay based Cursor Paging, HotChocolate based Offset paging, Batch querying, Flurl style exception handling,
 			and simplified data models when using nested paginated results from GraphQL.

FlurlGraphQL.Querying/FlurlGraphQL.Querying.csproj

@@ -0,0 +1,42 @@
+using System;
+using System.Threading.Tasks;
+using FlurlGraphQL.Querying.Tests.Models;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Newtonsoft.Json;
+
+namespace FlurlGraphQL.Querying.Tests
+{
+    [TestClass]
+    public class FlurlGraphQLConfigTests : BaseFlurlGraphQLTest
+    {
+        [TestMethod]
+        public void TestGlobalConfig()
+        {
+            var defaultConfig = FlurlGraphQLConfig.DefaultConfig;
+            Assert.AreEqual(FlurlGraphQLConfig.DefaultPersistedQueryFieldName, defaultConfig.PersistedQueryPayloadFieldName);
+            Assert.IsNull(defaultConfig.NewtonsoftJsonSerializerSettings);
+
+            FlurlGraphQLConfig.ConfigureDefaults(config =>
+            {
+                config.PersistedQueryPayloadFieldName = "test";
+                config.NewtonsoftJsonSerializerSettings = new JsonSerializerSettings()
+                {
+                    MaxDepth = 99,
+                    NullValueHandling = NullValueHandling.Include,
+                    TypeNameHandling = TypeNameHandling.None
+                };
+            });
+
+            var newConfig = FlurlGraphQLConfig.DefaultConfig;
+            Assert.IsTrue(newConfig is IFlurlGraphQLConfig);
+            Assert.AreEqual("test", newConfig.PersistedQueryPayloadFieldName);
+            Assert.AreEqual(99, newConfig.NewtonsoftJsonSerializerSettings.MaxDepth);
+
+            Assert.AreNotEqual(defaultConfig.PersistedQueryPayloadFieldName, newConfig.PersistedQueryPayloadFieldName);
+            Assert.AreNotEqual(defaultConfig.NewtonsoftJsonSerializerSettings, newConfig.NewtonsoftJsonSerializerSettings);
+
+            //We need to RESET our Defaults so we don't affect other Unit Tests...
+            FlurlGraphQLConfig.ResetDefaults();
+        }
+    }
+}