System.Text.Json source generator configuration for AOT

[szymonkolasa]

Hi,

in the README file I've found that GraphQL Server supports native AOT, so I've created a simple project to test it. When I tried to run it, I've got a lot of errors related to missing types.

Based on the errors I had to add below types to AppJsonSerializerContext:

[JsonSerializable(typeof(ExecutionResult))]
[JsonSerializable(typeof(IDictionary<string, object>))]
[JsonSerializable(typeof(List<string>))]
[JsonSerializable(typeof(IList<GraphQLRequest>))]
[JsonSerializable(typeof(IEnumerable))]
[JsonSerializable(typeof(OperationMessage))]
[JsonSerializable(typeof(JsonElement?))]
internal partial class AppJsonSerializerContext : JsonSerializerContext;

Is there some documented list of types or solution which provides all required types for System.Text.Json source generator to ensure the GraphQL Server works as expected? Thank you in advance for the answer. Below you can find full solution.

using System.Collections;
using System.Text.Json;
using System.Text.Json.Serialization;
using GraphQL;
using GraphQL.Transport;
using GraphQL.Types;

var builder = WebApplication.CreateSlimBuilder(args);

var services = builder.Services;

services.AddGraphQL(configure =>
{
    configure.AddSchema<MySchema>();
    configure.AddSystemTextJson(options => options.TypeInfoResolverChain.Insert(0, AppJsonSerializerContext.Default));
});

var app = builder.Build();

app.UseWebSockets();
app.UseGraphQL();

app.Run();

[JsonSerializable(typeof(ExecutionResult))]
[JsonSerializable(typeof(IDictionary<string, object>))]
[JsonSerializable(typeof(List<string>))]
[JsonSerializable(typeof(IList<GraphQLRequest>))]
[JsonSerializable(typeof(IEnumerable))]
[JsonSerializable(typeof(OperationMessage))]
[JsonSerializable(typeof(JsonElement?))]
internal partial class AppJsonSerializerContext : JsonSerializerContext;

public class Query : ObjectGraphType
{
    public Query()
    {
        Field<string>("hello")
            .Resolve(_ => "Hello, world!");
    }
}

public class MySchema : Schema
{
    public MySchema(IServiceProvider serviceProvider) : base(serviceProvider)
    {
        Query = new Query();
    }
}

[Shane32]

While GraphQL.NET Server “supports” AOT — meaning it doesn’t produce any AOT warnings during compilation — GraphQL.NET itself (which includes the serializer) is far from fully supporting AOT as you’ve seen. There is two samples application within the GraphQL.NET repository which uses AOT, but they do not use ASP.Net or GraphQL.NET Server. I can review your question further and probably add a sample project.

[Shane32]

As for the source generator, GraphQL.NET includes JsonConverters which will be used for deserializing variables or serializing results. You will need to enable reflection-based serialization in order for the project to compile, but there will be no reflection-based serialization actually occurring. Perhaps in the future we can update the GraphQL.NET serializers to eliminate this problem/warning.

Also, GraphQL.NET was missing a number of attributes which were preventing proper trim analysis of the project. This has been updated in GraphQL.NET 8.3.0. I suggest you update to GraphQL.NET 8.3.0 to solve many of these trimming errors.

Finally, I've added a sample project within PR #1180 demonstrating how to write a functional Native AOT ASP.NET Core application with GraphQL.NET. I've added CI tests to ensure that it functions properly when compiled as a Native AOT application. Notice the csproj which enables reflection-based serialization, suppressing the serialization warning.

As you further develop your GraphQL.NET schema, you will find:

• The built-in connection types do not work properly
• You may (or may not) need to manually register various graph types in your DI -- and .AddGraphTypes() does not work
• You will have the best success with the code-first pattern, explicitly specifying the graph type and resolver for each field, which will also perform the best.
• You should have limited success with patterns that infer the graph type, such as Field(x => x.Name). Since runtime compilation is not available, it will run slower than specifying the graph type and resolver explicitly.
• Be sure not to use the Field overload that does not specify a resolver or expression - e.g. Field<StringGraphType>("name")
• You may need to explicitly implement the ParseDictionary method for input object graph types.
• You should have limited success using the auto-registering graph types (but not enabling automatic auto-registering types)

In short, the auto-registering types and type inferring capability will probably work for 'simple' types, but not complex or custom types. Hopefully the trim warnings will assist while you develop your schema. Please also note that AOT support is still a 'beta' feature.

If you run into any issues where GraphQL.NET reports a missing constructor for an essential built-in type, please report it as an issue in the GraphQL.NET repo.

[szymonkolasa]

Thank you for the answer! I will take a look on the sample project and try to create more advanced scenarios. In case of any issues I will report an issue.