private static void CompileMiddleware(
ObjectFieldDefinition definition,
FieldMiddleware placeholder,
Type keyType,
Type valueType,
Type dataLoaderType)
{
Type middlewareType;
if (valueType.IsArray)
{
middlewareType =
typeof(GroupedDataLoaderMiddleware <, ,>)
.MakeGenericType(dataLoaderType, keyType, valueType.GetElementType() !);
}
else
{
middlewareType =
typeof(DataLoaderMiddleware <, ,>)
.MakeGenericType(dataLoaderType, keyType, valueType);
}
FieldMiddleware middleware = FieldClassMiddlewareFactory.Create(middlewareType);
var index = definition.MiddlewareComponents.IndexOf(placeholder);
definition.MiddlewareComponents[index] = middleware;
}
public static IMiddlewareConfiguration Use <TMiddleware>(
this IMiddlewareConfiguration configuration)
where TMiddleware : class
{
return(configuration.Use(
FieldClassMiddlewareFactory.Create <TMiddleware>()));
}
public static IObjectFieldDescriptor UsePagination <TSchemaType>(this IObjectFieldDescriptor descriptor) where TSchemaType : class, IOutputType
{
FieldMiddleware placeholder = next => default(FieldDelegate);
Type middlewareDefinition = typeof(QueryableConnectionMiddleware <>);
descriptor
.AddPaginationArguments()
.Type <PaginationType <TSchemaType> >()
.Use(placeholder)
.Extend()
.OnBeforeCompletion((context, defintion) =>
{
var reference = typeof(TSchemaType)?.BaseType?.GenericTypeArguments?[0];
if (reference != null)
{
Type middlewareType = middlewareDefinition.MakeGenericType(reference);
FieldMiddleware middleware = FieldClassMiddlewareFactory.Create(
middlewareType);
int index = defintion.MiddlewareComponents.IndexOf(placeholder);
defintion.MiddlewareComponents[index] = middleware;
}
})
.DependsOn <TSchemaType>();
return(descriptor);
}
public static IQueryExecutionBuilder MapField <TMiddleware>(
this IQueryExecutionBuilder builder,
FieldReference fieldReference,
Func <IServiceProvider, FieldDelegate, TMiddleware> factory)
where TMiddleware : class
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (fieldReference == null)
{
throw new ArgumentNullException(nameof(fieldReference));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
return(builder.UseField(
FieldClassMiddlewareFactory.Create <MapMiddleware>(
(s, n) =>
{
FieldMiddleware classMiddleware =
FieldClassMiddlewareFactory.Create(factory);
return new MapMiddleware(
n, fieldReference, classMiddleware(n));
})));
}
public static IObjectFieldDescriptor UsePaging <TSchemaType>(
this IObjectFieldDescriptor descriptor)
where TSchemaType : IOutputType, new()
{
FieldMiddleware placeholder =
next => context => Task.CompletedTask;
Type middlewareDefinition = typeof(QueryableConnectionMiddleware <>);
descriptor
.AddPagingArguments()
.Type(ConnectionType <TSchemaType> .CreateWithTotalCount())
.Use(placeholder)
.Extend()
.OnBeforeCompletion((context, defintion) =>
{
var reference = new ClrTypeReference(
typeof(TSchemaType),
TypeContext.Output);
IOutputType type = context.GetType <IOutputType>(reference);
if (type.NamedType() is IHasClrType hasClrType)
{
Type middlewareType = middlewareDefinition
.MakeGenericType(hasClrType.ClrType);
FieldMiddleware middleware =
FieldClassMiddlewareFactory.Create(middlewareType);
int index =
defintion.MiddlewareComponents.IndexOf(placeholder);
defintion.MiddlewareComponents[index] = middleware;
}
})
.DependsOn <TSchemaType>();
return(descriptor);
}
public static ISchemaBuilder Use <TMiddleware>(
this ISchemaBuilder configuration)
where TMiddleware : class
{
return(configuration.Use(
FieldClassMiddlewareFactory.Create <TMiddleware>()));
}
public static IObjectFieldDescriptor UsePaging <TSchemaType>(
this IObjectFieldDescriptor descriptor)
where TSchemaType : class, IOutputType
{
FieldMiddleware placeholder = next => context => default(ValueTask);
Type middlewareDefinition = typeof(QueryableConnectionMiddleware <>);
descriptor
.AddPagingArguments()
.Type <ConnectionWithCountType <TSchemaType> >()
.Use(placeholder)
.Extend()
.OnBeforeCompletion((context, defintion) =>
{
ITypeReference reference =
context.DescriptorContext.TypeInspector.GetTypeRef(typeof(TSchemaType));
IOutputType type = context.GetType <IOutputType>(reference);
if (type.NamedType() is IHasRuntimeType hasClrType)
{
Type middlewareType = middlewareDefinition.MakeGenericType(
hasClrType.RuntimeType);
FieldMiddleware middleware = FieldClassMiddlewareFactory.Create(
middlewareType);
int index = defintion.MiddlewareComponents.IndexOf(placeholder);
defintion.MiddlewareComponents[index] = middleware;
}
})
.DependsOn <TSchemaType>();
return(descriptor);
}
public static IQueryExecutionBuilder UseField <TMiddleware>(
this IQueryExecutionBuilder builder)
where TMiddleware : class
{
return(builder.UseField(
FieldClassMiddlewareFactory.Create <TMiddleware>()));
}
public static IObjectFieldDescriptor Use <TMiddleware>(
this IObjectFieldDescriptor descriptor)
where TMiddleware : class
{
return(descriptor.Use(
FieldClassMiddlewareFactory.Create <TMiddleware>()));
}
public static IQueryExecutionBuilder MapField(
this IQueryExecutionBuilder builder,
FieldReference fieldReference,
FieldMiddleware middleware)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (fieldReference == null)
{
throw new ArgumentNullException(nameof(fieldReference));
}
if (middleware == null)
{
throw new ArgumentNullException(nameof(middleware));
}
return(builder.UseField(
FieldClassMiddlewareFactory.Create <MapMiddleware>(
(s, n) => new MapMiddleware(
n, fieldReference, middleware(n)))));
}
private static TDescriptor UseFilter <TDescriptor>(
TDescriptor descriptor,
Type filterType)
where TDescriptor : IObjectFieldDescriptor
{
FieldMiddleware placeholder =
next => context => Task.CompletedTask;
Type middlewareDefinition = typeof(QueryableFilterMiddleware <>);
descriptor
.AddFilterArguments(filterType)
.Use(placeholder)
.Extend()
.OnBeforeCompletion((context, defintion) =>
{
var reference = new ClrTypeReference(
filterType,
TypeContext.Input);
IFilterInputType type =
context.GetType <IFilterInputType>(reference);
Type middlewareType = middlewareDefinition
.MakeGenericType(type.EntityType);
FieldMiddleware middleware =
FieldClassMiddlewareFactory.Create(middlewareType);
int index =
defintion.MiddlewareComponents.IndexOf(placeholder);
defintion.MiddlewareComponents[index] = middleware;
})
.DependsOn(filterType, mustBeCompleted: true);
return(descriptor);
}
public static ISchemaBuilder Use <TMiddleware>(
this ISchemaBuilder builder)
where TMiddleware : class
{
return(builder.Use(
FieldClassMiddlewareFactory.Create <TMiddleware>()));
}
public static ISchemaBuilder Use <TMiddleware>(
this ISchemaBuilder configuration,
Func <IServiceProvider, FieldDelegate, TMiddleware> factory)
where TMiddleware : class
{
return(configuration.Use(
FieldClassMiddlewareFactory.Create(factory)));
}
public static IQueryExecutionBuilder UseField <TMiddleware>(
this IQueryExecutionBuilder builder,
Func <IServiceProvider, FieldDelegate, TMiddleware> factory)
where TMiddleware : class
{
return(builder.UseField(
FieldClassMiddlewareFactory.Create <TMiddleware>(factory)));
}
public static IMiddlewareConfiguration Map(
this IMiddlewareConfiguration configuration,
FieldReference fieldReference,
FieldMiddleware middleware)
{
return(configuration.Use(
FieldClassMiddlewareFactory.Create <MapMiddleware>(
(s, n) => new MapMiddleware(
n, fieldReference, middleware(n)))));
}
public static IRequestExecutorBuilder MapField(
this IRequestExecutorBuilder builder,
FieldReference fieldReference,
FieldMiddleware middleware)
{
return(builder.UseField(
FieldClassMiddlewareFactory.Create(
(s, n) => new MapMiddleware(
n, fieldReference, middleware(n)))));
}
public static ISchemaBuilder Map(
this ISchemaBuilder configuration,
FieldReference fieldReference,
FieldMiddleware middleware)
{
return(configuration.Use(
FieldClassMiddlewareFactory.Create(
(s, n) => new MapMiddleware(
n, fieldReference, middleware(n)))));
}
public static IQueryExecutionBuilder Map(
this IQueryExecutionBuilder builder,
FieldReference fieldReference,
FieldMiddleware middleware)
{
return(builder.UseField(
FieldClassMiddlewareFactory.Create <MapMiddleware>(
(s, n) => new MapMiddleware(
n, fieldReference, middleware(n)))));
}
private static void CompileMiddleware(
Type type,
ObjectFieldDefinition definition,
FieldMiddleware placeholder)
{
Type middlewareType = _middlewareDefinition.MakeGenericType(type);
FieldMiddleware middleware = FieldClassMiddlewareFactory.Create(middlewareType);
int index = definition.MiddlewareComponents.IndexOf(placeholder);
definition.MiddlewareComponents[index] = middleware;
}
public static IQueryExecutionBuilder UseField <TMiddleware>(
this IQueryExecutionBuilder builder)
where TMiddleware : class
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder.UseField(
FieldClassMiddlewareFactory.Create <TMiddleware>()));
}
public static IObjectFieldDescriptor Use <TMiddleware>(
this IObjectFieldDescriptor descriptor,
Func <IServiceProvider, FieldDelegate, TMiddleware> factory)
where TMiddleware : class
{
if (factory is null)
{
throw new ArgumentNullException(nameof(factory));
}
return(descriptor.Use(FieldClassMiddlewareFactory.Create(factory)));
}
public static ISchemaBuilder Map <TMiddleware>(
this ISchemaBuilder configuration,
FieldReference fieldReference)
where TMiddleware : class
{
return(configuration.Use(
FieldClassMiddlewareFactory.Create(
(s, n) =>
{
FieldMiddleware classMiddleware =
FieldClassMiddlewareFactory.Create <TMiddleware>();
return new MapMiddleware(
n, fieldReference, classMiddleware(n));
})));
}
public static IQueryExecutionBuilder Map <TMiddleware>(
this IQueryExecutionBuilder builder,
FieldReference fieldReference)
where TMiddleware : class
{
return(builder.UseField(
FieldClassMiddlewareFactory.Create <MapMiddleware>(
(s, n) =>
{
FieldMiddleware classMiddleware =
FieldClassMiddlewareFactory.Create <TMiddleware>();
return new MapMiddleware(
n, fieldReference, classMiddleware(n));
})));
}
private static void CompileMiddleware(
ICompletionContext context,
ObjectFieldDefinition definition,
ITypeReference argumentTypeReference,
FieldMiddleware placeholder)
{
IFilterInputType type =
context.GetType <IFilterInputType>(argumentTypeReference);
Type middlewareType = _middlewareDefinition
.MakeGenericType(type.EntityType);
FieldMiddleware middleware =
FieldClassMiddlewareFactory.Create(middlewareType);
int index = definition.MiddlewareComponents.IndexOf(placeholder);
definition.MiddlewareComponents[index] = middleware;
}
public static ISchemaBuilder Map <TMiddleware>(
this ISchemaBuilder configuration,
FieldReference fieldReference,
Func <IServiceProvider, FieldDelegate, TMiddleware> factory)
where TMiddleware : class
{
return(configuration.Use(
FieldClassMiddlewareFactory.Create(
(s, n) =>
{
FieldMiddleware classMiddleware =
FieldClassMiddlewareFactory
.Create(factory);
return new MapMiddleware(
n, fieldReference, classMiddleware(n));
})));
}
public static IRequestExecutorBuilder MapField <TMiddleware>(
this IRequestExecutorBuilder builder,
FieldReference fieldReference,
Func <IServiceProvider, FieldDelegate, TMiddleware> factory)
where TMiddleware : class
{
return(builder.UseField(
FieldClassMiddlewareFactory.Create(
(s, n) =>
{
FieldMiddleware classMiddleware =
FieldClassMiddlewareFactory
.Create(factory);
return new MapMiddleware(
n, fieldReference, classMiddleware(n));
})));
}
private static void CompileMiddleware(
Type type,
ObjectFieldDefinition definition,
FieldMiddleware placeholder,
ICompletionContext context)
{
IFilterConvention filterConvention = context.DescriptorContext.GetFilterConvention();
string sortingConventionArgumentName =
context.DescriptorContext.GetSortingNamingConvention().ArgumentName;
Type middlewareType = _middlewareDefinition.MakeGenericType(type);
FieldMiddleware middleware =
FieldClassMiddlewareFactory.Create(middlewareType,
SelectionMiddlewareContext.Create(
filterConvention, sortingConventionArgumentName));
int index = definition.MiddlewareComponents.IndexOf(placeholder);
definition.MiddlewareComponents[index] = middleware;
}
public static IQueryExecutionBuilder UseField <TMiddleware>(
this IQueryExecutionBuilder builder,
Func <IServiceProvider, FieldDelegate, TMiddleware> factory)
where TMiddleware : class
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
return(builder.UseField(
FieldClassMiddlewareFactory.Create(factory)));
}
private static void CompileMiddleware(
ICompletionContext context,
ObjectFieldDefinition definition,
ITypeReference argumentTypeReference,
FieldMiddleware placeholder)
{
ISortingNamingConvention convention =
context.DescriptorContext.GetSortingNamingConvention();
ISortInputType type = context.GetType <ISortInputType>(argumentTypeReference);
Type middlewareType = _middlewareDefinition.MakeGenericType(type.EntityType);
FieldMiddleware middleware =
FieldClassMiddlewareFactory.Create(
middlewareType,
SortMiddlewareContext.Create(convention.ArgumentName));
int index = definition.MiddlewareComponents.IndexOf(placeholder);
definition.MiddlewareComponents[index] = middleware;
}
public override void OnBeforeCompleteType(
ITypeCompletionContext completionContext,
DefinitionBase?definition,
IDictionary <string, object?> contextData)
{
if (definition is not ObjectTypeDefinition objTypeDef)
{
return;
}
var options = completionContext.Services
.GetRequiredService <IFairyBreadOptions>();
var validatorRegistry = completionContext.Services
.GetRequiredService <IValidatorRegistry>();
foreach (var fieldDef in objTypeDef.Fields)
{
// Don't add validation middleware unless:
// 1. we have args
var needsValidationMiddleware = false;
foreach (var argDef in fieldDef.Arguments)
{
var argCoord = new FieldCoordinate(objTypeDef.Name, fieldDef.Name, argDef.Name);
// 2. the argument should be validated according to options func
if (!options.ShouldValidateArgument(objTypeDef, fieldDef, argDef))
{
continue;
}
// 3. there's validators for it
List <ValidatorDescriptor> validatorDescs;
try
{
validatorDescs = DetermineValidatorsForArg(validatorRegistry, argDef);
if (validatorDescs.Count < 1)
{
continue;
}
}
catch (Exception ex)
{
throw new Exception(
$"Problem getting runtime type for argument '{argDef.Name}' " +
$"in field '{fieldDef.Name}' on object type '{objTypeDef.Name}'.",
ex);
}
// Cleanup context now we're done with these
foreach (var key in argDef.ContextData.Keys)
{
if (key.StartsWith(WellKnownContextData.Prefix))
{
argDef.ContextData.Remove(key);
}
}
validatorDescs.TrimExcess();
needsValidationMiddleware = true;
argDef.ContextData[WellKnownContextData.ValidatorDescriptors] = validatorDescs.AsReadOnly();
}
if (needsValidationMiddleware)
{
if (_validationFieldMiddlewareDef is null)
{
_validationFieldMiddlewareDef = new FieldMiddlewareDefinition(
FieldClassMiddlewareFactory.Create <ValidationMiddleware>());
}
fieldDef.MiddlewareDefinitions.Insert(0, _validationFieldMiddlewareDef);
}
}
}
