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));
}
protected override async Task ExecuteRequestAsync(HttpHelper httpHelper)
{
var builder = QueryRequestBuilder.New();
IQueryCollection requestQuery = httpHelper.Context.Request.Query;
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(
httpHelper.Context,
httpHelper.Services,
builder)
.ConfigureAwait(false);
httpHelper.StatusCode = OK;
httpHelper.Result = await _queryExecutor
.ExecuteAsync(request, httpHelper.Context.RequestAborted)
.ConfigureAwait(false);
}
public async Task DeserializeQueryResultWithErrors()
{
// arrange
var qux = new OrderedDictionary {
{ "quux", 123 }
};
var baz = new OrderedDictionary {
{ "qux", qux }
};
var objectList = new List <object> {
baz
};
var scalarList = new List <object> {
123
};
var result = QueryResultBuilder.New();
var data = new OrderedDictionary();
data["foo"] = objectList;
data["bar"] = scalarList;
data["baz"] = baz;
result.SetData(data);
result.AddError(ErrorBuilder.New()
.SetMessage("foo")
.SetPath(Path.New("root").Append("child"))
.AddLocation(new Location(15, 16))
.SetExtension("bar", "baz")
.Build());
result.AddError(ErrorBuilder.New()
.SetMessage("qux")
.SetExtension("bar", "baz")
.Build());
result.AddError(ErrorBuilder.New()
.SetMessage("quux")
.Build());
var stream = new MemoryStream();
var serializer = new JsonQueryResultSerializer();
await serializer.SerializeAsync(result.Create(), stream);
byte[] buffer = stream.ToArray();
var serializedResult = Utf8GraphQLRequestParser.ParseJson(buffer);
// act
IReadOnlyQueryResult deserializedResult =
HttpResponseDeserializer.Deserialize(
(IReadOnlyDictionary <string, object>)serializedResult);
// assert
Snapshot.Match(deserializedResult);
}
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);
}
public async Task DeserializeQueryResultWithExtensions()
{
// arrange
var qux = new OrderedDictionary {
{ "quux", 123 }
};
var baz = new OrderedDictionary {
{ "qux", qux }
};
var objectList = new List <object> {
baz
};
var scalarList = new List <object> {
123
};
var result = QueryResultBuilder.New();
var data = new OrderedDictionary();
data["foo"] = objectList;
data["bar"] = scalarList;
data["baz"] = baz;
result.SetData(data);
var extensionData = new ExtensionData();
extensionData["foo"] = objectList;
extensionData["bar"] = scalarList;
extensionData["baz"] = baz;
result.SetExtensions(extensionData);
var stream = new MemoryStream();
var serializer = new JsonQueryResultSerializer();
await serializer.SerializeAsync(result.Create(), stream);
byte[] buffer = stream.ToArray();
var serializedResult = Utf8GraphQLRequestParser.ParseJson(buffer);
// act
IReadOnlyQueryResult deserializedResult =
HttpResponseDeserializer.Deserialize(
(IReadOnlyDictionary <string, object>)serializedResult);
// assert
deserializedResult.MatchSnapshot(m => m.Ignore(c => c.Field <JObject>("Extensions")));
deserializedResult.Extensions.OrderBy(t => t.Key)
.MatchSnapshot(new SnapshotNameExtension("extensions"));
}
private IReadOnlyList <GraphQLRequest> ParseRequest(
byte[] buffer, int bytesBuffered)
{
var graphQLData = new ReadOnlySpan <byte>(buffer);
graphQLData = graphQLData.Slice(0, bytesBuffered);
var requestParser = new Utf8GraphQLRequestParser(
graphQLData,
_parserOptions,
_documentCache,
_documentHashProvider);
return(requestParser.Parse());
}
private static InitializeConnectionMessage DeserializeInitConnMessage(
GraphQLSocketMessage parsedMessage)
{
if (parsedMessage.HasPayload)
{
object parsed = Utf8GraphQLRequestParser.ParseJson(
parsedMessage.Payload);
if (parsed is IReadOnlyDictionary <string, object> payload)
{
return(new InitializeConnectionMessage(payload));
}
}
return(new InitializeConnectionMessage(null));
}
private static bool TryDeserializeDataStartMessage(
GraphQLSocketMessage parsedMessage,
out OperationMessage message)
{
if (!parsedMessage.HasPayload)
{
message = null;
return(false);
}
IReadOnlyList <GraphQLRequest> batch =
Utf8GraphQLRequestParser.Parse(parsedMessage.Payload);
message = new DataStartMessage(parsedMessage.Id, batch[0]);
return(true);
}
private static bool TryDeserializeDataStartMessage(
GraphQLSocketMessage parsedMessage,
[NotNullWhen(true)] out OperationMessage?message)
{
if (parsedMessage.Payload.Length == 0 || parsedMessage.Id is null)
{
message = null;
return(false);
}
IReadOnlyList <GraphQLRequest> batch =
Utf8GraphQLRequestParser.Parse(parsedMessage.Payload);
message = new DataStartMessage(parsedMessage.Id, batch[0]);
return(true);
}
ReceiveServerMessageAsync(
this WebSocket webSocket)
{
await using var stream = new MemoryStream();
WebSocketReceiveResult result;
var buffer = new byte[_maxMessageSize];
do
{
result = await webSocket.ReceiveAsync(
new ArraySegment <byte>(buffer),
CancellationToken.None);
stream.Write(buffer, 0, result.Count);
}while (!result.EndOfMessage);
return((IReadOnlyDictionary <string, object>)
Utf8GraphQLRequestParser.ParseJson(stream.ToArray()));
}
public async Task DeserializeQueryResultWithExtensions()
{
// arrange
var qux = new OrderedDictionary {
{ "quux", 123 }
};
var baz = new OrderedDictionary {
{ "qux", qux }
};
var objectList = new List <object> {
baz
};
var scalarList = new List <object> {
123
};
var result = new QueryResult();
result.Data["foo"] = objectList;
result.Data["bar"] = scalarList;
result.Data["baz"] = baz;
result.Extensions["foo"] = objectList;
result.Extensions["bar"] = scalarList;
result.Extensions["baz"] = baz;
var stream = new MemoryStream();
var serializer = new JsonQueryResultSerializer();
await serializer.SerializeAsync(result, stream);
byte[] buffer = stream.ToArray();
var serializedResult = Utf8GraphQLRequestParser.ParseJson(buffer);
// act
IReadOnlyQueryResult deserializedResult =
HttpResponseDeserializer.Deserialize(
(IReadOnlyDictionary <string, object>)serializedResult);
// assert
Snapshot.Match(deserializedResult);
}
public async Task DeserializeQueryResult(object value, string type)
{
// arrange
var qux = new OrderedDictionary {
{ "quux", value }
};
var baz = new OrderedDictionary {
{ "qux", qux }
};
var objectList = new List <object> {
baz
};
var scalarList = new List <object> {
value
};
var result = QueryResultBuilder.New();
var data = new OrderedDictionary();
data["foo"] = objectList;
data["bar"] = scalarList;
data["baz"] = baz;
result.SetData(data);
var stream = new MemoryStream();
var serializer = new JsonQueryResultSerializer();
await serializer.SerializeAsync(result.Create(), stream);
byte[] buffer = stream.ToArray();
var serializedResult = Utf8GraphQLRequestParser.ParseJson(buffer);
// act
IReadOnlyQueryResult deserializedResult =
HttpResponseDeserializer.Deserialize(
(IReadOnlyDictionary <string, object>)serializedResult);
// assert
Snapshot.Match(deserializedResult,
"DeserializeQueryResult_" + type);
}
public async Task HttpPost_Operation_Batch_Invalid_Argument(string path)
{
// arrange
TestServer server = CreateStarWarsServer();
var batch = new List <ClientQueryRequest>
{
new ClientQueryRequest
{
Query =
@"
query getHero {
hero(episode: EMPIRE) {
id @export
}
}
query getHuman {
human(id: $id) {
name
}
}"
}
};
// act
HttpResponseMessage message =
await server.SendPostRequestAsync(
batch,
path);
// assert
Assert.Equal(HttpStatusCode.OK, message.StatusCode);
byte[] json = await message.Content.ReadAsByteArrayAsync();
Utf8GraphQLRequestParser.ParseJson(json).MatchSnapshot();
}
private static object ParseJson(byte[] buffer, int bytesBuffered)
{
return(Utf8GraphQLRequestParser.ParseJson(
new ReadOnlySpan <byte>(buffer, 0, bytesBuffered)));
}
private static bool TryParseMessage(
ReadOnlySequence <byte> slice,
out OperationMessage message)
{
ReadOnlySpan <byte> messageData;
byte[] buffer = null;
if (slice.IsSingleSegment)
{
messageData = slice.First.Span;
}
else
{
buffer = ArrayPool <byte> .Shared.Rent(1024 * 4);
int buffered = 0;
SequencePosition position = slice.Start;
ReadOnlyMemory <byte> memory;
while (slice.TryGet(ref position, out memory, true))
{
ReadOnlySpan <byte> span = memory.Span;
var bytesRemaining = buffer.Length - buffered;
if (span.Length > bytesRemaining)
{
var next = ArrayPool <byte> .Shared.Rent(
buffer.Length * 2);
Buffer.BlockCopy(buffer, 0, next, 0, buffer.Length);
ArrayPool <byte> .Shared.Return(buffer);
buffer = next;
}
for (int i = 0; i < span.Length; i++)
{
buffer[buffered++] = span[i];
}
}
messageData = buffer;
messageData = messageData.Slice(0, buffered);
}
try
{
if (messageData.Length == 0 ||
(messageData.Length == 1 && messageData[0] == default))
{
message = null;
return(false);
}
GraphQLSocketMessage parsedMessage =
Utf8GraphQLRequestParser.ParseMessage(messageData);
return(TryDeserializeMessage(parsedMessage, out message));
}
catch (SyntaxException)
{
message = null;
return(false);
}
finally
{
if (buffer != null)
{
ArrayPool <byte> .Shared.Return(buffer);
}
}
}
