ASP .NET 6 Web application with multiple schemas and GraphQLHttpMiddleware issue.

[wremert]

Hello,

We have an application where we use multiple schemas on different paths.
Now we need a GraphQLHttpMiddleware on the different schemas and they still need to point to individual paths.
When adding the GraphQLHttpMiddleware it acts as the schema we add first is the only one that will be applied for all the others aswell.

I can take down the example to two different schemas.

Example "ApplicationIntegrations"
This is how we did before:
services.AddGraphQL(builder => builder.AddSchema<ApplicationIntegrationsSchema>());

app.UseGraphQL<ApplicationIntegrationsSchema>("/applicationintegrations");

This is how we test now:
services.AddGraphQL(builder => builder.AddSelfActivatingSchema<ApplicationIntegrationsSchema>());

app.UseGraphQL<DatalayerMiddleWare<ApplicationIntegrationsSchema>>("/applicationintegrations", new GraphQLHttpMiddlewareOptions() { /---Some options related to authenticate---/ });

Example "DMT"
This is how we did before:
services.AddGraphQL(builder => builder.AddSchema<DmtSchema>());

app.UseGraphQL<DmtSchema>("/dmt");

This is how we test now:
services.AddGraphQL(builder => builder.AddSelfActivatingSchema<DmtSchema>());

app.UseGraphQL<DatalayerMiddleWare<DmtSchema>>("/dmt", new GraphQLHttpMiddlewareOptions() { /---Some options related to authenticate---/ });

When adding the middleware it doesn't matter if using the path /dmt or /applicationintegrations, both of them will load the schema from the first schema. In this case ApplicationIntegrationsSchema.
Also tested to create individual Middleware for each of the schemas. It acts the same way.
I checked the base.GetType().FullName in the middleware while debugging I can see that the correct schema is passed in. But when leaving the middleware the first schema will activate their Query.

If I go back to the old way it works like a charm and both of the paths have their respective schemas. But then the middleware is not applied.

If there's any input that could help me in a better direction I'd be really happy. Been banging my head on the table for a couple of days over this.

Thanks for a great package overall.

I'll add the files with all content if that helps.

program.cs

using Microsoft.AspNetCore.Diagnostics.HealthChecks;
using Serilog;
/-- a lot of internal usings --/
using TG.Datalayer.Foundation.GraphQL.Extension;

var builder = WebApplication.CreateBuilder(args);
/-- other internal adds--/

var dmtOptions = builder.Configuration.GetSection(DMTEndpointOptions.Key).Get<DMTEndpointOptions>();
var applicationIntegrationsOptions = builder.Configuration.GetSection(ApplicationIntegrationsEndpointOptions.Key).Get<ApplicationIntegrationsEndpointOptions>();

#if DEBUG
dmtOptions.EnableGraphQL = true;
applicationIntegrationsOptions.EnableGraphQL = true;
#endif

/-- other internal adds--/

builder.Services.AddControllers();

// Add all GraphQL services
builder.Services.AddGraphQLBaseServices();
builder.Services.AddApplicationIntegrationsGraphQLServices(applicationIntegrationsOptions);
builder.Services.AddDmtGraphQLServices(dmtOptions);

/-- other internal adds--/

var app = builder.Build();

app.UseRequestBody();
app.UseSerilogRequestLogging();

// Configure the HTTP request pipeline.
app.UseHttpsRedirection();
app.UseAuthentication(); 
app.UseAuthorization();

app.MapControllers();

/-- other internal maps--/

// Add Altair as gui for GraphQL queries
app.UseGraphQLAltair();

// Add all GraphQL app settings
app.AddDmtGraphQLAppSettings(dmtOptions);
app.AddApplicationIntegrationsGraphQLAppSettings(applicationIntegrationsOptions);

app.Run();

AddGraphQLBaseServices

public static class ServiceExtension
    {
        public static void AddGraphQLBaseServices(this IServiceCollection services)
        {
            services.AddGraphQL(builder => builder
                .AddSystemTextJson()
                .AddErrorInfoProvider(opt => opt.ExposeExceptionStackTrace = true)
                .AddGraphTypes()
            );
        }
    }

AddApplicationIntegrationsGraphQLServices

public static class ServiceExtension
    {
        public static void AddApplicationIntegrationsGraphQLServices(this IServiceCollection services, ApplicationIntegrationsEndpointOptions applicationIntegrationsEndpointOptions)
        {
            if (!applicationIntegrationsEndpointOptions.EnableGraphQL)
            {
                return;
            }

            services.AddGraphQL(builder => builder
                .AddSelfActivatingSchema<ApplicationIntegrationsSchema>()
            );

            services.AddSingleton<IApplicationIntegrationsRepository, ApplicationIntegrationsRepository>();
        }
    }

AddDmtGraphQLServices

public static void AddDmtGraphQLServices(this IServiceCollection services, DMTEndpointOptions dmtEndpointOptions)
        {
            if (!dmtEndpointOptions.EnableGraphQL)
            {
                return;
            }

            services.AddGraphQL(builder => builder
                .AddSelfActivatingSchema<DmtSchema>()
            );

            services.AddSingleton<IDmtRepository, DmtRepository>();
        }

AddDmtGraphQLAppSettings

public static void AddDmtGraphQLAppSettings(this WebApplication app, DMTEndpointOptions dMTEndpointOptions)
        {
            if (!dMTEndpointOptions.EnableGraphQL)
            {
                return;
            }

            app.UseGraphQL<DatalayerMiddleWare<DmtSchema>>("/dmt", new GraphQLHttpMiddlewareOptions()
            {
                AuthorizedRoles = new List<string>() { "" }
            });
        }

AddApplicationIntegrationsGraphQLAppSettings
(Also tried with an individual middleware with same result)

 public static void AddApplicationIntegrationsGraphQLAppSettings(this WebApplication app, ApplicationIntegrationsEndpointOptions applicationIntegrationsEndpointOptions)
        {
            if (!applicationIntegrationsEndpointOptions.EnableGraphQL)
            {
                return;
            }

            app.UseGraphQL<DatalayerMiddleWare<ApplicationIntegrationsSchema>>("/applicationintegrations", new GraphQLHttpMiddlewareOptions()
            {
                AuthorizedRoles = new List<string>() { "" }
            });
        }

DatalayerMiddleWare

public class DatalayerMiddleWare<TSchema> : GraphQLHttpMiddleware where TSchema : ISchema
{
    private readonly IUserHandler _userHandler;
    private readonly ILogger<EndpointMetrics> _logger;

    public DatalayerMiddleWare(RequestDelegate next, IGraphQLTextSerializer serializer, IDocumentExecuter documentExecuter, IServiceScopeFactory serviceScopeFactory, GraphQLHttpMiddlewareOptions options, IHostApplicationLifetime hostApplicationLifetime, IUserHandler userHandler, ILogger<EndpointMetrics> logger) : base(next, serializer, documentExecuter, serviceScopeFactory, options, hostApplicationLifetime)
    {
        _userHandler = userHandler;
        _logger = logger;
    }

    protected override async ValueTask<bool> HandleAuthorizeAsync(HttpContext context, RequestDelegate next)
    {
        //Internal logic for some Authorization
        
        return await base.HandleAuthorizeAsync(context, next);
    }
}

[Shane32]

What version of each GraphQL.NET package are you using? 7.x for all?

[wremert]

7.1.1 for all.

[Shane32]

Change IDocumentExecuter to IDocumentExecuter<TSchema> here:

public class DatalayerMiddleWare<TSchema> : GraphQLHttpMiddleware where TSchema : ISchema
{
    private readonly IUserHandler _userHandler;
    private readonly ILogger<EndpointMetrics> _logger;

    public DatalayerMiddleWare(RequestDelegate next, IGraphQLTextSerializer serializer, IDocumentExecuter<TSchema> documentExecuter, IServiceScopeFactory serviceScopeFactory, GraphQLHttpMiddlewareOptions options, IHostApplicationLifetime hostApplicationLifetime, IUserHandler userHandler, ILogger<EndpointMetrics> logger) : base(next, serializer, documentExecuter, serviceScopeFactory, options, hostApplicationLifetime)
    {
        _userHandler = userHandler;
        _logger = logger;
    }

    protected override async ValueTask<bool> HandleAuthorizeAsync(HttpContext context, RequestDelegate next)
    {
        //Internal logic for some Authorization
        
        return await base.HandleAuthorizeAsync(context, next);
    }
}

[wremert]

Mother of all conjunktions!
This worked straight away. I had shut down my computer for a week's vacation and wrote this question to give it maybe another shot when I was back.

Your answer was so quick I had to fire up the computer again and it worked. Thank you, sir!
The constructor parameters were applied automatically when inheriting GraphQLHttpMiddleware so I was never thinking of changing them. Thanks!

[Shane32]

I should probably add some notes to the documentation regarding this...

[Shane32]

I believe you could also change the base class to : GraphQLHttpMiddleware<TSchema> which would have revealed this issue.

[wremert]

This didn't work unfortinatley since it only pointed me to a error that TSchema was a type and GraphQLHttpMiddleware didn't allow types.

[Shane32]

The middleware by default does not set the Schema property on ExecutionOptions here:

https://github.com/graphql-dotnet/server/blob/master/src/Transports.AspNetCore/GraphQLHttpMiddleware.cs#L392-L401

But rather anticipates that the DocumentExecuter<T> instance will set the schema, and does this by requesting IDocumentExecuter<T> here:

https://github.com/graphql-dotnet/server/blob/master/src/Transports.AspNetCore/GraphQLHttpMiddleware.cs#L27

This behavior described above then occurs here:

https://github.com/graphql-dotnet/graphql-dotnet/blob/master/src/GraphQL/Execution/DocumentExecuter.cs#L294-L311

In your case you are using IDocumentExecuter directly. There is a configuration automatically added to set Schema if it is not set here:

https://github.com/graphql-dotnet/graphql-dotnet/blob/master/src/GraphQL/DI/GraphQLBuilderBase.cs#L64-L70

It pulls the ISchema registration, which is the first schema registered:

https://github.com/graphql-dotnet/graphql-dotnet/blob/master/src/GraphQL/Extensions/GraphQLBuilderExtensions.cs#L180

https://github.com/graphql-dotnet/graphql-dotnet/blob/master/src/GraphQL/Extensions/GraphQLBuilderExtensions.cs#L152

[wremert]

Thanks for this. Awesome.
I must be honest. I've read and read all over documentation, gone trough source and dotPeek'ed the dll's. The findings I was left with unsolved was related to the executed but I couldn't find a way to mimic the .dll

Thansk again.

[Shane32]

No problem!