protected override void OnCompleteType(
ITypeCompletionContext context,
InputObjectTypeDefinition definition)
{
base.OnCompleteType(context, definition);
ITypeConverter converter = context.Services.GetTypeConverter();
_objectToValueConverter = new InputObjectToObjectValueConverter(converter);
_objectToDictionary = new InputObjectToDictionaryConverter(converter);
SyntaxNode = definition.SyntaxNode;
var fields = new List <InputField>();
OnCompleteFields(context, definition, fields);
Fields = FieldCollection <InputField> .From(
fields,
context.DescriptorContext.Options.SortFieldsByName);
FieldInitHelper.CompleteFields(context, definition, Fields);
if (RuntimeType == typeof(object) || Fields.Any(t => t.Property is null))
{
_parseLiteral = ov => ParseLiteralToDictionary(this, ov, converter);
_deserialize = map => DeserializeToDictionary(this, map, converter);
}
protected override void OnRegisterDependencies(
IInitializationContext context,
InputObjectTypeDefinition definition)
{
base.OnRegisterDependencies(context, definition);
SetTypeIdentity(typeof(FilterInputType <>));
}
public static void RegisterDependencies(
this ITypeDiscoveryContext context,
InputObjectTypeDefinition definition)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (definition is null)
{
throw new ArgumentNullException(nameof(definition));
}
RegisterAdditionalDependencies(context, definition);
RegisterDirectiveDependencies(context, definition);
foreach (InputFieldDefinition field in definition.Fields)
{
RegisterAdditionalDependencies(context, field);
if (field.Type is not null)
{
context.RegisterDependency(field.Type,
TypeDependencyKind.Default);
}
context.RegisterDependencyRange(
field.GetDirectives().Select(t => t.TypeReference),
TypeDependencyKind.Completed);
}
}
public static void RegisterDependencies(
this IInitializationContext context,
InputObjectTypeDefinition definition)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (definition == null)
{
throw new ArgumentNullException(nameof(definition));
}
RegisterDirectiveDependencies(context, definition);
foreach (InputFieldDefinition field in definition.Fields)
{
if (field.Type != null)
{
context.RegisterDependency(field.Type,
TypeDependencyKind.Default);
}
context.RegisterDependencyRange(
field.Directives.Select(t => t.TypeReference),
TypeDependencyKind.Completed);
}
}
protected override void OnCompleteFields(
ITypeCompletionContext context,
InputObjectTypeDefinition definition,
ICollection <InputField> fields)
{
if (definition is FilterInputTypeDefinition {
UseAnd : true
} def)
{
fields.Add(new AndField(context.DescriptorContext, def.Scope, this));
}
if (definition is FilterInputTypeDefinition {
UseOr : true
} defOr)
{
fields.Add(new OrField(context.DescriptorContext, defOr.Scope, this));
}
foreach (InputFieldDefinition fieldDefinition in definition.Fields)
{
if (fieldDefinition is FilterOperationFieldDefinition operation)
{
fields.Add(new FilterOperationField(operation));
}
else if (fieldDefinition is FilterFieldDefinition field)
{
fields.Add(new FilterField(field));
}
}
}
protected override void OnRegisterDependencies(
ITypeDiscoveryContext context,
InputObjectTypeDefinition definition)
{
base.OnRegisterDependencies(context, definition);
context.RegisterDependencies(definition);
SetTypeIdentity(typeof(InputObjectType <>));
}
protected override void OnCompleteType(
ITypeCompletionContext context,
InputObjectTypeDefinition definition)
{
base.OnCompleteType(context, definition);
if (definition is SortInputTypeDefinition ft &&
ft.EntityType is { })
protected override void OnCompleteType(
ICompletionContext context,
InputObjectTypeDefinition definition)
{
base.OnCompleteType(context, definition);
EntityType = definition is FilterInputTypeDefinition ft
? ft.EntityType
: typeof(object);
}
protected override FieldCollection <InputField> OnCompleteFields(
ITypeCompletionContext context,
InputObjectTypeDefinition definition)
{
return(CompleteFields(
context,
this,
definition.Fields.OfType <SortOperationDefintion>(),
CreateField,
definition.Fields.Count));
protected override void OnCompleteFields(
ICompletionContext context,
InputObjectTypeDefinition definition,
ICollection <InputField> fields)
{
foreach (SortOperationDefintion fieldDefinition in
definition.Fields.OfType <SortOperationDefintion>())
{
fields.Add(new SortOperationField(fieldDefinition));
}
}
protected override void OnCompleteType(
ITypeCompletionContext context,
InputObjectTypeDefinition definition)
{
base.OnCompleteType(context, definition);
SyntaxNode = definition.SyntaxNode;
Fields = OnCompleteFields(context, definition);
_createInstance = OnCompleteCreateInstance(context, definition);
_getFieldValues = OnCompleteGetFieldValues(context, definition);
}
protected override void OnCompleteType(
ITypeCompletionContext context,
InputObjectTypeDefinition definition)
{
base.OnCompleteType(context, definition);
if (definition is SortInputTypeDefinition {
EntityType : { }
} ft)
{
EntityType = ft.EntityType;
}
}
protected override void OnRegisterDependencies(
ITypeDiscoveryContext context,
InputObjectTypeDefinition definition)
{
base.OnRegisterDependencies(context, definition);
if (definition is FilterInputTypeDefinition {
EntityType : { }
} filterDefinition)
{
SetTypeIdentity(typeof(FilterInputType <>)
.MakeGenericType(filterDefinition.EntityType));
}
}
public IEnumerable <ITypeDeclaration> GetTypeDeclarations()
{
return(document.Children.Concat(options.ScalarTypes).Select(def => def switch
{
ObjectTypeDefinition objectTypeDefinition => new ObjectTypeContext(objectTypeDefinition, options, document) as ITypeDeclaration,
InputObjectTypeDefinition inputObjectTypeDefinition => new InputObjectTypeContext(inputObjectTypeDefinition, options, document) as ITypeDeclaration,
InterfaceTypeDefinition interfaceTypeDefinition => new InterfaceTypeContext(interfaceTypeDefinition, options, document) as ITypeDeclaration,
EnumTypeDefinition enumTypeDefinition => new EnumTypeContext(enumTypeDefinition, options, document) as ITypeDeclaration,
UnionTypeDefinition unionTypeDefinition => new UnionTypeContext(unionTypeDefinition, options) as ITypeDeclaration,
ScalarTypeDefinition scalarTypeDefinition => new ScalarTypeContext(scalarTypeDefinition, options) as ITypeDeclaration,
SchemaDefinition _ => null,
_ => throw new InvalidOperationException("Unhandled definition type " + def.Kind.ToString("g"))
})
protected override void OnCompleteFields(
ICompletionContext context,
InputObjectTypeDefinition definition,
ICollection <InputField> fields)
{
fields.Add(new AndField(context.DescriptorContext, this));
fields.Add(new OrField(context.DescriptorContext, this));
foreach (FilterOperationDefintion fieldDefinition in
definition.Fields.OfType <FilterOperationDefintion>())
{
fields.Add(new FilterOperationField(fieldDefinition));
}
}
public InputObjectTypeExtension Create(IDescriptorContext context, InputObjectTypeExtensionNode node)
{
var preserveSyntaxNodes = context.Options.PreserveSyntaxNodes;
var typeDefinition = new InputObjectTypeDefinition(node.Name.Value);
typeDefinition.BindTo = node.GetBindingValue();
SdlToTypeSystemHelper.AddDirectives(typeDefinition, node);
DeclareFields(typeDefinition, node.Fields, preserveSyntaxNodes);
return(InputObjectTypeExtension.CreateUnsafe(typeDefinition));
}
public static void RegisterDependencies(
this ITypeDiscoveryContext context,
InputObjectTypeDefinition definition)
{
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
if (definition is null)
{
throw new ArgumentNullException(nameof(definition));
}
CollectDependencies(definition, context.Dependencies);
}
private static void HandleInputObjectType(
ITypeCompletionContext completionContext,
InputObjectTypeDefinition definition,
ISpatialConvention convention)
{
foreach (var field in definition.Fields)
{
if (completionContext.IsNamedType <IGeoJsonInputType>(field.Type))
{
field.Formatters.Add(
new GeometryTransformerInputFormatter(
convention.TransformerFactory,
convention.DefaultSrid));
}
}
}
public void Field_Ignore_PropertyIsExcluded()
{
// arrange
var descriptor =
InputObjectTypeDescriptor.New <SimpleInput>(Context);
// act
descriptor.Field(t => t.Id).Ignore();
// assert
InputObjectTypeDefinition description =
descriptor.CreateDefinition();
Assert.Collection(description.Fields,
t => Assert.Equal("name", t.Name));
}
public static void CollectDependencies(
InputObjectTypeDefinition definition,
ICollection <TypeDependency> dependencies)
{
if (definition is null)
{
throw new ArgumentNullException(nameof(definition));
}
if (dependencies is null)
{
throw new ArgumentNullException(nameof(dependencies));
}
if (definition.HasDependencies)
{
foreach (TypeDependency dependency in definition.Dependencies)
{
dependencies.Add(dependency);
}
}
foreach (InputFieldDefinition field in definition.Fields)
{
if (field.HasDependencies)
{
foreach (TypeDependency dependency in field.Dependencies)
{
dependencies.Add(dependency);
}
}
if (field.Type is not null)
{
dependencies.Add(new(field.Type, GetDefaultValueDependencyKind(field)));
}
CollectDirectiveDependencies(field, dependencies);
}
CollectDirectiveDependencies(definition, dependencies);
}
private static void DeclareFields(
InputObjectTypeDefinition parent,
IReadOnlyCollection <InputValueDefinitionNode> fields,
bool preserveSyntaxNodes)
{
foreach (InputValueDefinitionNode inputField in fields)
{
var inputFieldDefinition = new InputFieldDefinition(
inputField.Name.Value,
inputField.Description?.Value,
TypeReference.Create(inputField.Type),
inputField.DefaultValue);
inputFieldDefinition.BindTo = inputField.GetBindingValue();
if (preserveSyntaxNodes)
{
inputFieldDefinition.SyntaxNode = inputField;
}
SdlToTypeSystemHelper.AddDirectives(inputFieldDefinition, inputField);
parent.Fields.Add(inputFieldDefinition);
}
}
protected internal InputObjectTypeDescriptor(
IDescriptorContext context,
InputObjectTypeDefinition definition)
: base(context, definition)
{
}
protected virtual FieldCollection <InputField> OnCompleteFields(
ITypeCompletionContext context,
InputObjectTypeDefinition definition)
{
return(CompleteFields(context, this, definition.Fields, CreateField));
protected override Action <object, object?[]> OnCompleteGetFieldValues(
ITypeCompletionContext context,
InputObjectTypeDefinition definition)
=> GetFieldData;
protected override Func <object?[], object> OnCompleteCreateInstance(
ITypeCompletionContext context,
InputObjectTypeDefinition definition)
=> CreateInstance;
private static void Annotate(InputObjectTypeDefinition inputTypeDefinition)
{
inputTypeDefinition.ContextData.Add(ValidateAttribute.ValidateContextDataKey, true);
}
protected override void OnCreateDefinition(InputObjectTypeDefinition definition)
{
Fields.AddRange(Filters.SelectMany(x => x.Filters.Values));
base.OnCreateDefinition(definition);
}
protected internal void CopyTo(InputObjectTypeDefinition target)
{
base.CopyTo(target);
if (Fields is { Count : > 0 })
public InputObjectTypeContext(InputObjectTypeDefinition declaration, GraphQLGenerationOptions options, Document document)
{
this.declaration = declaration;
this.options = options;
this.document = document;
}
