private static bool HasSameShape(
FieldDefinitionNode left,
FieldDefinitionNode right)
{
if (left.Name.Value.Equals(
right.Name.Value,
StringComparison.Ordinal) &&
HasSameType(left.Type, right.Type) &&
left.Arguments.Count == right.Arguments.Count)
{
Dictionary <string, InputValueDefinitionNode> leftArgs =
left.Arguments.ToDictionary(t => t.Name.Value);
Dictionary <string, InputValueDefinitionNode> rightArgs =
right.Arguments.ToDictionary(t => t.Name.Value);
foreach (string name in leftArgs.Keys)
{
InputValueDefinitionNode leftArgument = leftArgs[name];
if (!rightArgs.TryGetValue(name,
out InputValueDefinitionNode rightArgument) ||
!HasSameType(leftArgument.Type, rightArgument.Type))
{
return(false);
}
}
return(true);
}
return(false);
}
protected override FieldDefinitionNode RewriteFieldDefinition(
FieldDefinitionNode node,
object context)
{
if (node.Type.NamedType().Name.Value.EndsWith("Connection") &&
node.Arguments.Any(t => t.Name.Value.EqualsOrdinal("first") &&
t.Type.NamedType().Name.Value.EqualsOrdinal("Int")))
{
var arguments = node.Arguments.ToList();
InputValueDefinitionNode first =
arguments.First(t => t.Name.Value.EqualsOrdinal("first"));
InputValueDefinitionNode last =
arguments.First(t => t.Name.Value.EqualsOrdinal("last"));
arguments[arguments.IndexOf(first)] =
first.WithType(RewriteType(first.Type, "PaginationAmount"));
arguments[arguments.IndexOf(last)] =
last.WithType(RewriteType(first.Type, "PaginationAmount"));
node = node.WithArguments(arguments);
}
return(base.RewriteFieldDefinition(node, context));
}
public static InputValueDefinitionNode Rename(
this InputValueDefinitionNode enumTypeDefinition,
NameString newName,
IEnumerable <NameString> schemaNames)
{
return(AddSource(enumTypeDefinition, newName, schemaNames,
(n, d) => enumTypeDefinition
.WithName(n).WithDirectives(d)));
}
private void VisitInputValueDefinition(
InputValueDefinitionNode node,
ISyntaxWriter writer)
{
writer.WriteIndent(_indented);
WriteDescription(node.Description, writer);
WriteInputValueDefinition(node, writer);
}
public static InputValueDefinitionNode Rename(
this InputValueDefinitionNode enumTypeDefinition,
NameString newName,
params NameString[] schemaNames)
{
return(Rename(
enumTypeDefinition,
newName,
(IEnumerable <NameString>)schemaNames));
}
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 static bool HasSameArguments(
IReadOnlyList <InputValueDefinitionNode> left,
IReadOnlyList <InputValueDefinitionNode> right)
{
var leftArgs = left.ToDictionary(t => t.Name.Value);
var rightArgs = right.ToDictionary(t => t.Name.Value);
foreach (string name in leftArgs.Keys)
{
InputValueDefinitionNode leftArgument = leftArgs[name];
if (!rightArgs.TryGetValue(name,
out InputValueDefinitionNode rightArgument) ||
!HasSameType(leftArgument.Type, rightArgument.Type))
{
return(false);
}
}
return(true);
}
protected virtual ISyntaxVisitorAction Leave(
InputValueDefinitionNode node,
TContext context) =>
DefaultAction;
IInputFieldDescriptor IInputFieldDescriptor.SyntaxNode(
InputValueDefinitionNode syntaxNode)
{
SyntaxNode(syntaxNode);
return(this);
}
private void VisitArgumentValueDefinition(
InputValueDefinitionNode node,
ISyntaxWriter writer)
{
if (node.Description is { })
protected virtual void VisitInputValueDefinition(InputValueDefinitionNode node)
{
}
protected virtual ISyntaxVisitorAction Enter(
InputValueDefinitionNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
public Field(InputValueDefinitionNode definitionInput)
{
this.definitionInput = definitionInput;
this.Name = definitionInput.Name?.Value;
this.Arguments = Enumerable.Empty <Argument>();
}
public void SyntaxNode(InputValueDefinitionNode syntaxNode)
{
InputDescription.SyntaxNode = syntaxNode;
}
public new IDirectiveArgumentDescriptor SyntaxNode(
InputValueDefinitionNode inputValueDefinition)
{
base.SyntaxNode(inputValueDefinition);
return(this);
}
IDirectiveArgumentDescriptor IDirectiveArgumentDescriptor.SyntaxNode(
InputValueDefinitionNode syntaxNode)
{
SyntaxNode(syntaxNode);
return(this);
}
public Argument(InputValueDefinitionNode definition)
{
this.definition = definition;
this.Name = definition.Name.Value;
}
protected void SyntaxNode(InputValueDefinitionNode syntaxNode)
{
InputDescription.SyntaxNode = syntaxNode;
}
protected void SyntaxNode(InputValueDefinitionNode inputValueDefinition)
{
Definition.SyntaxNode = inputValueDefinition;
}
public new IFilterOperationFieldDescriptor SyntaxNode(
InputValueDefinitionNode inputValueDefinition)
{
base.SyntaxNode(inputValueDefinition);
return(this);
}
IArgumentDescriptor IArgumentDescriptor.SyntaxNode(
InputValueDefinitionNode syntaxNode)
{
SyntaxNode = syntaxNode;
return(this);
}
