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 : {} } &&
protected internal SortInputTypeDescriptor(
IDescriptorContext context,
SortInputTypeDefinition definition,
string?scope)
: base(context, definition, scope)
{
}
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);
}
}
}
}
public bool TryGetFieldHandler(
ITypeDiscoveryContext context,
SortInputTypeDefinition typeDefinition,
SortFieldDefinition fieldDefinition,
[NotNullWhen(true)] out ISortFieldHandler?handler)
{
foreach (ISortFieldHandler sortFieldHandler in _provider.FieldHandlers)
{
if (sortFieldHandler.CanHandle(context, typeDefinition, fieldDefinition))
{
handler = sortFieldHandler;
return(true);
}
}
handler = null;
return(false);
}
private void OnBeforeRegisteringDependencies(
ITypeDiscoveryContext discoveryContext,
SortInputTypeDefinition definition)
{
ISortConvention convention = GetConvention(
discoveryContext.DescriptorContext,
definition.Scope);
var descriptor = SortInputTypeDescriptor.New(
discoveryContext.DescriptorContext,
definition.EntityType,
definition.Scope);
SchemaTypeReference typeReference = TypeReference.Create(
discoveryContext.Type,
definition.Scope);
convention.ApplyConfigurations(typeReference, descriptor);
SortInputTypeDefinition extensionDefinition = descriptor.CreateDefinition();
discoveryContext.RegisterDependencies(extensionDefinition);
}
public override bool CanHandle(
ITypeDiscoveryContext context,
SortInputTypeDefinition typeDefinition,
SortFieldDefinition fieldDefinition) => true;
/// <inheritdoc />
public abstract bool CanHandle(
ITypeDiscoveryContext context,
SortInputTypeDefinition typeDefinition,
SortFieldDefinition fieldDefinition);
