GraphQL.GraphQLResponse.Data Does Not Get Populated

[alex-leroux]

Hi,

I have implemented a GraphQL server using the GraphQL 2.4 (https://github.com/graphql-dotnet/graphql-dotnet) package, as per this sample: https://www.red-gate.com/simple-talk/dotnet/net-development/building-and-consuming-graphql-api-in-asp-net-core-3-1/

I returns results like this:

Now I am trying use GraphQL.Client 3.1.4 to execute queries against this server, as per the sample provided at https://github.com/graphql-dotnet/graphql-client. However, I find that the GraphQLResponse.Data is never populated. My response type is defined like this for example query above:

public class AuthorResponse
{
	public Author author { get; set; }
}
public class Author
{
	public int id { get; set; }
	public string firstName { get; set; }
	public string lastName { get; set; }
}

Looking at the source code, it appears that the provided serializer, GraphQL.Client.Serializer.Newtonsoft.NewtonsoftJsonSerializer, cannot populate it, unless the response were somehow wrapped in a GraphQLResponse shaped wrapper.

What am I doing wrong?
How is this supposed to work?

[alex-leroux]

If I define and use a custom serializer, as below, it works. But it is unclear to me how Errors and Extensions will then work.

public class GraphQLJsonSerializer : IGraphQLWebsocketJsonSerializer
{
	private JsonSerializerSettings jsonSerializerSettings;

	public GraphQLJsonSerializer() : this(GetDefaultJsonSerializerSettings()) {}

	public GraphQLJsonSerializer(JsonSerializerSettings jsonSerializerSettings)
	{
		this.jsonSerializerSettings = jsonSerializerSettings;
		ConfigureMandatorySerializerOptions();
	}

	public string SerializeToString(GraphQLRequest request)
	{
		return JsonConvert.SerializeObject(request, this.jsonSerializerSettings);
	}

	public byte[] SerializeToBytes(GraphQLWebSocketRequest request)
	{
		string json = JsonConvert.SerializeObject(request, this.jsonSerializerSettings);
		return Encoding.UTF8.GetBytes(json);
	}

	public Task<WebsocketMessageWrapper> DeserializeToWebsocketResponseWrapperAsync(Stream stream)
	{
		WebsocketMessageWrapper data = DeserializeFromUtf8Stream<WebsocketMessageWrapper>(stream);
		return Task.FromResult(data);
	}

	public GraphQLWebSocketResponse<GraphQLResponse<ResponseType>> DeserializeToWebsocketResponse<ResponseType>(byte[] bytes)
	{
		return JsonConvert.DeserializeObject<GraphQLWebSocketResponse<GraphQLResponse<ResponseType>>>(Encoding.UTF8.GetString(bytes),
			this.jsonSerializerSettings);
	}

	public Task<GraphQLResponse<ResponseType>> DeserializeFromUtf8StreamAsync<ResponseType>(Stream stream, CancellationToken cancellationToken)
	{
		ResponseType data = DeserializeFromUtf8Stream<ResponseType>(stream);
		GraphQLResponse<ResponseType> graphQLResponse = new GraphQLResponse<ResponseType>() { Data = data };
		return Task.FromResult(graphQLResponse);
	}

	private static JsonSerializerSettings GetDefaultJsonSerializerSettings()
	{
		return new JsonSerializerSettings
		{
			ContractResolver = new CamelCasePropertyNamesContractResolver { IgnoreIsSpecifiedMembers = true },
			MissingMemberHandling = MissingMemberHandling.Ignore
		};
	}

	private void ConfigureMandatorySerializerOptions()
	{
		this.jsonSerializerSettings.Converters.Insert(0, new MapConverter());
	}

	private ResponseType DeserializeFromUtf8Stream<ResponseType>(Stream stream)
	{
		using (StreamReader streamReader = new StreamReader(stream))
		using (JsonReader jsonReader = new JsonTextReader(streamReader))
		{
			JsonSerializer serializer = JsonSerializer.Create(this.jsonSerializerSettings);
			return serializer.Deserialize<ResponseType>(jsonReader);
		}
	}
}

[rose-a]

Would you show us some of your code (using the original NewtonsoftJsonSerializer)?

[alex-leroux]

I am querying like this:

    private const string graphQLServerURL = "https://localhost:44388/blog";

    [Test]
    public void TestExecuteGetAuthorByID()
    {
        string query =

@"query
{
author (id: 1)
{
id
firstName
lastName
}
}";

        AuthorResponse authorResponse = ExecuteQuery<AuthorResponse>(graphQLServerURL, query);
        Author author = authorResponse.Author;
        Assert.AreEqual(1, author.Id, "The result is unexpected.");
        Assert.AreEqual("Joydip", author.FirstName, "The result is unexpected.");
        Assert.AreEqual("Kanjilal", author.LastName, "The result is unexpected.");
    }

    private static ResponseType ExecuteQuery<ResponseType>(string graphQLServerURL, string query)
{
        NewtonsoftJsonSerializer querySerializer = new NewtonsoftJsonSerializer();
        GraphQLHttpClient graphQLClient = new GraphQLHttpClient(graphQLServerURL, querySerializer);
        GraphQLRequest graphQLRequest = new GraphQLRequest(query);
        Task<GraphQLResponse<ResponseType>> graphQLResponseTask = graphQLClient.SendQueryAsync<ResponseType>(graphQLRequest);
        graphQLResponseTask.Wait();

        GraphQLResponse<ResponseType> graphQLResponse = graphQLResponseTask.Result;
    return graphQLResponse.Data;
    }

[alex-leroux]

I have figured this out. My server was returning ExecutionResult.Data (as per the sample) instead of ExecutionResult.