protected override void OnCreateDefinition(
FilterInputTypeDefinition definition)
{
if (!Definition.AttributesAreApplied && Definition.EntityType is not null)
{
Context.TypeInspector.ApplyAttributes(Context, this, Definition.EntityType);
Definition.AttributesAreApplied = true;
}
var fields = new Dictionary <NameString, FilterOperationDefintion>();
var handledProperties = new HashSet <PropertyInfo>();
var explicitFields = Fields.Select(t => t.CreateDefinition()).ToList();
FieldDescriptorUtilities.AddExplicitFields(
explicitFields.Where(t => !t.Ignore).SelectMany(t => t.Filters),
f => f.Operation?.Property,
fields,
handledProperties);
foreach (FilterFieldDefintion field in explicitFields.Where(t => t.Ignore))
{
handledProperties.Add(field.Property);
}
OnCompleteFields(fields, handledProperties);
Definition.Fields.AddRange(fields.Values);
}
protected override void OnCreateDefinition(
DirectiveTypeDefinition definition)
{
if (!Definition.AttributesAreApplied && Definition.RuntimeType != typeof(object))
{
Context.TypeInspector.ApplyAttributes(
Context,
this,
Definition.RuntimeType);
Definition.AttributesAreApplied = true;
}
var arguments = new Dictionary <NameString, DirectiveArgumentDefinition>();
var handledMembers = new HashSet <PropertyInfo>();
FieldDescriptorUtilities.AddExplicitFields(
Arguments.Select(t => t.CreateDefinition()),
f => f.Property,
arguments,
handledMembers);
OnCompleteArguments(arguments, handledMembers);
definition.Arguments.AddRange(arguments.Values);
base.OnCreateDefinition(definition);
}
protected override void OnCompleteFields(
IDictionary <NameString, InputFieldDefinition> fields,
ISet <PropertyInfo> handledProperties)
{
if (Definition.Fields.IsImplicitBinding())
{
FieldDescriptorUtilities.AddImplicitFields(
this,
p => InputFieldDescriptor
.New(Context, p)
.CreateDefinition(),
fields,
handledProperties);
}
base.OnCompleteFields(fields, handledProperties);
}
protected override void OnCreateDefinition(
FilterInputTypeDefinition definition)
{
var fields = new Dictionary <NameString, FilterOperationDefintion>();
var handledProperties = new HashSet <PropertyInfo>();
FieldDescriptorUtilities.AddExplicitFields(
Fields.Select(t => t.CreateDefinition())
.SelectMany(t => t.Filters),
f => f.Operation.Property,
fields,
handledProperties);
OnCompleteFields(fields, handledProperties);
Definition.Fields.AddRange(fields.Values);
}
protected override void OnCompleteArguments(
IDictionary <NameString, DirectiveArgumentDefinition> arguments,
ISet <PropertyInfo> handledProperties)
{
if (Definition.Arguments.IsImplicitBinding())
{
FieldDescriptorUtilities.AddImplicitFields(
this,
p => DirectiveArgumentDescriptor
.New(Context, p)
.CreateDefinition(),
arguments,
handledProperties);
}
base.OnCompleteArguments(arguments, handledProperties);
}
protected override void OnCompleteFields(
IDictionary <NameString, FilterFieldDefinition> fields,
ISet <MemberInfo> handledProperties)
{
if (Definition.Fields.IsImplicitBinding())
{
FieldDescriptorUtilities.AddImplicitFields(
this,
Definition.EntityType,
p => FilterFieldDescriptor
.New(Context, Definition.Scope, p)
.CreateDefinition(),
fields,
handledProperties,
include: (members, member) => member is PropertyInfo);
}
base.OnCompleteFields(fields, handledProperties);
}
protected override void OnCreateDefinition(
SortInputTypeDefinition definition)
{
if (!Definition.AttributesAreApplied && Definition.EntityType is not null)
{
Context.TypeInspector.ApplyAttributes(Context, this, Definition.EntityType);
Definition.AttributesAreApplied = true;
}
var fields = new Dictionary <NameString, SortFieldDefinition>();
var handledProperties = new HashSet <MemberInfo>();
FieldDescriptorUtilities.AddExplicitFields(
Fields.Select(t => t.CreateDefinition()),
f => f.Member,
fields,
handledProperties);
OnCompleteFields(fields, handledProperties);
Definition.Fields.AddRange(fields.Values);
}
protected override void OnCreateDefinition(
FilterInputTypeDefinition definition)
{
var fields = new Dictionary <NameString, FilterOperationDefintion>();
var handledProperties = new HashSet <PropertyInfo>();
List <FilterFieldDefintion> explicitFields =
Fields.Select(t => t.CreateDefinition()).ToList();
FieldDescriptorUtilities.AddExplicitFields(
explicitFields.Where(t => !t.Ignore).SelectMany(t => t.Filters),
f => f.Operation.Property,
fields,
handledProperties);
foreach (var field in explicitFields.Where(t => t.Ignore))
{
handledProperties.Add(field.Property);
}
OnCompleteFields(fields, handledProperties);
Definition.Fields.AddRange(fields.Values);
}
protected override void OnCompleteFields(
IDictionary <NameString, ObjectFieldDefinition> fields,
ISet <MemberInfo> handledMembers)
{
HashSet <string> subscribeResolver = null;
if (Definition.Fields.IsImplicitBinding() &&
Definition.FieldBindingType is not null)
{
FieldDescriptorUtilities.AddImplicitFields(
this,
Definition.FieldBindingType,
p =>
{
var descriptor = ObjectFieldDescriptor.New(
Context, p, Definition.RuntimeType, Definition.FieldBindingType);
if (Definition.IsExtension && Context.TypeInspector.IsMemberIgnored(p))
{
descriptor.Ignore();
}
Fields.Add(descriptor);
return(descriptor.CreateDefinition());
},
fields,
handledMembers,
include: IncludeField,
includeIgnoredMembers
: Definition.IsExtension);
}
base.OnCompleteFields(fields, handledMembers);
bool IncludeField(IReadOnlyList <MemberInfo> all, MemberInfo current)
{
NameString name = Context.Naming.GetMemberName(current, MemberKind.ObjectField);
if (Fields.Any(t => t.Definition.Name.Equals(name)))
{
return(false);
}
if (subscribeResolver is null)
{
subscribeResolver = new HashSet <string>();
foreach (MemberInfo member in all)
{
HandlePossibleSubscribeMember(member);
}
}
return(!subscribeResolver.Contains(current.Name));
}
void HandlePossibleSubscribeMember(MemberInfo member)
{
if (member.IsDefined(typeof(SubscribeAttribute)))
{
if (member.GetCustomAttribute <SubscribeAttribute>() is { With : not null } attr)
{
subscribeResolver.Add(attr.With);
}
}
}
}
