Code first schema configuration with AddGraphQL()

[sri-s-creator]

I am trying to configure my GraphQL server with code first schema and minimal API.

I have followed the sample and this is what my API looks like currently:

app.MapPost("/graphql", () => { SchemaBuilder schemaBuilder = new(); GraphQL.Types.Schema schema = schemaBuilder.Build(_schema); return await _executer.ExecuteAsync(_ => { _.Schema = schema; _.Query = "{ hello }"; });

I am trying to change this to use the built in GraphQLHttpMiddleware. I followed the docs and this is what my new API looks like:

app.MapPost("/graphql", () => new GraphQLExecutionActionResult(opts => { opts.ValidationErrorsReturnBadRequest = true; });

The docs specify that this doesn't require UseGraphQL() or MapGraphQL() in the application startup. However. the sample uses builder.Services.AddGraphQL(). How do I invoke AddGraphQL() for the code first approach? I tried to do this:

builder.Services.AddGraphQL(b => b.AddSchema<ISchema>().AddSystemTextJson());

which results in a compilation error System.ArgumentException: Cannot instantiate implementation type 'GraphQL.Types.ISchema' for service type 'GraphQL.Types.ISchema'. Is it possible to get the behavior I am expecting by invoking AddGraphQL() without AddSchema()?

Any direction you could provide would be helpful, thanks.

[SebastianStehle]

I think you have to register a Dummy schema here and then you can later replace it with the actual schema. I have something similar to support dynamic schemas

[Shane32]

Code first implies that you have a class that inherits from GraphQL.Types.Schema - for example like this:

public class StarWarsSchema : Schema
{
    public StarWarsSchema(IServiceProvider serviceProvider)
        : base(serviceProvider)
    {
        Query = serviceProvider.GetRequiredService<StarWarsQuery>();
        Mutation = serviceProvider.GetRequiredService<StarWarsMutation>();

        Description = "Example StarWars universe schema";
    }
}

To register your code-first schema, just use something like this:

builder.Services.AddGraphQL(b => b
    // add your code-first schema class
    .AddSchema<StarWarsSchema>()
    // add the serialization engine to use
    .AddSystemTextJson()
    // auto-identify and register all graph types in the specified assembly and register them in the DI provider
    .AddGraphTypes(typeof(StarWarsSchema).Assembly)
);

However, if you are attempting to use schema-first, you will have code like this:

private static ISchema BuildSchema(IServiceProvider serviceProvider)
{
    // load the schema-first SDL from an embedded resource
    var filename = "MyProject.MySchema.gql";
    var assembly = Assembly.GetExecutingAssembly();
    var stream = assembly.GetManifestResourceStream(filename)
        ?? throw new InvalidOperationException("Could not read schema definitions from embedded resource.");
    var reader = new StreamReader(stream);
    var schemaString = reader.ReadToEnd();

    // create the schema
    var schemaBuilder = new SchemaBuilder
    {
        ServiceProvider = serviceProvider,
    };
    schemaBuilder.Types.Include<Query>();
    schemaBuilder.Types.Include<Category>();
    // other configuration code for the schema goes here

    // build the schema
    return schemaBuilder.Build(schemaString);
}

To register it, use code like this:

builder.Services.AddGraphQL(b => b
    .AddSchema(provider => BuildSchema(provider))
    .AddSystemTextJson()
);

Either way, there are many other methods available for configuring GraphQL.NET within the AddGraphQL method. See this link for a complete list of methods:

• https://graphql-dotnet.github.io/docs/getting-started/dependency-injection/#dependency-injection-registration-helpers

The most common methods besides those noted above, I would say, would be:

• AddAutoClrMappings - handy for auto-mapping CLR types to graph types, especially useful for input graph types
• AddClrTypeMappings - very useful when using CLR-based field mappings - e.g. Field(x => x.Address)
• AddDataLoader - installs data loader processing
• AddExecutionStrategy - to use a serial execution strategy for queries, common when using scoped services such as EF
• AddUnhandledExceptionHandler - for logging of unhandled errors

Please note that the above instructions assume a singleton schema. If you need a scoped schema, use the overload of AddSchema which allows you to specify a scoped lifetime. More details are available here:

• https://graphql-dotnet.github.io/docs/getting-started/dependency-injection/#schema-service-lifetime

Once you have GraphQL configured within your DI provider, you can use this code to configure GraphQL at an endpoint:

app.UseGraphQL("/graphql", opts => {
    opts.ValidationErrorsReturnBadRequest = true;
});

The GraphQL.NET Server readme covers other ways to use the HTTP middleware; the code you supplied probably works just fine as well. There's also extensive documentation for authentication, authorization, CORS and other relevant information there also.

[Shane32]

Cannot instantiate implementation type 'GraphQL.Types.ISchema' for service type 'GraphQL.Types.ISchema'

This error is caused by the use of ISchema when calling .AddSchema. The latter basically just calls builder.Services.AddSingleton<ISchema>();. That's invalid because ISchema is an interface and can't be instantiated. DI is expecting a concrete class.

Is it possible to get the behavior I am expecting by invoking AddGraphQL() without AddSchema()?

The GraphQL.NET Server ASP.NET Core middleware is expecting to pull ISchema from DI (as well as some other GraphQL.NET-specific services). You can certainly call .AddGraphQL(b => b.AddSystemTextJson()); and then register ISchema yourself in the DI provider.

I have followed the sample and this is what my API looks like currently:

Based on your sample code, it would seem that you are using schema-first currently, with _schema being the SDL passed to SchemaBuilder. I suggest reviewing my schema-first sample above. You'd delete the first part which loads from an embedded resource, and use _schema in place of schemaString below.

[sri-s-creator]

Hi @Shane32, thanks for the detailed response. You are correct that I am using schema first. I mixed up the terminologies a bit.
I did exactly as you described to register the schema using this:

builder.Services.AddGraphQL(b => b .AddSchema(provider => BuildSchema(provider)) .AddSystemTextJson() );

I noticed from debugging is that ExecuteResultAsync() in GraphQLExecutionActionResult never gets invoked, and therefore the middleware doesn't get added to the pipeline. I think this is because I am using minimal API whose framework handles the execution of IResult and not IActionResult which is appropriate for controller based APIs. Perhaps I have to go with the custom middleware approach to add the middleware to the request pipeline. I am going to investigate this further on my end, thanks!

[Shane32]

If you must use MapPost, then you can use this IResult implementation:

/// <summary>
/// An <see cref="IResult"/> that executes a GraphQL request for the specified schema.
/// </summary>
public class GraphQLExecutionHttpResult<TSchema> : IResult
    where TSchema : ISchema
{
    private readonly GraphQLHttpMiddlewareOptions _options;

    /// <summary>
    /// Initializes a new instance with an optional middleware configuration delegate.
    /// </summary>
    public GraphQLExecutionHttpResult(Action<GraphQLHttpMiddlewareOptions>? configure = null)
        : this(Configure(configure))
    {
    }

    private static GraphQLHttpMiddlewareOptions Configure(Action<GraphQLHttpMiddlewareOptions>? configure)
    {
        var options = new GraphQLHttpMiddlewareOptions();
        configure?.Invoke(options);
        return options;
    }

    /// <summary>
    /// Initializes a new instance with the specified middleware options.
    /// </summary>
    public GraphQLExecutionHttpResult(GraphQLHttpMiddlewareOptions options)
    {
        _options = options;
    }

    /// <inheritdoc/>
    public virtual Task ExecuteAsync(HttpContext httpContext)
    {
        var provider = httpContext.RequestServices;
        var middleware = new GraphQLHttpMiddleware<TSchema>(
            static httpContext =>
            {
                httpContext.Response.StatusCode = (int)HttpStatusCode.NotFound;
                return Task.CompletedTask;
            },
            provider.GetRequiredService<IGraphQLTextSerializer>(),
            provider.GetRequiredService<IDocumentExecuter<TSchema>>(),
            provider.GetRequiredService<IServiceScopeFactory>(),
            _options,
            provider.GetService<IHostApplicationLifetime>() ?? NullHostApplicationLifetime.Instance);

        return middleware.InvokeAsync(httpContext);
    }

    private class NullHostApplicationLifetime : IHostApplicationLifetime
    {
        private NullHostApplicationLifetime()
        {
        }

        public static NullHostApplicationLifetime Instance { get; } = new();

        public CancellationToken ApplicationStarted => default;

        public CancellationToken ApplicationStopped => default;

        public CancellationToken ApplicationStopping => default;

        public void StopApplication() { }
    }
}

/// <summary>
/// An <see cref="IResult"/> that executes a GraphQL request for the default schema.
/// </summary>
public class GraphQLExecutionHttpResult : GraphQLExecutionHttpResult<ISchema>
{
    /// <inheritdoc cref="GraphQLExecutionHttpResult{TSchema}.GraphQLExecutionHttpResult(Action{GraphQLHttpMiddlewareOptions}?)"/>
    public GraphQLExecutionHttpResult(Action<GraphQLHttpMiddlewareOptions>? configure = null)
        : base(configure)
    {
    }

    /// <inheritdoc cref="GraphQLExecutionHttpResult{TSchema}.GraphQLExecutionHttpResult(GraphQLHttpMiddlewareOptions)"/>
    public GraphQLExecutionHttpResult(GraphQLHttpMiddlewareOptions options)
        : base(options)
    {
    }
}

However, so far I fail to understand why you are trying to use MapPost vs UseGraphQL, which should essentially do the same thing while being better optimized and better supported.

[sri-s-creator]

Thanks, I'll give this a try.
I'm trying to use MapPost vs UseGraphQL because of additional pre-processing and custom authorization in our legacy code which would likely require a massive refactor.

[Shane32]

See:

• Support IResult via GraphQLExecutionHttpResult for .NET 6+ #1191

[sri-s-creator]

Hi @Shane32 - tested this, and it works as expected. Thank you for the quick turnaround on this, I will use this for now and consume this in the 8.3.0 release when it's available.

[Shane32]

Released today:

• https://www.nuget.org/packages/GraphQL.Server.Transports.AspNetCore/8.3.0