public static Task SerializeAsync(
this IQueryResultSerializer serializer,
IExecutionResult result,
Stream outputStream,
CancellationToken cancellationToken)
{
if (result is IReadOnlyQueryResult queryResult)
{
return(serializer.SerializeAsync(
queryResult,
outputStream,
cancellationToken));
}
else
{
return(serializer.SerializeAsync(
QueryResult.CreateError(
ErrorBuilder.New()
.SetMessage("Result type not supported.")
.SetCode("RESULT_TYPE_NOT_SUPPORTED")
.Build()),
outputStream,
cancellationToken));
}
}
public static Task SerializeAsync(
this IQueryResultSerializer serializer,
IExecutionResult result,
Stream outputStream,
CancellationToken cancellationToken)
{
if (result is IReadOnlyQueryResult queryResult)
{
return(serializer.SerializeAsync(
queryResult,
outputStream,
cancellationToken));
}
else
{
// TODO : resources
return(serializer.SerializeAsync(
QueryResult.CreateError(
ErrorBuilder.New()
.SetMessage("Result type not supported.")
.SetCode(ErrorCodes.Serialization.ResultTypeNotSupported)
.Build()),
outputStream,
cancellationToken));
}
}
protected override async Task ExecuteRequestAsync(
HttpContext context,
IServiceProvider services)
{
IReadOnlyList <GraphQLRequest> batch =
await ReadRequestAsync(context)
.ConfigureAwait(false);
if (batch.Count == 1)
{
string operations = context.Request.Query[_batchOperations];
if (operations == null)
{
await ExecuteQueryAsync(context, services, batch[0])
.ConfigureAwait(false);
}
else if (TryParseOperations(operations,
out IReadOnlyList <string> operationNames))
{
await ExecuteOperationBatchAsync(
context, services, batch[0], operationNames)
.ConfigureAwait(false);
}
else
{
// TODO : resources
var result = QueryResult.CreateError(
ErrorBuilder.New()
.SetMessage("Invalid GraphQL Request.")
.SetCode(ErrorCodes.Server.RequestInvalid)
.Build());
SetResponseHeaders(
context.Response,
_resultSerializer.ContentType);
await _resultSerializer.SerializeAsync(
result, context.Response.Body)
.ConfigureAwait(false);
}
}
else
{
await ExecuteQueryBatchAsync(context, services, batch)
.ConfigureAwait(false);
}
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task InvokeAsync(HttpContext context)
#endif
{
if (_isPathValid(context) && CanHandleRequest(context))
{
try
{
await HandleRequestAsync(context)
.ConfigureAwait(false);
}
catch (NotSupportedException)
{
context.Response.StatusCode = _badRequest;
}
catch (SyntaxException ex)
{
IError error = ErrorBuilder.New()
.SetMessage(ex.Message)
.AddLocation(ex.Line, ex.Column)
.Build();
var errorResult = QueryResult.CreateError(error);
SetResponseHeaders(context.Response, _serializer.ContentType);
await _serializer.SerializeAsync(errorResult, context.Response.Body)
.ConfigureAwait(false);
}
}
else if (Next != null)
{
await Next.Invoke(context).ConfigureAwait(false);
}
}
protected override async Task ExecuteRequestAsync(
HttpContext context,
IServiceProvider services)
{
var builder = QueryRequestBuilder.New();
#if ASPNETCLASSIC
IReadableStringCollection requestQuery = context.Request.Query;
#else
IQueryCollection requestQuery = context.Request.Query;
#endif
builder
.SetQuery(requestQuery[_queryIdentifier])
.SetQueryName(requestQuery[_namedQueryIdentifier])
.SetOperation(requestQuery[_operationNameIdentifier]);
string variables = requestQuery[_variablesIdentifier];
if (variables != null &&
variables.Length > 0 &&
Utf8GraphQLRequestParser.ParseJson(variables)
is IReadOnlyDictionary <string, object> v)
{
builder.SetVariableValues(v);
}
IReadOnlyQueryRequest request =
await BuildRequestAsync(
context,
services,
builder)
.ConfigureAwait(false);
var schemaName = await _schemaNameProvider(context).ConfigureAwait(false);
var _queryExecutor = _queryExecutorProvider.GetQueryExecutor(schemaName);
IExecutionResult result = await _queryExecutor
.ExecuteAsync(request, context.GetCancellationToken())
.ConfigureAwait(false);
SetResponseHeaders(
context.Response,
_resultSerializer.ContentType);
await _resultSerializer.SerializeAsync(
result,
context.Response.Body,
context.GetCancellationToken())
.ConfigureAwait(false);
}
private async Task WriteResponseAsync(
HttpResponse response,
IExecutionResult executionResult)
{
if (executionResult is IReadOnlyQueryResult queryResult)
{
response.ContentType = ContentType.Json;
response.StatusCode = _ok;
await _resultSerializer.SerializeAsync(
queryResult, response.Body)
.ConfigureAwait(false);
}
}
public void GivenNullStreamWhenSerializeAsyncCalledThenShouldThrowArgumentNull()
{
Assert.ThrowsAsync <ArgumentNullException>(
async() => await target.SerializeAsync(null, getOne()));
}
