private static void RenameObjectField(
ObjectTypeDefinitionNode objectType,
RenameFieldsContext renameContext)
{
IReadOnlyCollection <InterfaceTypeDefinitionNode> interfaceTypes =
GetInterfaceTypes(objectType, renameContext.Types);
foreach (FieldDefinitionNode fieldDefinition in
objectType.Fields)
{
NameString originalName =
fieldDefinition.GetOriginalName(renameContext.SchemaName);
if (!originalName.Equals(fieldDefinition.Name.Value))
{
foreach (InterfaceTypeDefinitionNode interfaceType in
GetInterfacesThatProvideFieldDefinition(
originalName, interfaceTypes))
{
RenameInterfaceField(interfaceType,
renameContext, originalName,
fieldDefinition.Name.Value);
}
}
}
}
protected override ObjectTypeDefinitionNode RewriteObjectTypeDefinition(
ObjectTypeDefinitionNode node,
MergeContext context)
{
ObjectTypeDefinitionNode current = node;
if (context.Extensions.TryGetValue(
current.Name.Value,
out ITypeExtensionNode extension))
{
if (extension is ObjectTypeExtensionNode objectTypeExtension)
{
current = AddInterfaces(current, objectTypeExtension);
current = AddFields(current, objectTypeExtension);
current = AddDirectives(current, objectTypeExtension,
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.RewriteObjectTypeDefinition(current, context));
}
protected override void VisitObjectTypeDefinition(
ObjectTypeDefinitionNode node,
object context)
{
_types.Add(SchemaTypeReference.Create(
_objectTypeFactory.Create(_bindingLookup, node)));
}
private static ObjectTypeDefinitionNode AddInterfaces(
ObjectTypeDefinitionNode typeDefinition,
ObjectTypeExtensionNode typeExtension)
{
if (typeExtension.Interfaces.Count == 0)
{
return(typeDefinition);
}
var interfaces = new HashSet <string>(
typeDefinition.Interfaces.Select(t => t.Name.Value));
foreach (string interfaceName in
typeExtension.Interfaces.Select(t => t.Name.Value))
{
interfaces.Add(interfaceName);
}
if (interfaces.Count == typeDefinition.Interfaces.Count)
{
return(typeDefinition);
}
return(typeDefinition.WithInterfaces(
interfaces.Select(n => new NamedTypeNode(new NameNode(n)))
.ToList()));
}
protected override void VisitObjectTypeDefinition(
ObjectTypeDefinitionNode node,
TypeDefinitionItem context)
{
var item = new TypeDefinitionItem {
Name = node.Name.ToString(), Type = TypeDefinitionType.Type
};
using (var interfaces = node.Interfaces.GetEnumerator())
{
while (interfaces.MoveNext())
{
item.InterfaceKeys.Add(interfaces.Current.Name.Value);
}
}
using (var directives = node.Directives.GetEnumerator())
{
while (directives.MoveNext())
{
item.Directives.Add(directives.Current.Name.Value);
}
}
VisitName(node.Name, context);
VisitIfNotNull(node.Description, context, VisitStringValue);
VisitMany(node.Directives, context, VisitDirective);
VisitMany(node.Interfaces, context, VisitNamedType);
VisitMany(node.Fields, item, VisitFieldDefinition);
this.VisitedItems.Add(item);
}
public static ObjectTypeDefinitionNode Rename(
this ObjectTypeDefinitionNode objectTypeDefinition,
NameString newName,
IEnumerable <NameString> schemaNames)
{
return(AddSource(objectTypeDefinition, newName, schemaNames,
(n, d) => objectTypeDefinition
.WithName(n).WithDirectives(d)));
}
public static ObjectTypeDefinitionNode Rename(
this ObjectTypeDefinitionNode objectTypeDefinition,
NameString newName,
params NameString[] schemaNames)
{
return(Rename(
objectTypeDefinition,
newName,
(IEnumerable <NameString>)schemaNames));
}
protected override ObjectTypeDefinitionNode RewriteObjectTypeDefinition(
ObjectTypeDefinitionNode node,
Context context)
{
if (IsRelevant(node, context))
{
return(base.RewriteObjectTypeDefinition(node, context));
}
return(node);
}
private static ObjectTypeDefinitionNode AddFields(
ObjectTypeDefinitionNode typeDefinition,
ObjectTypeExtensionNode typeExtension)
{
IReadOnlyList <FieldDefinitionNode> fields =
AddFields(typeDefinition.Fields, typeExtension.Fields);
return(fields == typeDefinition.Fields
? typeDefinition
: typeDefinition.WithFields(fields));
}
public bool TryGetOperationType(
ObjectTypeDefinitionNode rootType,
out OperationType operationType)
{
if (RootTypes.ContainsValue(rootType))
{
operationType = RootTypes.First(t => t.Value == rootType).Key;
return(true);
}
operationType = default;
return(false);
}
public void CreateObjectType()
{
// arrange
var scalarType = new StringType();
var parser = new Parser();
DocumentNode document = parser.Parse(
"type Simple { a: String b: [String] }");
ObjectTypeDefinitionNode objectTypeDefinition = document
.Definitions.OfType <ObjectTypeDefinitionNode>().First();
var resolverBinding = new DelegateResolverBinding(
"Simple", "a",
(c, r) => "hello");
var serviceManager = new ServiceManager();
var schemaContext = new SchemaContext(serviceManager);
schemaContext.Types.RegisterType(scalarType);
schemaContext.Resolvers.RegisterResolver(resolverBinding);
// act
var factory = new ObjectTypeFactory();
ObjectType objectType = factory.Create(objectTypeDefinition);
schemaContext.Types.RegisterType(objectType);
var initializationContext = new TypeInitializationContext(
schemaContext, error => { }, objectType, false);
((INeedsInitialization)objectType)
.RegisterDependencies(initializationContext);
schemaContext.CompleteTypes();
// assert
Assert.Equal("Simple", objectType.Name);
Assert.Equal(3, objectType.Fields.Count);
Assert.True(objectType.Fields.ContainsField("a"));
Assert.True(objectType.Fields.ContainsField("b"));
Assert.False(objectType.Fields["a"].Type.IsNonNullType());
Assert.False(objectType.Fields["a"].Type.IsListType());
Assert.True(objectType.Fields["a"].Type.IsScalarType());
Assert.Equal("String", objectType.Fields["a"].Type.TypeName());
Assert.False(objectType.Fields["b"].Type.IsNonNullType());
Assert.True(objectType.Fields["b"].Type.IsListType());
Assert.False(objectType.Fields["b"].Type.IsScalarType());
Assert.Equal("String", objectType.Fields["b"].Type.TypeName());
Assert.Equal("hello", (objectType.Fields["a"]
.Resolver(null, CancellationToken.None)));
}
public void IsSubscriptionType_False()
{
// arrange
DocumentNode schema = Parser.Default.Parse(
"type Subscription { a: String } type Abc { a: String }");
var schemaInfo = new SchemaInfo("foo", schema);
ObjectTypeDefinitionNode queryType = schema.Definitions
.OfType <ObjectTypeDefinitionNode>().Last();
var type = new ObjectTypeInfo(queryType, schemaInfo);
// act
bool isQuery = type.IsSubscriptionType();
// assert
Assert.False(isQuery);
}
public void IsQueryType_True()
{
// arrange
DocumentNode schema = Utf8GraphQLParser.Parse(
"type Query { a: String } type Abc { a: String }");
var schemaInfo = new SchemaInfo("foo", schema);
ObjectTypeDefinitionNode queryType = schema.Definitions
.OfType <ObjectTypeDefinitionNode>().First();
var type = new ObjectTypeInfo(queryType, schemaInfo);
// act
bool isQuery = type.IsQueryType();
// assert
Assert.True(isQuery);
}
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()
});
GetInterfaceTypes(
ObjectTypeDefinitionNode objectType,
IDictionary <NameString, ComplexTypeDefinitionNodeBase> types)
{
var interfaceTypes = new List <InterfaceTypeDefinitionNode>();
foreach (NamedTypeNode namedType in objectType.Interfaces)
{
if (types.TryGetValue(namedType.Name.Value,
out ComplexTypeDefinitionNodeBase ct) &&
ct is InterfaceTypeDefinitionNode it)
{
interfaceTypes.Add(it);
}
}
return(interfaceTypes);
}
public void ObjectFieldDeprecationReason()
{
// arrange
ObjectTypeDefinitionNode typeDefinition =
CreateTypeDefinition <ObjectTypeDefinitionNode>(@"
type Simple {
a: String @deprecated(reason: ""reason123"")
}");
// act
var factory = new ObjectTypeFactory();
ObjectType type = factory.Create(typeDefinition);
CompleteType(type);
// assert
Assert.True(type.Fields["a"].IsDeprecated);
Assert.Equal("reason123", type.Fields["a"].DeprecationReason);
}
protected override void MergeTypes(
ISchemaMergeContext context,
IReadOnlyList <ObjectTypeInfo> types,
NameString newTypeName)
{
List <ObjectTypeDefinitionNode> definitions = types
.Select(t => t.Definition)
.ToList();
// ? : how do we handle the interfaces correctly
var interfaces = new HashSet <string>(
definitions.SelectMany(d =>
d.Interfaces.Select(t => t.Name.Value)));
ObjectTypeDefinitionNode definition = definitions[0]
.WithInterfaces(interfaces.Select(t =>
new NamedTypeNode(new NameNode(t))).ToList())
.Rename(newTypeName, types.Select(t => t.Schema.Name));
context.AddType(definition);
}
public void Merge(
ISchemaMergeContext context,
IReadOnlyList <ITypeInfo> types)
{
if (types.Count > 0)
{
if (types[0].IsRootType)
{
var names = new HashSet <string>();
var fields = new List <FieldDefinitionNode>();
foreach (ObjectTypeInfo type in
types.OfType <ObjectTypeInfo>())
{
IntegrateFields(type.Definition, type, names, fields);
}
if (types[0].Schema.TryGetOperationType(
(ObjectTypeDefinitionNode)types[0].Definition,
out OperationType operationType))
{
var mergedRootType = new ObjectTypeDefinitionNode
(
null,
new NameNode(operationType.ToString()),
null,
Array.Empty <DirectiveNode>(),
Array.Empty <NamedTypeNode>(),
fields
);
context.AddType(mergedRootType);
}
}
else
{
_next.Invoke(context, types);
}
}
}
private static void MergeRootType(
ISchemaMergeContext context,
OperationType operation,
IEnumerable <ISchemaInfo> schemas,
MergeTypeRuleDelegate merge)
{
var types = new List <TypeInfo>();
foreach (ISchemaInfo schema in schemas)
{
ObjectTypeDefinitionNode rootType = schema.GetRootType(operation);
if (rootType is not null)
{
types.Add(new ObjectTypeInfo(rootType, schema));
}
}
if (types.Count > 0)
{
merge(context, types);
}
}
private static void IntegrateFields(
ObjectTypeDefinitionNode rootType,
ITypeInfo typeInfo,
ISet <string> names,
ICollection <FieldDefinitionNode> fields)
{
string schemaName = typeInfo.Schema.Name;
foreach (FieldDefinitionNode field in rootType.Fields)
{
FieldDefinitionNode current = field;
if (names.Add(current.Name.Value))
{
current = current.AddDelegationPath(schemaName);
}
else
{
var path = new SelectionPathComponent(
field.Name,
field.Arguments.Select(t => new ArgumentNode(
t.Name,
new ScopedVariableNode(
null,
new NameNode(ScopeNames.Arguments),
t.Name))).ToList());
var newName = new NameNode(
typeInfo.CreateUniqueName(current));
current = current.WithName(newName)
.AddDelegationPath(schemaName, path);
}
fields.Add(current);
}
}
public void CreateObjectType()
{
// arrange
ObjectTypeDefinitionNode typeDefinition =
CreateTypeDefinition <ObjectTypeDefinitionNode>(@"
type Simple { a: String b: [String] }");
var resolverBinding = new FieldResolver(
"Simple", "a",
c => Task.FromResult <object>("hello"));
// act
var factory = new ObjectTypeFactory();
ObjectType type = factory.Create(typeDefinition);
CompleteType(type,
s => s.Resolvers.RegisterResolver(resolverBinding));
// assert
Assert.Equal("Simple", type.Name);
Assert.Equal(3, type.Fields.Count);
Assert.True(type.Fields.ContainsField("a"));
Assert.False(type.Fields["a"].Type.IsNonNullType());
Assert.False(type.Fields["a"].Type.IsListType());
Assert.True(type.Fields["a"].Type.IsScalarType());
Assert.Equal("String", type.Fields["a"].Type.TypeName());
Assert.True(type.Fields.ContainsField("b"));
Assert.False(type.Fields["b"].Type.IsNonNullType());
Assert.True(type.Fields["b"].Type.IsListType());
Assert.False(type.Fields["b"].Type.IsScalarType());
Assert.Equal("String", type.Fields["b"].Type.TypeName());
Assert.Equal("hello", (type.Fields["a"]
.Resolver(null).Result));
}
protected virtual ISyntaxVisitorAction Leave(
ObjectTypeDefinitionNode node,
TContext context) =>
DefaultAction;
protected virtual void VisitObjectTypeDefinition(ObjectTypeDefinitionNode node)
{
}
private void VisitObjectTypeDefinition(ObjectTypeDefinitionNode node, ISyntaxWriter writer)
{
WriteDescription(node.Description, writer);
VisitObjectTypeDefinitionBase(node, writer);
}
public IObjectTypeDescriptor SyntaxNode(
ObjectTypeDefinitionNode objectTypeDefinition)
{
Definition.SyntaxNode = objectTypeDefinition;
return(this);
}
protected override void VisitObjectTypeDefinition(
ObjectTypeDefinitionNode node)
{
_typeRegistry.RegisterType(_objectTypeFactory.Create(node));
}
protected virtual ISyntaxVisitorAction Enter(
ObjectTypeDefinitionNode node,
ISyntaxVisitorContext context) =>
DefaultAction;
IObjectTypeDescriptor IObjectTypeDescriptor.SyntaxNode(
ObjectTypeDefinitionNode syntaxNode)
{
SyntaxNode(syntaxNode);
return(this);
}
protected void SyntaxNode(ObjectTypeDefinitionNode syntaxNode)
{
ObjectDescription.SyntaxNode = syntaxNode;
}
public ObjectType(ObjectTypeDefinitionNode definition)
{
this.definition = definition;
this.Name = definition.Name?.Value;
}
