Refactor GraphQLClient and related classes to use a generic GraphQLRequest type for improved flexibility and clarity

clement911 · clement911 · commit 2a75e5af0434 · 2025-07-28T20:30:13.000+10:00
diff --git a/GraphQLSharp.Tests/GraphQLClientTests.cs b/GraphQLSharp.Tests/GraphQLClientTests.cs
@@ -7,7 +7,7 @@ namespace GraphQLSharp.Tests;
 [TestClass]
 public class GraphQLClientTests
 {
-    private GraphQLClient<QueryRoot, Mutation, GraphQLClientOptions> _client;
+    private GraphQLClient<GraphQLRequest, GraphQLClientOptions, QueryRoot, Mutation> _client;
 
     [TestInitialize]
     public void Initialize()
diff --git a/GraphQLSharp.Tests/shopify.cs b/GraphQLSharp.Tests/shopify.cs
@@ -10,7 +10,7 @@
 
 namespace Shopify
 {
-    public partial class GraphQLClient : GraphQLClient<Shopify.Types.QueryRoot, Shopify.Types.Mutation, GraphQLClientOptions>
+    public partial class GraphQLClient : GraphQLClient<GraphQLRequest, GraphQLClientOptions, Shopify.Types.QueryRoot, Shopify.Types.Mutation>
     {
         public GraphQLClient(GraphQLClientOptions? defaultOptions = null) : base(defaultOptions!)
         {
diff --git a/GraphQLSharp.Tests/square.cs b/GraphQLSharp.Tests/square.cs
@@ -10,7 +10,7 @@
 
 namespace Square
 {
-    public partial class GraphQLClient : GraphQLClient<Square.Types.Query, GraphQLClientOptions>
+    public partial class GraphQLClient : GraphQLClient<GraphQLRequest, GraphQLClientOptions, Square.Types.Query>
     {
         public GraphQLClient(GraphQLClientOptions? defaultOptions = null) : base(defaultOptions!)
         {
diff --git a/GraphQLSharp/Client/GraphQLClient.cs b/GraphQLSharp/Client/GraphQLClient.cs
@@ -5,7 +5,8 @@
 
 namespace GraphQLSharp;
 
-public class GraphQLClient<TQueryRoot, TMutationRoot, TClientOptions> : GraphQLClient<TQueryRoot, TClientOptions>
+public class GraphQLClient<TGraphQLRequest, TClientOptions, TQueryRoot, TMutationRoot> : GraphQLClient<TGraphQLRequest, TClientOptions, TQueryRoot>
+    where TGraphQLRequest : GraphQLRequest, new()
     where TQueryRoot : class
     where TMutationRoot : class
     where TClientOptions : GraphQLClientOptions
@@ -19,13 +20,14 @@ public Task<GraphQLResponse<TMutationRoot>> ExecuteMutationAsync([StringSyntax("
         return ExecuteAsync<TMutationRoot>(query, options, cancellationToken);
     }
 
-    public Task<GraphQLResponse<TMutationRoot>> ExecuteMutationAsync(GraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)
+    public Task<GraphQLResponse<TMutationRoot>> ExecuteMutationAsync(TGraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)
     {
         return ExecuteAsync<TMutationRoot>(request, options, cancellationToken);
     }
 }
 
-public class GraphQLClient<TQueryRoot, TClientOptions> : GraphQLClient<TClientOptions>
+public class GraphQLClient<TGraphQLRequest, TClientOptions, TQueryRoot> : GraphQLClient<TGraphQLRequest, TClientOptions>
+    where TGraphQLRequest : GraphQLRequest, new()
     where TQueryRoot : class
     where TClientOptions : GraphQLClientOptions
 {
@@ -38,25 +40,26 @@ public Task<GraphQLResponse<TQueryRoot>> ExecuteQueryAsync([StringSyntax("GraphQ
         return ExecuteAsync<TQueryRoot>(query, options, cancellationToken);
     }
 
-    public Task<GraphQLResponse<TQueryRoot>> ExecuteQueryAsync(GraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)
+    public Task<GraphQLResponse<TQueryRoot>> ExecuteQueryAsync(TGraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)
     {
         return ExecuteAsync<TQueryRoot>(request, options, cancellationToken);
     }
 }
 
-public class GraphQLCLient : GraphQLClient<GraphQLClientOptions>
+public class GraphQLCLient : GraphQLClient<GraphQLRequest, GraphQLClientOptions>
 {
     public GraphQLCLient(GraphQLClientOptions defaultOptions = null) : base(defaultOptions)
     {
     }
 }
 
-public class GraphQLClient<TClientOptions>
+public class GraphQLClient<TGraphQLRequest, TClientOptions>
+    where TGraphQLRequest : GraphQLRequest, new()
     where TClientOptions : GraphQLClientOptions
 {
     private static readonly HttpClient _defaultHttpClient = new();
 
-    private static readonly ProductInfoHeaderValue _defaultUserAgent = new(typeof(GraphQLClient<TClientOptions>).Assembly.GetName().Name!, typeof(GraphQLClient<TClientOptions>).Assembly.GetName().Version!.ToString());
+    private static readonly ProductInfoHeaderValue _defaultUserAgent = new(typeof(GraphQLClient<TGraphQLRequest, TClientOptions>).Assembly.GetName().Name!, typeof(GraphQLClient<TGraphQLRequest, TClientOptions>).Assembly.GetName().Version!.ToString());
 
     private readonly TClientOptions _defaultOptions;
 
@@ -75,16 +78,16 @@ public Task<GraphQLResponse<JsonElement>> ExecuteAsync([StringSyntax("GraphQL")]
 
     public Task<GraphQLResponse<T>> ExecuteAsync<T>([StringSyntax("GraphQL")] string query, TClientOptions options = null, CancellationToken cancellationToken = default)
     {
-        return ExecuteAsync<T>(new GraphQLRequest { query = query }, options, cancellationToken);
+        return ExecuteAsync<T>(new TGraphQLRequest { query = query }, options, cancellationToken);
     }
 
-    public Task<GraphQLResponse<JsonElement>> ExecuteAsync(GraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)
+    public Task<GraphQLResponse<JsonElement>> ExecuteAsync(TGraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)
     {
         //returing JsonElement and not JsonDocument because JsonDocument is disposable and we don't want to force the user to dispose it
         return ExecuteAsync<JsonElement>(request, options, cancellationToken);
     }
 
-    public async Task<GraphQLResponse<T>> ExecuteAsync<T>(GraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)
+    public async Task<GraphQLResponse<T>> ExecuteAsync<T>(TGraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)
     {
         var interceptor = options?.Interceptor ?? _defaultOptions?.Interceptor ?? DefaultInterceptor;
 
@@ -100,7 +103,7 @@ public async Task<GraphQLResponse<T>> ExecuteAsync<T>(GraphQLRequest request, TC
         }
     }
 
-    private async Task<GraphQLResponse<T>> ExecuteCoreAsync<T>(GraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)
+    private async Task<GraphQLResponse<T>> ExecuteCoreAsync<T>(TGraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)
     {
         HttpResponse httpResponse = null;
         try
@@ -151,8 +154,9 @@ protected virtual void ValidateOptions(TClientOptions defaultOptions, TClientOpt
     {
     }
 
-    private HttpRequestMessage CreateHttpRequest(GraphQLRequest request, TClientOptions options)
+    private HttpRequestMessage CreateHttpRequest(TGraphQLRequest request, TClientOptions options)
     {
+        _ = request.query ?? throw new ArgumentNullException(nameof(request.query));
         ValidateOptions(_defaultOptions, options);
         var uri = options?.Uri ?? _defaultOptions?.Uri ?? throw new ArgumentNullException($"{nameof(options)}.{nameof(options.Uri)}");
         var requestMessage = new HttpRequestMessage
diff --git a/GraphQLSharp/Client/GraphQLRequest.cs b/GraphQLSharp/Client/GraphQLRequest.cs
@@ -6,7 +6,7 @@ namespace GraphQLSharp;
 public class GraphQLRequest
 {
     [StringSyntax("GraphQL")]
-    public required string query { get; set; }
+    public string query { get; set; }
 
     public string operationName { get; set; }
 
diff --git a/GraphQLSharp/Client/Interception/IInterceptor.cs b/GraphQLSharp/Client/Interception/IInterceptor.cs
@@ -7,11 +7,13 @@ namespace GraphQLSharp;
 /// </summary>
 public interface IInterceptor
 {
-    Task<GraphQLResponse<T>> InterceptRequestAsync<T, TClientOptions>(GraphQLRequest request,
-                                                                        TClientOptions defaultOptions,
-                                                                        TClientOptions options,
-                                                                        CancellationToken cancellationToken,
-                                                                        Func<GraphQLRequest, CancellationToken, Task<GraphQLResponse<T>>> executeAsync
-                                                                        )
-                                                                    where TClientOptions : GraphQLClientOptions;
+    Task<GraphQLResponse<TData>> InterceptRequestAsync<TGraphQLRequest, TClientOptions, TData>(
+                                TGraphQLRequest request,
+                                TClientOptions defaultOptions,
+                                TClientOptions options,
+                                CancellationToken cancellationToken,
+                                Func<TGraphQLRequest, CancellationToken,
+                                Task<GraphQLResponse<TData>>> executeAsync)
+                where TGraphQLRequest : GraphQLRequest, new()
+                where TClientOptions : GraphQLClientOptions;
 }
diff --git a/GraphQLSharp/Client/Interception/NoOpInterceptor.cs b/GraphQLSharp/Client/Interception/NoOpInterceptor.cs
@@ -6,7 +6,9 @@ public class NoOpInterceptor : IInterceptor
 
     private NoOpInterceptor() { }
 
-    public Task<GraphQLResponse<T>> InterceptRequestAsync<T, TClientOptions>(GraphQLRequest request, TClientOptions defaultOptions, TClientOptions options, CancellationToken cancellationToken, Func<GraphQLRequest, CancellationToken, Task<GraphQLResponse<T>>> executeAsync) where TClientOptions : GraphQLClientOptions
+    public Task<GraphQLResponse<T>> InterceptRequestAsync<TGraphQLRequest, TClientOptions, T>(TGraphQLRequest request, TClientOptions defaultOptions, TClientOptions options, CancellationToken cancellationToken, Func<TGraphQLRequest, CancellationToken, Task<GraphQLResponse<T>>> executeAsync)
+        where TGraphQLRequest : GraphQLRequest, new()
+        where TClientOptions : GraphQLClientOptions
     {
         return executeAsync(request, cancellationToken);
     }
diff --git a/GraphQLSharp/TypeGenerator/GraphQLTypeGenerator.cs b/GraphQLSharp/TypeGenerator/GraphQLTypeGenerator.cs
@@ -144,6 +144,7 @@ public string GenerateTypes(GraphQLTypeGeneratorOptions options, JsonDocument in
         var queryType = schemaElt.GetProperty("queryType").GetProperty("name").GetString();
         var mutationType = schemaElt.TryGetProperty("mutationType", out var elt) && elt.ValueKind == JsonValueKind.Object ? elt.GetProperty("name").GetString() : null;
         var clientOptionsTypeName = options.ClientOptionsType == null ? typeof(GraphQLClientOptions).Name : options.ClientOptionsType.FullName;
+        var graphQLRequestTypeName = options.GraphQLRequestType == null ? typeof(GraphQLRequest).Name : options.GraphQLRequestType.FullName;
 
         var context = new Context();
         var str = context.StrBuilder;
@@ -158,7 +159,7 @@ public string GenerateTypes(GraphQLTypeGeneratorOptions options, JsonDocument in
                 .AppendLine($"namespace {options.NamespaceClient} {{")
                 //generating partial class to allow for extension methods and member overrides
                 .AppendLine("public partial class GraphQLClient : ")
-                .AppendLine(mutationType == null ? $"GraphQLClient<{options.NamespaceTypes}.{queryType}, {clientOptionsTypeName}>" : $"GraphQLClient<{options.NamespaceTypes}.{queryType}, {options.NamespaceTypes}.{mutationType}, {clientOptionsTypeName}>")
+                .AppendLine(mutationType == null ? $"GraphQLClient<{graphQLRequestTypeName}, {clientOptionsTypeName}, {options.NamespaceTypes}.{queryType}>" : $"GraphQLClient<{graphQLRequestTypeName}, {clientOptionsTypeName}, {options.NamespaceTypes}.{queryType}, {options.NamespaceTypes}.{mutationType}>")
                 .AppendLine($$"""
                     {
                         public GraphQLClient({{clientOptionsTypeName}}? defaultOptions = null) : base(defaultOptions!)
diff --git a/GraphQLSharp/TypeGenerator/GraphQLTypeGeneratorOptions.cs b/GraphQLSharp/TypeGenerator/GraphQLTypeGeneratorOptions.cs
@@ -35,6 +35,12 @@ public class GraphQLTypeGeneratorOptions
     /// </summary>
     public Type ClientOptionsType { get; set; }
 
+    /// <summary>
+    /// An optional Type that represents the GraphQLRequest for the generated GraphQL client.
+    /// The type must inherit from GraphQLRequest.
+    /// </summary>
+    public Type GraphQLRequestType { get; set; }
+
     /// <summary>
     /// Indicates whether to generate member names for the GraphQL types.
     /// Defaults to false

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ namespace GraphQLSharp.Tests;`
`7`	`7`	`[TestClass]`
`8`	`8`	`public class GraphQLClientTests`
`9`	`9`	`{`
`10`		`- private GraphQLClient<QueryRoot, Mutation, GraphQLClientOptions> _client;`
	`10`	`+ private GraphQLClient<GraphQLRequest, GraphQLClientOptions, QueryRoot, Mutation> _client;`
`11`	`11`
`12`	`12`	`[TestInitialize]`
`13`	`13`	`public void Initialize()`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`
`11`	`11`	`namespace Shopify`
`12`	`12`	`{`
`13`		`- public partial class GraphQLClient : GraphQLClient<Shopify.Types.QueryRoot, Shopify.Types.Mutation, GraphQLClientOptions>`
	`13`	`+ public partial class GraphQLClient : GraphQLClient<GraphQLRequest, GraphQLClientOptions, Shopify.Types.QueryRoot, Shopify.Types.Mutation>`
`14`	`14`	`{`
`15`	`15`	`public GraphQLClient(GraphQLClientOptions? defaultOptions = null) : base(defaultOptions!)`
`16`	`16`	`{`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,8 @@`
`5`	`5`
`6`	`6`	`namespace GraphQLSharp;`
`7`	`7`
`8`		`-public class GraphQLClient<TQueryRoot, TMutationRoot, TClientOptions> : GraphQLClient<TQueryRoot, TClientOptions>`
	`8`	`+public class GraphQLClient<TGraphQLRequest, TClientOptions, TQueryRoot, TMutationRoot> : GraphQLClient<TGraphQLRequest, TClientOptions, TQueryRoot>`
	`9`	`+ where TGraphQLRequest : GraphQLRequest, new()`
`9`	`10`	`where TQueryRoot : class`
`10`	`11`	`where TMutationRoot : class`
`11`	`12`	`where TClientOptions : GraphQLClientOptions`
`@@ -19,13 +20,14 @@ public Task<GraphQLResponse<TMutationRoot>> ExecuteMutationAsync([StringSyntax("`
`19`	`20`	`return ExecuteAsync<TMutationRoot>(query, options, cancellationToken);`
`20`	`21`	`}`
`21`	`22`
`22`		`- public Task<GraphQLResponse<TMutationRoot>> ExecuteMutationAsync(GraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)`
	`23`	`+ public Task<GraphQLResponse<TMutationRoot>> ExecuteMutationAsync(TGraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)`
`23`	`24`	`{`
`24`	`25`	`return ExecuteAsync<TMutationRoot>(request, options, cancellationToken);`
`25`	`26`	`}`
`26`	`27`	`}`
`27`	`28`
`28`		`-public class GraphQLClient<TQueryRoot, TClientOptions> : GraphQLClient<TClientOptions>`
	`29`	`+public class GraphQLClient<TGraphQLRequest, TClientOptions, TQueryRoot> : GraphQLClient<TGraphQLRequest, TClientOptions>`
	`30`	`+ where TGraphQLRequest : GraphQLRequest, new()`
`29`	`31`	`where TQueryRoot : class`
`30`	`32`	`where TClientOptions : GraphQLClientOptions`
`31`	`33`	`{`
`@@ -38,25 +40,26 @@ public Task<GraphQLResponse<TQueryRoot>> ExecuteQueryAsync([StringSyntax("GraphQ`
`38`	`40`	`return ExecuteAsync<TQueryRoot>(query, options, cancellationToken);`
`39`	`41`	`}`
`40`	`42`
`41`		`- public Task<GraphQLResponse<TQueryRoot>> ExecuteQueryAsync(GraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)`
	`43`	`+ public Task<GraphQLResponse<TQueryRoot>> ExecuteQueryAsync(TGraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)`
`42`	`44`	`{`
`43`	`45`	`return ExecuteAsync<TQueryRoot>(request, options, cancellationToken);`
`44`	`46`	`}`
`45`	`47`	`}`
`46`	`48`
`47`		`-public class GraphQLCLient : GraphQLClient<GraphQLClientOptions>`
	`49`	`+public class GraphQLCLient : GraphQLClient<GraphQLRequest, GraphQLClientOptions>`
`48`	`50`	`{`
`49`	`51`	`public GraphQLCLient(GraphQLClientOptions defaultOptions = null) : base(defaultOptions)`
`50`	`52`	`{`
`51`	`53`	`}`
`52`	`54`	`}`
`53`	`55`
`54`		`-public class GraphQLClient<TClientOptions>`
	`56`	`+public class GraphQLClient<TGraphQLRequest, TClientOptions>`
	`57`	`+ where TGraphQLRequest : GraphQLRequest, new()`
`55`	`58`	`where TClientOptions : GraphQLClientOptions`
`56`	`59`	`{`
`57`	`60`	`private static readonly HttpClient _defaultHttpClient = new();`
`58`	`61`
`59`		`- private static readonly ProductInfoHeaderValue _defaultUserAgent = new(typeof(GraphQLClient<TClientOptions>).Assembly.GetName().Name!, typeof(GraphQLClient<TClientOptions>).Assembly.GetName().Version!.ToString());`
	`62`	`+ private static readonly ProductInfoHeaderValue _defaultUserAgent = new(typeof(GraphQLClient<TGraphQLRequest, TClientOptions>).Assembly.GetName().Name!, typeof(GraphQLClient<TGraphQLRequest, TClientOptions>).Assembly.GetName().Version!.ToString());`
`60`	`63`
`61`	`64`	`private readonly TClientOptions _defaultOptions;`
`62`	`65`
`@@ -75,16 +78,16 @@ public Task<GraphQLResponse<JsonElement>> ExecuteAsync([StringSyntax("GraphQL")]`
`75`	`78`
`76`	`79`	`public Task<GraphQLResponse<T>> ExecuteAsync<T>([StringSyntax("GraphQL")] string query, TClientOptions options = null, CancellationToken cancellationToken = default)`
`77`	`80`	`{`
`78`		`- return ExecuteAsync<T>(new GraphQLRequest { query = query }, options, cancellationToken);`
	`81`	`+ return ExecuteAsync<T>(new TGraphQLRequest { query = query }, options, cancellationToken);`
`79`	`82`	`}`
`80`	`83`
`81`		`- public Task<GraphQLResponse<JsonElement>> ExecuteAsync(GraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)`
	`84`	`+ public Task<GraphQLResponse<JsonElement>> ExecuteAsync(TGraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)`
`82`	`85`	`{`
`83`	`86`	`//returing JsonElement and not JsonDocument because JsonDocument is disposable and we don't want to force the user to dispose it`
`84`	`87`	`return ExecuteAsync<JsonElement>(request, options, cancellationToken);`
`85`	`88`	`}`
`86`	`89`
`87`		`- public async Task<GraphQLResponse<T>> ExecuteAsync<T>(GraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)`
	`90`	`+ public async Task<GraphQLResponse<T>> ExecuteAsync<T>(TGraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)`
`88`	`91`	`{`
`89`	`92`	`var interceptor = options?.Interceptor ?? _defaultOptions?.Interceptor ?? DefaultInterceptor;`
`90`	`93`
`@@ -100,7 +103,7 @@ public async Task<GraphQLResponse<T>> ExecuteAsync<T>(GraphQLRequest request, TC`
`100`	`103`	`}`
`101`	`104`	`}`
`102`	`105`
`103`		`- private async Task<GraphQLResponse<T>> ExecuteCoreAsync<T>(GraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)`
	`106`	`+ private async Task<GraphQLResponse<T>> ExecuteCoreAsync<T>(TGraphQLRequest request, TClientOptions options = null, CancellationToken cancellationToken = default)`
`104`	`107`	`{`
`105`	`108`	`HttpResponse httpResponse = null;`
`106`	`109`	`try`
`@@ -151,8 +154,9 @@ protected virtual void ValidateOptions(TClientOptions defaultOptions, TClientOpt`
`151`	`154`	`{`
`152`	`155`	`}`
`153`	`156`
`154`		`- private HttpRequestMessage CreateHttpRequest(GraphQLRequest request, TClientOptions options)`
	`157`	`+ private HttpRequestMessage CreateHttpRequest(TGraphQLRequest request, TClientOptions options)`
`155`	`158`	`{`
	`159`	`+ _ = request.query ?? throw new ArgumentNullException(nameof(request.query));`
`156`	`160`	`ValidateOptions(_defaultOptions, options);`
`157`	`161`	`var uri = options?.Uri ?? _defaultOptions?.Uri ?? throw new ArgumentNullException($"{nameof(options)}.{nameof(options.Uri)}");`
`158`	`162`	`var requestMessage = new HttpRequestMessage`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ namespace GraphQLSharp;`
`6`	`6`	`public class GraphQLRequest`
`7`	`7`	`{`
`8`	`8`	`[StringSyntax("GraphQL")]`
`9`		`- public required string query { get; set; }`
	`9`	`+ public string query { get; set; }`
`10`	`10`
`11`	`11`	`public string operationName { get; set; }`
`12`	`12`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,9 @@ public class NoOpInterceptor : IInterceptor`
`6`	`6`
`7`	`7`	`private NoOpInterceptor() { }`
`8`	`8`
`9`		`- public Task<GraphQLResponse<T>> InterceptRequestAsync<T, TClientOptions>(GraphQLRequest request, TClientOptions defaultOptions, TClientOptions options, CancellationToken cancellationToken, Func<GraphQLRequest, CancellationToken, Task<GraphQLResponse<T>>> executeAsync) where TClientOptions : GraphQLClientOptions`
	`9`	`+ public Task<GraphQLResponse<T>> InterceptRequestAsync<TGraphQLRequest, TClientOptions, T>(TGraphQLRequest request, TClientOptions defaultOptions, TClientOptions options, CancellationToken cancellationToken, Func<TGraphQLRequest, CancellationToken, Task<GraphQLResponse<T>>> executeAsync)`
	`10`	`+ where TGraphQLRequest : GraphQLRequest, new()`
	`11`	`+ where TClientOptions : GraphQLClientOptions`
`10`	`12`	`{`
`11`	`13`	`return executeAsync(request, cancellationToken);`
`12`	`14`	`}`