public override void OnBeforeCompleteName(
ITypeCompletionContext completionContext,
DefinitionBase?definition,
IDictionary <string, object?> contextData)
{
if (definition is FilterInputTypeDefinition def)
{
IFilterConvention convention = GetConvention(
completionContext.DescriptorContext,
def.Scope);
var descriptor = FilterInputTypeDescriptor.New(
completionContext.DescriptorContext,
def.EntityType,
def.Scope);
SchemaTypeReference typeReference = TypeReference.Create(
completionContext.Type,
def.Scope);
convention.ApplyConfigurations(typeReference, descriptor);
DataTypeExtensionHelper.MergeFilterInputTypeDefinitions(
completionContext,
descriptor.CreateDefinition(),
def);
if (def.Scope is not null)
{
definition.Name = completionContext.Scope +
"_" +
definition.Name;
}
}
}
public override void OnBeforeRegisterDependencies(
ITypeDiscoveryContext discoveryContext,
DefinitionBase?definition,
IDictionary <string, object?> contextData)
{
if (definition is FilterInputTypeDefinition def)
{
IFilterConvention convention = GetConvention(
discoveryContext.DescriptorContext,
def.Scope);
SchemaTypeReference typeReference = TypeReference.Create(
discoveryContext.Type,
def.Scope);
var descriptor = FilterInputTypeDescriptor.New(
discoveryContext.DescriptorContext,
def.EntityType,
def.Scope);
convention.ApplyConfigurations(typeReference, descriptor);
FilterInputTypeDefinition extensionDefinition = descriptor.CreateDefinition();
discoveryContext.RegisterDependencies(extensionDefinition);
}
}
public override void OnBeforeRegisterDependencies(
ITypeDiscoveryContext discoveryContext,
DefinitionBase?definition,
IDictionary <string, object?> contextData)
{
if (definition is FilterInputTypeDefinition def)
{
IFilterConvention convention = GetConvention(
discoveryContext.DescriptorContext,
def.Scope);
var descriptor = FilterInputTypeDescriptor.From(
discoveryContext.DescriptorContext,
def,
def.Scope);
var typeReference = TypeReference.Create(
discoveryContext.Type,
def.Scope);
convention.ApplyConfigurations(typeReference, descriptor);
foreach (InputFieldDefinition field in def.Fields)
{
if (field is FilterFieldDefinition filterFieldDefinition)
{
if (discoveryContext.TryPredictTypeKind(
filterFieldDefinition.Type,
out TypeKind kind) &&
kind != TypeKind.Scalar && kind != TypeKind.Enum)
{
field.Type = field.Type.With(scope: discoveryContext.Scope);
}
if (filterFieldDefinition.Handler is null)
{
if (convention.TryGetHandler(
discoveryContext,
def,
filterFieldDefinition,
out IFilterFieldHandler? handler))
{
filterFieldDefinition.Handler = handler;
}
else
{
throw ThrowHelper.FilterInterceptor_NoHandlerFoundForField(
def,
filterFieldDefinition);
}
}
}
}
}
}
protected override InputObjectTypeDefinition CreateDefinition(
ITypeDiscoveryContext context)
{
var descriptor = FilterInputTypeDescriptor.FromSchemaType(
context.DescriptorContext,
context.Scope,
GetType());
_configure(descriptor);
return(descriptor.CreateDefinition());
}
protected override InputObjectTypeDefinition CreateDefinition(
ITypeDiscoveryContext context)
{
var descriptor = FilterInputTypeDescriptor <T> .New(
context.DescriptorContext,
context.Scope,
typeof(T));
_configure(descriptor);
return(descriptor.CreateDefinition());
}
/// <inheritdoc />
public IFilterConventionDescriptor Configure <TFilterType, TRuntimeType>(
ConfigureFilterInputType <TRuntimeType> configure)
where TFilterType : FilterInputType <TRuntimeType> =>
Configure(
Context.TypeInspector.GetTypeRef(typeof(TFilterType), TypeContext.Input, Definition.Scope),
d =>
{
configure.Invoke(FilterInputTypeDescriptor.From <TRuntimeType>(
(FilterInputTypeDescriptor)d,
Definition.Scope));
});
public static FilterInputTypeDescriptor <T> From <T>(
FilterInputTypeDescriptor descriptor,
string?scope = null) =>
From <T>(descriptor.Context, descriptor.Definition, scope);
