private void VisitInputObjectTypeDefinition(
InputObjectTypeDefinitionNode node,
ISyntaxWriter writer)
{
WriteDescription(node.Description, writer);
VisitInputObjectTypeDefinitionBase(node, writer);
}
private static InputObjectTypeDefinitionNode AddInputFields(
InputObjectTypeDefinitionNode typeDefinition,
InputObjectTypeExtensionNode typeExtension)
{
if (typeExtension.Fields.Count == 0)
{
return(typeDefinition);
}
var fields =
new OrderedDictionary <string, InputValueDefinitionNode>();
foreach (InputValueDefinitionNode field in typeDefinition.Fields)
{
fields[field.Name.Value] = field;
}
foreach (InputValueDefinitionNode field in typeExtension.Fields)
{
// we allow an extension to override fields.
fields[field.Name.Value] = field;
}
return(typeDefinition.WithFields(fields.Values.ToList()));
}
protected override void VisitInputObjectTypeDefinition(
InputObjectTypeDefinitionNode node,
object context)
{
_types.Add(SchemaTypeReference.Create(
_inputObjectTypeFactory.Create(_bindingLookup, node)));
}
RewriteInputObjectTypeDefinition(
InputObjectTypeDefinitionNode node,
MergeContext context)
{
InputObjectTypeDefinitionNode current = node;
if (context.Extensions.TryGetValue(
current.Name.Value,
out ITypeExtensionNode extension))
{
if (extension is InputObjectTypeExtensionNode iote)
{
current = AddInputFields(current, iote);
current = AddDirectives(current, iote,
d => current.WithDirectives(d), context);
}
else
{
throw new SchemaMergeException(
current,
extension,
string.Format(
CultureInfo.InvariantCulture,
StitchingResources.AddSchemaExtensionRewriter_TypeMismatch,
node.Name.Value,
node.Kind,
extension.Kind));
}
}
return(base.RewriteInputObjectTypeDefinition(current, context));
}
public static InputObjectTypeDefinitionNode Rename(
this InputObjectTypeDefinitionNode enumTypeDefinition,
NameString newName,
IEnumerable <NameString> schemaNames)
{
return(AddSource(enumTypeDefinition, newName, schemaNames,
(n, d) => enumTypeDefinition
.WithName(n).WithDirectives(d)));
}
protected override void VisitInputObjectTypeDefinition(
InputObjectTypeDefinitionNode node,
TypeDefinitionItem context)
{
VisitName(node.Name, context);
VisitIfNotNull(node.Description, context, VisitStringValue);
VisitMany(node.Directives, context, VisitDirective);
VisitMany(node.Fields, context, VisitInputValueDefinition);
}
public static InputObjectTypeDefinitionNode Rename(
this InputObjectTypeDefinitionNode enumTypeDefinition,
NameString newName,
params NameString[] schemaNames)
{
return(Rename(
enumTypeDefinition,
newName,
(IEnumerable <NameString>)schemaNames));
}
RewriteInputObjectTypeDefinition(
InputObjectTypeDefinitionNode node,
Context context)
{
if (IsRelevant(node, context))
{
return(base.RewriteInputObjectTypeDefinition(node, context));
}
return(node);
}
private InputObjectTypeDefinitionNode RemoveFields(
InputObjectTypeDefinitionNode typeDefinition)
{
var renamedFields = new List <InputValueDefinitionNode>();
foreach (InputValueDefinitionNode field in typeDefinition.Fields)
{
if (!Field.FieldName.Equals(field.Name.Value))
{
renamedFields.Add(field);
}
}
return(typeDefinition.WithFields(renamedFields));
}
private InputObjectTypeDefinitionNode RenameFields(
InputObjectTypeDefinitionNode typeDefinition,
NameString schemaName)
{
var renamedFields = new List <InputValueDefinitionNode>();
foreach (InputValueDefinitionNode field in typeDefinition.Fields)
{
renamedFields.Add(
Field.FieldName.Equals(field.Name.Value)
? field.Rename(NewFieldName, schemaName)
: field);
}
return(typeDefinition.WithFields(renamedFields));
}
protected override void MergeTypes(
ISchemaMergeContext context,
IReadOnlyList <InputObjectTypeInfo> types,
NameString newTypeName)
{
List <InputObjectTypeDefinitionNode> definitions = types
.Select(t => t.Definition)
.ToList();
InputObjectTypeDefinitionNode definition =
definitions[0].Rename(
newTypeName,
types.Select(t => t.Schema.Name));
context.AddType(definition);
}
protected sealed override ISyntaxVisitorAction Enter(
ISyntaxNode node,
ISyntaxVisitorContext context)
{
return(node switch
{
DocumentNode n => Enter(n, context),
OperationDefinitionNode n => Enter(n, context),
VariableDefinitionNode n => Enter(n, context),
VariableNode n => Enter(n, context),
SelectionSetNode n => Enter(n, context),
FieldNode n => Enter(n, context),
ArgumentNode n => Enter(n, context),
FragmentSpreadNode n => Enter(n, context),
InlineFragmentNode n => Enter(n, context),
FragmentDefinitionNode n => Enter(n, context),
DirectiveNode n => Enter(n, context),
NamedTypeNode n => Enter(n, context),
ListTypeNode n => Enter(n, context),
NonNullTypeNode n => Enter(n, context),
ListValueNode n => Enter(n, context),
ObjectValueNode n => Enter(n, context),
ObjectFieldNode n => Enter(n, context),
IValueNode n => Enter(n, context),
SchemaDefinitionNode n => Enter(n, context),
OperationTypeDefinitionNode n => Enter(n, context),
ScalarTypeDefinitionNode n => Enter(n, context),
ObjectTypeDefinitionNode n => Enter(n, context),
FieldDefinitionNode n => Enter(n, context),
InputValueDefinitionNode n => Enter(n, context),
InterfaceTypeDefinitionNode n => Enter(n, context),
UnionTypeDefinitionNode n => Enter(n, context),
EnumTypeDefinitionNode n => Enter(n, context),
EnumValueDefinitionNode n => Enter(n, context),
InputObjectTypeDefinitionNode n => Enter(n, context),
DirectiveDefinitionNode n => Enter(n, context),
SchemaExtensionNode n => Enter(n, context),
ScalarTypeExtensionNode n => Enter(n, context),
ObjectTypeExtensionNode n => Enter(n, context),
InterfaceTypeExtensionNode n => Enter(n, context),
UnionTypeExtensionNode n => Enter(n, context),
EnumTypeExtensionNode n => Enter(n, context),
InputObjectTypeExtensionNode n => Enter(n, context),
_ => throw new NotSupportedException()
});
public new IInputObjectTypeDescriptor <T> SyntaxNode(
InputObjectTypeDefinitionNode inputObjectTypeDefinitionNode)
{
base.SyntaxNode(inputObjectTypeDefinitionNode);
return(this);
}
public IInputObjectTypeDescriptor SyntaxNode(
InputObjectTypeDefinitionNode inputObjectTypeDefinitionNode)
{
Definition.SyntaxNode = inputObjectTypeDefinitionNode;
return(this);
}
protected virtual ISyntaxVisitorAction Enter(
InputObjectTypeDefinitionNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
protected override void VisitInputObjectTypeDefinition(
InputObjectTypeDefinitionNode node)
{
_typeRegistry.RegisterType(_inputObjectTypeFactory.Create(node));
}
public ObjectType(InputObjectTypeDefinitionNode definition)
{
this.definitionInput = definition;
this.Name = definition.Name?.Value;
}
protected virtual void VisitInputObjectTypeDefinition(InputObjectTypeDefinitionNode node)
{
}
IInputObjectTypeDescriptor IInputObjectTypeDescriptor.SyntaxNode(
InputObjectTypeDefinitionNode syntaxNode)
{
SyntaxNode(syntaxNode);
return(this);
}
protected void SyntaxNode(InputObjectTypeDefinitionNode syntaxNode)
{
ObjectDescription.SyntaxNode = syntaxNode;
}
