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; }