CreateQueryRequestInternalAsync(
HttpContext context,
IServiceProvider services)
{
IQueryRequestBuilder builder =
await CreateQueryRequestAsync(context)
.ConfigureAwait(false);
OnCreateRequestAsync onCreateRequest = Options.OnCreateRequest
?? GetService<OnCreateRequestAsync>(context);
builder.AddProperty(nameof(HttpContext), context);
builder.AddProperty(nameof(ClaimsPrincipal), context.GetUser());
builder.SetServices(services);
if (context.IsTracingEnabled())
{
builder.AddProperty(ContextDataKeys.EnableTracing, true);
}
if (onCreateRequest != null)
{
CancellationToken requestAborted =
context.GetCancellationToken();
await onCreateRequest(context, builder, requestAborted)
.ConfigureAwait(false);
}
return builder.Create();
}
public async ValueTask OnRequestAsync(ISocketConnection connection, IQueryRequestBuilder requestBuilder,
CancellationToken cancellationToken)
{
requestBuilder.TrySetServices(connection.RequestServices);
requestBuilder.TryAddProperty(nameof(HttpContext), connection.HttpContext);
requestBuilder.TryAddProperty(nameof(ClaimsPrincipal), connection.HttpContext.User);
}
OnCreateQueryRequestAsync(HttpContext context)
{
#if ASPNETCLASSIC
IReadableStringCollection requestQuery = context.Request.Query;
#else
IQueryCollection requestQuery = context.Request.Query;
#endif
IQueryRequestBuilder builder =
QueryRequestBuilder.New()
.SetQuery(requestQuery[_queryIdentifier])
.SetQueryName(requestQuery[_namedQueryIdentifier])
.SetOperation(requestQuery[_operationNameIdentifier]);
string variables = requestQuery[_variablesIdentifier];
if (variables != null &&
variables.Any() &&
Utf8GraphQLRequestParser.ParseJson(variables)
is IReadOnlyDictionary <string, object> v)
{
builder.SetVariableValues(v);
}
return(Task.FromResult(builder));
}
private static void AddVariables(
IResolverContext context,
NameString schemaName,
IQueryRequestBuilder builder,
DocumentNode query,
IEnumerable <VariableValue> variableValues)
{
OperationDefinitionNode operation =
query.Definitions.OfType <OperationDefinitionNode>().First();
var usedVariables = new HashSet <string>(
operation.VariableDefinitions.Select(t =>
t.Variable.Name.Value));
foreach (VariableValue variableValue in variableValues)
{
if (usedVariables.Contains(variableValue.Name))
{
object value = variableValue.Value;
if (context.Schema.TryGetType(
variableValue.Type.NamedType().Name.Value,
out InputObjectType inputType))
{
var wrapped = WrapType(inputType, variableValue.Type);
value = ObjectVariableRewriter.RewriteVariable(
schemaName, wrapped, value);
}
builder.AddVariableValue(variableValue.Name, value);
}
}
}
ExecutedMutationWithRenamedInputField(
IQueryRequestBuilder requestBuilder)
{
IHttpClientFactory clientFactory = CreateRemoteSchemas();
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton(clientFactory);
serviceCollection.AddStitchedSchema(builder =>
builder.AddSchemaFromHttp("contract")
.AddSchemaFromHttp("customer")
.RenameField(
new FieldReference("CreateCustomerInput", "name"),
"foo")
.AddExtensionsFromString(
FileResource.Open("StitchingExtensions.graphql"))
.AddSchemaConfiguration(c =>
{
c.RegisterType <PaginationAmountType>();
c.RegisterExtendedScalarTypes();
}));
IServiceProvider services =
serviceCollection.BuildServiceProvider();
IQueryExecutor executor = services
.GetRequiredService <IQueryExecutor>();
using (IServiceScope scope = services.CreateScope())
{
requestBuilder.SetServices(scope.ServiceProvider);
return(await executor.ExecuteAsync(requestBuilder.Create()));
}
}
public Task OnCreateAsync(
HttpContext context,
IQueryRequestBuilder requestBuilder,
CancellationToken cancellationToken)
{
return(_interceptor(context, requestBuilder, cancellationToken));
}
protected async Task <IReadOnlyQueryRequest> BuildRequestAsync(
HttpContext context,
IServiceProvider services,
IQueryRequestBuilder builder)
{
if (!_interceptorInitialized)
{
_interceptor = services
.GetService <IQueryRequestInterceptor <HttpContext> >();
_interceptorInitialized = true;
}
if (_interceptor != null)
{
await _interceptor.OnCreateAsync(
context,
builder,
context.GetCancellationToken())
.ConfigureAwait(false);
}
builder.SetServices(services);
builder.TryAddProperty(nameof(HttpContext), context);
builder.TryAddProperty(nameof(ClaimsPrincipal), context.GetUser());
if (context.IsTracingEnabled())
{
builder.TryAddProperty(ContextDataKeys.EnableTracing, true);
}
return(builder.Create());
}
public override async ValueTask OnCreateAsync(HttpContext context, IRequestExecutor requestExecutor,
IQueryRequestBuilder requestBuilder, CancellationToken cancellationToken)
{
var token = context.Request.Headers[HttpHeaderContants.HeaderAuthenticationAccessToken];
if (string.IsNullOrEmpty(token))
{
return;
}
var jwtHelper = context.RequestServices.GetRequiredService <IJwtHelper>();
try
{
var claimsIdentity = await jwtHelper.ValidateTokenAsync(token);
if (claimsIdentity.IsAuthenticated)
{
context.User.AddIdentity(claimsIdentity);
}
}
catch (CaminoAuthenticationException)
{
context.Response.StatusCode = StatusCodes.Status401Unauthorized;
}
catch (Exception)
{
context.Response.StatusCode = StatusCodes.Status500InternalServerError;
}
await base.OnCreateAsync(context, requestExecutor, requestBuilder, cancellationToken);
}
protected override async Task HandleAsync(
ISocketConnection connection,
DataStartMessage message,
CancellationToken cancellationToken)
{
IQueryRequestBuilder requestBuilder =
QueryRequestBuilder.From(message.Payload)
.SetServices(connection.RequestServices);
await _socketSessionInterceptor.OnRequestAsync(
connection, requestBuilder, cancellationToken);
IExecutionResult result = await _requestExecutor.ExecuteAsync(
requestBuilder.Create(), cancellationToken);
switch (result)
{
case IResponseStream responseStream:
var subscription = new Subscription(connection, responseStream, message.Id);
connection.Subscriptions.Register(subscription);
break;
case IQueryResult queryResult:
using (queryResult)
await HandleQueryResultAsync(
connection, message, queryResult, cancellationToken);
break;
default:
throw DataStartMessageHandler_RequestTypeNotSupported();
}
}
public override ValueTask OnCreateAsync(
HttpContext context,
IRequestExecutor requestExecutor,
IQueryRequestBuilder requestBuilder,
CancellationToken cancellationToken)
{
throw new GraphQLException("MyCustomError");
}
public ValueTask OnCreateAsync(
IServiceProvider serviceProvider,
OperationRequest request,
IQueryRequestBuilder requestBuilder,
CancellationToken cancellationToken)
{
requestBuilder.AddProperty("Foo", "bar");
return(default);
protected override async Task HandleAsync(
ISocketConnection connection,
DataStartMessage message,
CancellationToken cancellationToken)
{
IQueryRequestBuilder requestBuilder =
QueryRequestBuilder.New()
.SetQuery(message.Payload.Query)
.SetQueryName(message.Payload.QueryName)
.SetOperation(message.Payload.OperationName)
.SetVariableValues(message.Payload.Variables)
.SetProperties(message.Payload.Extensions)
.SetServices(connection.RequestServices);
if (_requestInterceptors != null)
{
for (var i = 0; i < _requestInterceptors.Length; i++)
{
await _requestInterceptors[i].OnCreateAsync(
connection,
requestBuilder,
cancellationToken)
.ConfigureAwait(false);
}
}
IExecutionResult result =
await _queryExecutor.ExecuteAsync(
requestBuilder.Create(),
cancellationToken)
.ConfigureAwait(false);
switch (result)
{
case IResponseStream responseStream:
connection.Subscriptions.Register(
new Subscription(
connection,
responseStream,
message.Id));
break;
case IReadOnlyQueryResult queryResult:
using (queryResult)
{
await HandleQueryResultAsync(
connection,
message,
queryResult,
cancellationToken)
.ConfigureAwait(false);
}
break;
default:
throw new NotSupportedException();
}
}
public override async ValueTask OnCreateAsync(
HttpContext context,
IRequestExecutor requestExecutor,
IQueryRequestBuilder requestBuilder,
CancellationToken cancellationToken)
{
await _interceptor(context, requestExecutor, requestBuilder, cancellationToken);
await base.OnCreateAsync(context, requestExecutor, requestBuilder, cancellationToken);
}
/// <summary>
/// Sets the error message for when the introspection is not allowed.
/// </summary>
public static IQueryRequestBuilder SetIntrospectionNotAllowedMessage(
this IQueryRequestBuilder builder,
Func <string> messageFactory)
{
if (messageFactory is null)
{
throw new ArgumentNullException(nameof(messageFactory));
}
return(builder.SetProperty(WellKnownContextData.IntrospectionMessage, messageFactory));
}
public async Task PrepareRequestAsync(
IQueryRequestBuilder requestBuilder)
{
requestBuilder.SetProperties(
new Dictionary <string, object>(RequestProperties));
if (_onCreateRequest != null)
{
await _onCreateRequest(
HttpContext, requestBuilder,
HttpContext.RequestAborted)
.ConfigureAwait(false);
}
}
public async ValueTask <IQueryResult> InvokeAsync(IResolverContext context)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
IQueryRequestBuilder builder = New().SetQuery(_query);
_setVariables(context, builder);
return(await _dataLoader
.LoadAsync(builder.Create(), context.RequestAborted)
.ConfigureAwait(false));
}
public static async Task <IExecutionResult> ExecuteQuery(
IServiceProvider services, string token = null)
{
IQueryRequestBuilder requestBuilder =
QueryRequestBuilder.New()
.SetQuery("{ foo }");
if (token != null)
{
HttpContext httpContext = services.GetRequiredService <HttpContext>();
httpContext.Request.Headers.Add(BewitTokenHeader.Value, token);
}
return(await services.ExecuteRequestAsync(requestBuilder.Create()));
}
private static IReadOnlyQueryRequest CreateRequest(
TestConfiguration?configuration, string query)
{
configuration ??= new TestConfiguration();
configuration.Service ??= new ServiceCollection()
.AddStarWarsRepositories()
.AddInMemorySubscriptionProvider()
.BuildServiceProvider();
IQueryRequestBuilder builder =
QueryRequestBuilder.New()
.SetQuery(query)
.SetServices(configuration.Service);
if (configuration.ModifyRequest is { })
public Task OnCreateAsync(
ISocketConnection context,
IQueryRequestBuilder requestBuilder,
CancellationToken cancellationToken)
{
if (_interceptor != null &&
context is WebSocketConnection connection)
{
return(_interceptor.OnCreateAsync(
connection.HttpContext,
requestBuilder,
cancellationToken));
}
return(Task.CompletedTask);
}
public virtual ValueTask OnCreateAsync(
HttpContext context,
IRequestExecutor requestExecutor,
IQueryRequestBuilder requestBuilder,
CancellationToken cancellationToken)
{
requestBuilder.TrySetServices(context.RequestServices);
requestBuilder.TryAddProperty(nameof(HttpContext), context);
requestBuilder.TryAddProperty(nameof(ClaimsPrincipal), context.User);
requestBuilder.TryAddProperty(nameof(CancellationToken), context.RequestAborted);
if (context.IsTracingEnabled())
{
requestBuilder.TryAddProperty(WellKnownContextData.EnableTracing, true);
}
return(default);
public virtual ValueTask OnRequestAsync(
ISocketConnection connection,
IQueryRequestBuilder requestBuilder,
CancellationToken cancellationToken)
{
HttpContext context = connection.HttpContext;
requestBuilder.TrySetServices(connection.RequestServices);
requestBuilder.TryAddProperty(nameof(CancellationToken), connection.RequestAborted);
requestBuilder.TryAddProperty(nameof(HttpContext), context);
requestBuilder.TryAddProperty(nameof(ClaimsPrincipal), context.User);
if (connection.HttpContext.IsTracingEnabled())
{
requestBuilder.TryAddProperty(ContextDataKeys.EnableTracing, true);
}
return(default);
private static void AddVariables(
IQueryRequestBuilder builder,
DocumentNode query,
IEnumerable <Delegation.VariableValue> variableValues)
{
OperationDefinitionNode operation =
query.Definitions.OfType <OperationDefinitionNode>().First();
var usedVariables = new HashSet <string>(
operation.VariableDefinitions.Select(t =>
t.Variable.Name.Value));
foreach (Delegation.VariableValue variableValue in variableValues)
{
if (usedVariables.Contains(variableValue.Name))
{
builder.AddVariableValue(variableValue.Name, variableValue.Value);
}
}
}
public async Task HandleAsync(
IWebSocketContext context,
GenericOperationMessage message,
CancellationToken cancellationToken)
{
QueryRequestDto payload = message.Payload.ToObject <QueryRequestDto>();
IQueryRequestBuilder requestBuilder =
QueryRequestBuilder.New()
.SetQuery(payload.Query)
.SetOperation(payload.OperationName)
.SetVariableValues(QueryMiddlewareUtilities
.ToDictionary(payload.Variables))
.SetServices(context.HttpContext.CreateRequestServices());
await context.PrepareRequestAsync(requestBuilder)
.ConfigureAwait(false);
IExecutionResult result =
await context.QueryExecutor.ExecuteAsync(
requestBuilder.Create(), cancellationToken)
.ConfigureAwait(false);
if (result is IResponseStream responseStream)
{
context.RegisterSubscription(
new Subscription(context, responseStream, message.Id));
}
else if (result is IReadOnlyQueryResult queryResult)
{
await context.SendSubscriptionDataMessageAsync(
message.Id, queryResult, cancellationToken)
.ConfigureAwait(false);
await context.SendSubscriptionCompleteMessageAsync(
message.Id, cancellationToken)
.ConfigureAwait(false);
}
}
private async Task <IReadOnlyList <IReadOnlyQueryRequest> > BuildBatchRequestAsync(
HttpContext context,
IServiceProvider services,
GraphQLRequest request,
IReadOnlyList <string> operationNames)
{
var queryBatch = new IReadOnlyQueryRequest[operationNames.Count];
for (var i = 0; i < operationNames.Count; i++)
{
IQueryRequestBuilder requestBuilder =
QueryRequestBuilder.From(request)
.SetOperation(operationNames[i]);
queryBatch[i] = await BuildRequestAsync(
context,
services,
requestBuilder)
.ConfigureAwait(false);
}
return(queryBatch);
}
protected override async Task HandleAsync(
ISocketConnection connection,
DataStartMessage message,
CancellationToken cancellationToken)
{
IQueryRequestBuilder requestBuilder =
QueryRequestBuilder.New()
.SetQuery(message.Payload.Query)
.SetQueryId(message.Payload.QueryId)
.SetOperation(message.Payload.OperationName)
.SetVariableValues(message.Payload.Variables)
.SetProperties(message.Payload.Extensions)
.SetServices(connection.RequestServices);
await _socketSessionInterceptor.OnRequestAsync(
connection, requestBuilder, cancellationToken);
IExecutionResult result = await _requestExecutor.ExecuteAsync(
requestBuilder.Create(), cancellationToken);
switch (result)
{
case IResponseStream responseStream:
var subscription = new Subscription(connection, responseStream, message.Id);
connection.Subscriptions.Register(subscription);
break;
case IQueryResult queryResult:
using (queryResult)
await HandleQueryResultAsync(
connection, message, queryResult, cancellationToken);
break;
default:
throw new NotSupportedException("The response type is not supported.");
}
}
public Task PrepareRequestAsync(IQueryRequestBuilder requestBuilder)
{
requestBuilder.SetProperties(
new Dictionary <string, object>(RequestProperties));
return(Task.CompletedTask);
}
/// <summary>
/// Set allowed complexity for this request and override the global allowed complexity.
/// </summary>
public static IQueryRequestBuilder SetMaximumAllowedComplexity(
this IQueryRequestBuilder builder,
int maximumAllowedComplexity) =>
builder.SetProperty(
WellKnownContextData.MaximumAllowedComplexity,
maximumAllowedComplexity);
/// <summary>
/// Skips the operation complexity analysis of this request.
/// </summary>
public static IQueryRequestBuilder SkipComplexityAnalysis(
this IQueryRequestBuilder builder) =>
builder.SetProperty(WellKnownContextData.SkipComplexityAnalysis, null);
/// <summary>
/// Allows introspection usage in the current request.
/// </summary>
public static IQueryRequestBuilder AllowIntrospection(
this IQueryRequestBuilder builder) =>
builder.SetProperty(WellKnownContextData.IntrospectionAllowed, null);
protected override async Task HandleAsync(
ISocketConnection connection,
DataStartMessage message,
CancellationToken cancellationToken)
{
var session = new CancellationTokenSource();
var combined = CancellationTokenSource.CreateLinkedTokenSource(
session.Token, cancellationToken);
var sessionIsHandled = false;
IExecutionResult result = await ExecuteAsync(combined.Token);
try
{
switch (result)
{
case SubscriptionResult subscriptionResult:
// first we add the cts to the result so that they are disposed when the
// subscription is disposed.
subscriptionResult.RegisterDisposable(combined);
// while a subscription result must be disposed we are not handling it here
// and leave this responsibility to the subscription session.
ISubscription subscription = GetSubscription(result);
var subscriptionSession = new SubscriptionSession(
session,
_socketSessionInterceptor,
connection,
subscriptionResult,
subscription,
_diagnosticEvents,
message.Id);
connection.Subscriptions.Register(subscriptionSession);
sessionIsHandled = true;
break;
case IResponseStream streamResult:
// stream results represent deferred execution streams that use execution
// resources. We need to ensure that these are disposed when we are
// finished.
await using (streamResult)
{
await HandleStreamResultAsync(
connection,
message,
streamResult,
cancellationToken);
}
break;
case IQueryResult queryResult:
// query results use pooled memory an need to be disposed after we have
// used them.
using (queryResult)
{
await HandleQueryResultAsync(
connection,
message,
queryResult,
cancellationToken);
}
break;
default:
throw DataStartMessageHandler_RequestTypeNotSupported();
}
}
finally
{
if (!sessionIsHandled)
{
session.Dispose();
combined.Dispose();
}
}
async ValueTask <IExecutionResult> ExecuteAsync(CancellationToken cancellationToken)
{
try
{
IQueryRequestBuilder requestBuilder =
QueryRequestBuilder.From(message.Payload)
.SetServices(connection.RequestServices);
await _socketSessionInterceptor.OnRequestAsync(
connection, requestBuilder, cancellationToken);
return(await _requestExecutor.ExecuteAsync(
requestBuilder.Create(), cancellationToken));
}
catch (Exception ex)
{
IErrorBuilder error = _errorHandler.CreateUnexpectedError(ex);
return(QueryResultBuilder.CreateError(error.Build()));
}
}
}
