public ConfigureRequestExecutorSetup(
NameString schemaName,
RequestExecutorSetup options)
{
SchemaName = schemaName.EnsureNotEmpty(nameof(schemaName));
_configure = options.CopyTo;
}
private async Task CreateFactoryOptionsAsync(
RemoteSchemaDefinition schemaDefinition,
IList <IConfigureRequestExecutorSetup> factoryOptions,
CancellationToken cancellationToken)
{
await using ServiceProvider services =
new ServiceCollection()
.AddGraphQL(_schemaName)
.AddRemoteSchema(
schemaDefinition.Name,
(sp, ct) => new ValueTask <RemoteSchemaDefinition>(schemaDefinition))
.Services
.BuildServiceProvider();
IRequestExecutorOptionsMonitor optionsMonitor =
services.GetRequiredService <IRequestExecutorOptionsMonitor>();
RequestExecutorSetup options =
await optionsMonitor.GetAsync(schemaDefinition.Name, cancellationToken)
.ConfigureAwait(false);
factoryOptions.Add(new ConfigureRequestExecutorSetup(schemaDefinition.Name, options));
options =
await optionsMonitor.GetAsync(_schemaName, cancellationToken)
.ConfigureAwait(false);
factoryOptions.Add(new ConfigureRequestExecutorSetup(_schemaName, options));
}
public void Configure(RequestExecutorSetup options)
{
if (options is null)
{
throw new ArgumentNullException(nameof(options));
}
_configure(options);
}
public RegisteredExecutor(
IRequestExecutor executor,
IServiceProvider services,
IDiagnosticEvents diagnosticEvents,
RequestExecutorSetup setup)
{
Executor = executor;
Services = services;
DiagnosticEvents = diagnosticEvents;
Setup = setup;
}
public RegisteredExecutor(
IRequestExecutor executor,
IServiceProvider services,
IExecutionDiagnosticEvents diagnosticEvents,
RequestExecutorSetup setup,
TypeModuleChangeMonitor typeModuleChangeMonitor)
{
Executor = executor;
Services = services;
DiagnosticEvents = diagnosticEvents;
Setup = setup;
TypeModuleChangeMonitor = typeModuleChangeMonitor;
}
public async ValueTask <IRequestExecutor> GetRequestExecutorNoLockAsync(
NameString schemaName = default,
CancellationToken cancellationToken = default)
{
schemaName = schemaName.HasValue ? schemaName : Schema.DefaultName;
if (!_executors.TryGetValue(schemaName, out RegisteredExecutor? re))
{
RequestExecutorSetup options =
await _optionsMonitor.GetAsync(schemaName, cancellationToken)
.ConfigureAwait(false);
IServiceProvider schemaServices =
await CreateSchemaServicesAsync(schemaName, options, cancellationToken)
.ConfigureAwait(false);
re = new RegisteredExecutor
(
schemaServices.GetRequiredService <IRequestExecutor>(),
schemaServices,
schemaServices.GetRequiredService <IDiagnosticEvents>(),
options
);
foreach (OnRequestExecutorCreatedAction action in options.OnRequestExecutorCreated)
{
action.Action?.Invoke(re.Executor);
if (action.AsyncAction is not null)
{
await action.AsyncAction.Invoke(re.Executor, cancellationToken)
.ConfigureAwait(false);
}
}
re.DiagnosticEvents.ExecutorCreated(schemaName, re.Executor);
_executors.TryAdd(schemaName, re);
}
return(re.Executor);
}
private async ValueTask <RequestExecutorOptions> CreateExecutorOptionsAsync(
RequestExecutorSetup options,
CancellationToken cancellationToken)
{
var executorOptions = options.RequestExecutorOptions ?? new RequestExecutorOptions();
foreach (RequestExecutorOptionsAction action in options.RequestExecutorOptionsActions)
{
if (action.Action is { } configure)
{
configure(executorOptions);
}
if (action.AsyncAction is { } configureAsync)
{
await configureAsync(executorOptions, cancellationToken).ConfigureAwait(false);
}
}
return(executorOptions);
}
private async ValueTask <ISchema> CreateSchemaAsync(
NameString schemaName,
RequestExecutorSetup options,
IServiceProvider serviceProvider,
CancellationToken cancellationToken)
{
if (options.Schema is not null)
{
AssertSchemaNameValid(options.Schema, schemaName);
return(options.Schema);
}
ISchemaBuilder schemaBuilder = options.SchemaBuilder ?? new SchemaBuilder();
schemaBuilder.AddServices(serviceProvider);
foreach (SchemaBuilderAction action in options.SchemaBuilderActions)
{
if (action.Action is { } configure)
{
configure(serviceProvider, schemaBuilder);
}
if (action.AsyncAction is { } configureAsync)
{
await configureAsync(serviceProvider, schemaBuilder, cancellationToken)
.ConfigureAwait(false);
}
}
schemaBuilder.TryAddTypeInterceptor(new SetSchemaNameInterceptor(schemaName));
ISchema schema = schemaBuilder.Create();
AssertSchemaNameValid(schema, schemaName);
return(schema);
}
private async Task <IServiceProvider> CreateSchemaServicesAsync(
NameString schemaName,
RequestExecutorSetup options,
CancellationToken cancellationToken)
{
var lazy = new SchemaBuilder.LazySchema();
RequestExecutorOptions executorOptions =
await CreateExecutorOptionsAsync(options, cancellationToken)
.ConfigureAwait(false);
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton <IApplicationServiceProvider>(
s => new DefaultApplicationServiceProvider(_applicationServices));
serviceCollection.AddSingleton(s => lazy.Schema);
serviceCollection.AddSingleton(executorOptions);
serviceCollection.AddSingleton <IRequestExecutorOptionsAccessor>(
s => s.GetRequiredService <RequestExecutorOptions>());
serviceCollection.AddSingleton <IInstrumentationOptionsAccessor>(
s => s.GetRequiredService <RequestExecutorOptions>());
serviceCollection.AddSingleton <IErrorHandlerOptionsAccessor>(
s => s.GetRequiredService <RequestExecutorOptions>());
serviceCollection.AddSingleton <IDocumentCacheSizeOptionsAccessor>(
s => s.GetRequiredService <RequestExecutorOptions>());
serviceCollection.AddSingleton <IRequestTimeoutOptionsAccessor>(
s => s.GetRequiredService <RequestExecutorOptions>());
serviceCollection.AddSingleton <IErrorHandler, DefaultErrorHandler>();
serviceCollection.TryAddDiagnosticEvents();
serviceCollection.TryAddOperationExecutors();
serviceCollection.TryAddTimespanProvider();
// register global error filters
foreach (IErrorFilter errorFilter in _applicationServices.GetServices <IErrorFilter>())
{
serviceCollection.AddSingleton(errorFilter);
}
// register global diagnostic listener
foreach (IDiagnosticEventListener diagnosticEventListener in
_applicationServices.GetServices <IDiagnosticEventListener>())
{
serviceCollection.AddSingleton(diagnosticEventListener);
}
serviceCollection.AddSingleton <IActivator>(
sp => new DefaultActivator(_applicationServices));
serviceCollection.AddSingleton(
sp => CreatePipeline(
schemaName,
options.Pipeline,
sp,
sp.GetRequiredService <IRequestExecutorOptionsAccessor>()));
serviceCollection.AddSingleton <IRequestExecutor>(
sp => new RequestExecutor(
sp.GetRequiredService <ISchema>(),
_applicationServices.GetRequiredService <DefaultRequestContextAccessor>(),
_applicationServices,
sp,
sp.GetRequiredService <IErrorHandler>(),
_applicationServices.GetRequiredService <ITypeConverter>(),
sp.GetRequiredService <IActivator>(),
sp.GetRequiredService <IDiagnosticEvents>(),
sp.GetRequiredService <RequestDelegate>())
);
foreach (Action <IServiceCollection> configureServices in options.SchemaServices)
{
configureServices(serviceCollection);
}
var schemaServices = serviceCollection.BuildServiceProvider();
var combinedServices = schemaServices.Include(_applicationServices);
lazy.Schema =
await CreateSchemaAsync(schemaName, options, combinedServices, cancellationToken)
.ConfigureAwait(false);
return(schemaServices);
}
