private static void CompileMiddleware(
ITypeCompletionContext context,
ObjectFieldDefinition definition,
ITypeReference argumentTypeReference,
FieldMiddleware placeholder,
string?scope)
{
IType resolvedType = context.GetType <IType>(argumentTypeReference);
if (!(resolvedType.ElementType().NamedType() is ISortInputType type))
{
throw Sorting_TypeOfInvalidFormat(resolvedType);
}
ISortConvention convention = context.DescriptorContext.GetSortConvention(scope);
var fieldDescriptor = ObjectFieldDescriptor.From(context.DescriptorContext, definition);
convention.ConfigureField(fieldDescriptor);
MethodInfo factory = _factoryTemplate.MakeGenericMethod(type.EntityType.Source);
var middleware = (FieldMiddleware)factory.Invoke(null, new object[] { convention }) !;
var index = definition.MiddlewareComponents.IndexOf(placeholder);
definition.MiddlewareComponents[index] = middleware;
}
private void OnBeforeCompleteName(
ITypeCompletionContext completionContext,
SortInputTypeDefinition definition)
{
ISortConvention convention = GetConvention(
completionContext.DescriptorContext,
definition.Scope);
var descriptor = SortInputTypeDescriptor.New(
completionContext.DescriptorContext,
definition.EntityType,
definition.Scope);
SchemaTypeReference typeReference = TypeReference.Create(
completionContext.Type,
definition.Scope);
convention.ApplyConfigurations(typeReference, descriptor);
DataTypeExtensionHelper.MergeSortInputTypeDefinitions(
completionContext,
descriptor.CreateDefinition(),
definition);
if (definition is { Name : {} } &&
public static SchemaException SortConvention_OperationIsNotNamed(
ISortConvention sortConvention,
SortOperation sortOperation) =>
new SchemaException(
SchemaErrorBuilder.New()
.SetMessage(
DataResources.SortProvider_UnableToCreateFieldHandler,
sortOperation.Id,
sortConvention.GetType().FullName ?? sortConvention.GetType().Name,
sortConvention.Scope ?? "Default")
.SetExtension(nameof(sortConvention), sortConvention)
.SetExtension(nameof(sortOperation), sortOperation)
.Build());
protected SortEnumValueDescriptor(
IDescriptorContext context,
string?scope,
int value)
: base(context, new SortEnumValueDefinition {
Operation = value
})
{
ISortConvention convention = context.GetSortConvention(scope);
Definition.Name = convention.GetOperationName(value);
Definition.Description = convention.GetOperationDescription(value);
Definition.RuntimeValue = Definition.Name.Value;
}
private void ConfigureSortInputType(
ITypeDiscoveryContext discoveryContext,
SortInputTypeDefinition definition)
{
ISortConvention convention = GetConvention(
discoveryContext.DescriptorContext,
definition.Scope);
var descriptor = SortInputTypeDescriptor.From(
discoveryContext.DescriptorContext,
definition,
definition.Scope);
SchemaTypeReference typeReference = TypeReference.Create(
discoveryContext.Type,
definition.Scope);
convention.ApplyConfigurations(typeReference, descriptor);
foreach (InputFieldDefinition field in definition.Fields)
{
if (field is SortFieldDefinition sortFieldDefinition)
{
if (discoveryContext.TryPredictTypeKind(
sortFieldDefinition.Type,
out TypeKind kind) &&
kind != TypeKind.Enum)
{
field.Type = field.Type.With(scope: discoveryContext.Scope);
}
if (convention.TryGetFieldHandler(
discoveryContext,
definition,
sortFieldDefinition,
out ISortFieldHandler? handler))
{
sortFieldDefinition.Handler = handler;
}
else
{
throw ThrowHelper.SortInterceptor_NoFieldHandlerFoundForField(
definition,
sortFieldDefinition);
}
}
}
}
private static void CompileMiddleware(
ITypeCompletionContext context,
ObjectFieldDefinition definition,
ITypeReference argumentTypeReference,
FieldMiddleware placeholder,
string?scope)
{
ISortInputType type = context.GetType <ISortInputType>(argumentTypeReference);
ISortConvention convention = context.DescriptorContext.GetSortConvention(scope);
MethodInfo factory = _factoryTemplate.MakeGenericMethod(type.EntityType.Source);
var middleware = (FieldMiddleware)factory.Invoke(null, new object[] { convention }) !;
var index = definition.MiddlewareComponents.IndexOf(placeholder);
definition.MiddlewareComponents[index] = middleware;
}
private void ConfigureSortEnumType(
ITypeDiscoveryContext discoveryContext,
SortEnumTypeDefinition definition)
{
ISortConvention convention = GetConvention(
discoveryContext.DescriptorContext,
discoveryContext.Scope);
ISortEnumTypeDescriptor descriptor = SortEnumTypeDescriptor.From(
discoveryContext.DescriptorContext,
definition);
SchemaTypeReference typeReference = TypeReference.Create(
discoveryContext.Type,
discoveryContext.Scope);
convention.ApplyConfigurations(typeReference, descriptor);
foreach (var enumValue in definition.Values)
{
if (enumValue is SortEnumValueDefinition sortEnumValueDefinition)
{
if (convention.TryGetOperationHandler(
discoveryContext,
definition,
sortEnumValueDefinition,
out ISortOperationHandler? handler))
{
sortEnumValueDefinition.Handler = handler;
}
else
{
throw ThrowHelper.SortInterceptor_NoOperationHandlerFoundForValue(
definition,
sortEnumValueDefinition);
}
}
}
}
private void OnBeforeRegisteringDependencies(
ITypeDiscoveryContext discoveryContext,
SortEnumTypeDefinition definition)
{
ISortConvention convention = GetConvention(
discoveryContext.DescriptorContext,
definition.Scope);
var descriptor = SortEnumTypeDescriptor.New(
discoveryContext.DescriptorContext,
definition.EntityType,
definition.Scope);
SchemaTypeReference typeReference = TypeReference.Create(
discoveryContext.Type,
definition.Scope);
convention.ApplyConfigurations(typeReference, descriptor);
SortEnumTypeDefinition extensionDefinition = descriptor.CreateDefinition();
discoveryContext.RegisterDependencies(extensionDefinition);
}
private static FieldMiddleware CreateMiddleware <TEntity>(
ISortConvention convention) =>
convention.CreateExecutor <TEntity>();
private static IObjectFieldDescriptor UseSortingInternal(
IObjectFieldDescriptor descriptor,
Type?sortType,
string?scope)
{
FieldMiddleware placeholder = next => context => default;
string argumentPlaceholder =
"_" + Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
descriptor
.Use(placeholder)
.Extend()
.OnBeforeCreate(
(c, definition) =>
{
ISortConvention convention = c.GetSortConvention(scope);
Type argumentType;
if (sortType is null)
{
if (definition.ResultType is null ||
definition.ResultType == typeof(object) ||
!c.TypeInspector.TryCreateTypeInfo(
definition.ResultType,
out ITypeInfo? typeInfo))
{
throw new ArgumentException(
SortObjectFieldDescriptorExtensions_UseSorting_CannotHandleType,
nameof(descriptor));
}
ExtendedTypeReference fieldType = convention
.GetFieldType(typeInfo.NamedType);
argumentType = fieldType.Type.Type;
}
else
{
argumentType = sortType;
}
ExtendedTypeReference argumentTypeReference = c.TypeInspector.GetTypeRef(
typeof(ListType <>).MakeGenericType(
typeof(NonNullType <>).MakeGenericType(argumentType)),
TypeContext.Input,
scope);
var argumentDefinition = new ArgumentDefinition
{
Name = argumentPlaceholder, Type = argumentTypeReference
};
definition.Arguments.Add(argumentDefinition);
definition.Configurations.Add(
LazyTypeConfigurationBuilder
.New <ObjectFieldDefinition>()
.Definition(definition)
.Configure(
(context, def) =>
CompileMiddleware(
context,
def,
argumentTypeReference,
placeholder,
scope))
.On(ApplyConfigurationOn.Completion)
.DependsOn(argumentTypeReference, true)
.Build());
argumentDefinition.Configurations.Add(
LazyTypeConfigurationBuilder
.New <ArgumentDefinition>()
.Definition(argumentDefinition)
.Configure(
(context, argumentDefinition) =>
argumentDefinition.Name =
context.GetSortConvention(scope).GetArgumentName())
.On(ApplyConfigurationOn.Naming)
.Build());
});
return(descriptor);
}
