public DocumentNode AddExtensions( DocumentNode schema, DocumentNode extensions) { if (schema == null) { throw new ArgumentNullException(nameof(schema)); } if (extensions == null) { throw new ArgumentNullException(nameof(extensions)); } var newTypes = extensions.Definitions.OfType <ITypeDefinitionNode>().ToList(); var newDirectives = extensions.Definitions.OfType <DirectiveDefinitionNode>().ToList(); DocumentNode current = schema; if (newTypes.Count > 0 || newDirectives.Count > 0) { current = RemoveDirectives(current, newDirectives.Select(t => t.Name.Value)); current = RemoveTypes(current, newTypes.Select(t => t.Name.Value)); var definitions = schema.Definitions.ToList(); definitions.AddRange(newTypes); definitions.AddRange(newDirectives); current = current.WithDefinitions(definitions); } var context = new MergeContext(current, extensions); current = RewriteDocument(current, context); if (context.Extensions.Count > 0) { var definitions = current.Definitions.ToList(); foreach (string notProcessed in context.Extensions.Keys.Except( current.Definitions.OfType <ITypeDefinitionNode>().Select(t => t.Name.Value))) { definitions.Add(context.Extensions[notProcessed]); } return(current.WithDefinitions(definitions)); } return(current); }
private DocumentNode RewriteTypes( ISchemaInfo schema, DocumentNode document) { if (_typeRewriters.Count == 0) { return(document); } var definitions = new List <IDefinitionNode>(); foreach (IDefinitionNode definition in document.Definitions) { if (definition is ITypeDefinitionNode typeDefinition) { foreach (ITypeRewriter rewriter in _typeRewriters) { typeDefinition = rewriter.Rewrite( schema, typeDefinition); } definitions.Add(typeDefinition); } else { definitions.Add(definition); } } return(document.WithDefinitions(definitions)); }
/// <summary> /// Renames files when neccessary. /// </summary> /// <param name="schema"></param> /// <param name="definitionSchema"></param> /// <returns></returns> private DocumentNode RewriteDocument(ISchemaInfo schema, DocumentNode definitionSchema) { var definitions = new List <IDefinitionNode>(); var schemaName = schema.Name.Value; if (schemaName.Contains("api")) { schemaName = schemaName.Substring(0, schemaName.Length - 3); } else if (schemaName.Contains("service")) { schemaName = schemaName.Substring(0, schemaName.Length - 7); } foreach (var definition in definitionSchema.Definitions) { if (definition is ObjectTypeDefinitionNode typeDefinition) { if (!(typeDefinition.Name.Value.ToLower().Contains(schemaName))) { definitions.Add(typeDefinition.WithName(new NameNode(schemaName + "_" + typeDefinition.Name.Value))); continue; } } definitions.Add(definition); } return(definitionSchema.WithDefinitions(definitions)); }
private static DocumentNode CreateIntrospectionQuery( SchemaFeatures features) { DocumentNode query = Parser.Default.Parse( GetIntrospectionQuery(_phase2)); OperationDefinitionNode operation = query.Definitions.OfType <OperationDefinitionNode>().First(); FieldNode schema = operation.SelectionSet.Selections.OfType <FieldNode>().First(); FieldNode directives = schema.SelectionSet.Selections.OfType <FieldNode>().First(t => t.Name.Value.Equals(_directivesField , StringComparison.Ordinal)); var selections = directives.SelectionSet.Selections.ToList(); if (features.HasDirectiveLocations) { selections.Add(CreateField(_locations)); } else { selections.Add(CreateField(_onField)); selections.Add(CreateField(_onFragment)); selections.Add(CreateField(_onOperation)); } if (features.HasRepeatableDirectives) { selections.Add(CreateField(_isRepeatable)); } FieldNode newField = directives.WithSelectionSet( directives.SelectionSet.WithSelections(selections)); selections = schema.SelectionSet.Selections.ToList(); selections.Remove(directives); selections.Add(newField); newField = schema.WithSelectionSet( schema.SelectionSet.WithSelections(selections)); selections = operation.SelectionSet.Selections.ToList(); selections.Remove(schema); selections.Add(newField); OperationDefinitionNode newOp = operation.WithSelectionSet( operation.SelectionSet.WithSelections(selections)); var definitions = query.Definitions.ToList(); definitions.Remove(operation); definitions.Insert(0, newOp); return(query.WithDefinitions(definitions)); }
private static DocumentNode CreateIntrospectionQueryDocument(ISchemaFeatures features) { DocumentNode query = Utf8GraphQLParser.Parse(GetIntrospectionQuery()); OperationDefinitionNode operation = query.Definitions.OfType <OperationDefinitionNode>().First(); FieldNode schema = operation.SelectionSet.Selections.OfType <FieldNode>().First(); if (schema.SelectionSet is null) { throw new IntrospectionException(); } FieldNode directives = schema.SelectionSet.Selections.OfType <FieldNode>().First(t => t.Name.Value.Equals(_directivesField, StringComparison.Ordinal)); if (directives.SelectionSet is null) { throw new IntrospectionException(); } var selections = directives.SelectionSet.Selections.ToList(); AddDirectiveFeatures(features, selections); FieldNode newField = directives.WithSelectionSet( directives.SelectionSet.WithSelections(selections)); selections = schema.SelectionSet.Selections.ToList(); RemoveSubscriptionIfNotSupported(features, selections); selections.Remove(directives); selections.Add(newField); newField = schema.WithSelectionSet( schema.SelectionSet.WithSelections(selections)); selections = operation.SelectionSet.Selections.ToList(); selections.Remove(schema); selections.Add(newField); OperationDefinitionNode newOp = operation.WithSelectionSet( operation.SelectionSet.WithSelections(selections)); var definitions = query.Definitions.ToList(); definitions.Remove(operation); definitions.Insert(0, newOp); return(query.WithDefinitions(definitions)); }
public ClientGenerator AddSchemaDocument( string name, DocumentNode document) { if (name is null) { throw new ArgumentNullException(nameof(name)); } if (document is null) { throw new ArgumentNullException(nameof(document)); } if (_clientName is null) { _clientName = name + "Client"; } var extensions = new HashSet <IDefinitionNode>( document.Definitions.OfType <ITypeExtensionNode>()); if (extensions.Count == 0) { _schemas.Add(name, document); return(this); } var types = extensions.Except(document.Definitions).ToList(); if (types.Count > 0) { _schemas.Add(name, document.WithDefinitions(types)); } _extensions.Add(document.WithDefinitions(extensions.ToList())); return(this); }
public void Duplicate_Fragment() { // arrange DocumentNode query1 = Parse(Open("simple.query1.graphql")); DocumentNode query2 = query1.WithDefinitions(query1.Definitions.Skip(2).ToArray()); List <DocumentNode> queries = new() { query1, query2 }; // act void Error() => CreateOperationDocuments(queries); // assert Assert.Throws <CodeGeneratorException>(Error).Message.MatchSnapshot(); }
public DocumentNode Rewrite(ISchemaInfo schema, DocumentNode document) { if (SchemaName.HasValue && !SchemaName.Value.Equals(schema.Name)) { return(document); } var definitions = new List <IDefinitionNode>(document.Definitions); RemoveType(definitions, schema.QueryType?.Name.Value); RemoveType(definitions, schema.MutationType?.Name.Value); RemoveType(definitions, schema.SubscriptionType?.Name.Value); return(document.WithDefinitions(definitions)); }
private static DocumentNode RemoveDefinitions( DocumentNode document, Func <DocumentNode, Dictionary <string, IDefinitionNode> > toDict, IEnumerable <string> names) { List <IDefinitionNode> definitions = document.Definitions.ToList(); Dictionary <string, IDefinitionNode> directives = toDict(document); foreach (string name in names) { if (directives.TryGetValue(name, out IDefinitionNode directive)) { definitions.Remove(directive); } } return(document.WithDefinitions(definitions)); }
public DocumentNode Rewrite(ISchemaInfo schema, DocumentNode document) { if (SchemaName.HasValue && !SchemaName.Value.Equals(schema.Name)) { return(document); } ITypeDefinitionNode?typeDefinition = document.Definitions .OfType <ITypeDefinitionNode>() .FirstOrDefault(t => TypeName.Equals(t.GetOriginalName(schema.Name))); if (typeDefinition is null) { return(document); } var definitions = new List <IDefinitionNode>(document.Definitions); definitions.Remove(typeDefinition); return(document.WithDefinitions(definitions)); }
public void DuplicatesWillBeIgnoredOnFieldMerging() { // arrange ISchema schema = SchemaBuilder.New() .AddStarWarsTypes() .Create(); DocumentNode document = Utf8GraphQLParser.Parse( FileResource.Open("InvalidIntrospectionQuery.graphql")); var originalOperation = ((OperationDefinitionNode)document.Definitions[0]); OperationDefinitionNode operationWithDuplicates = originalOperation.WithSelectionSet( originalOperation.SelectionSet.WithSelections( new List <ISelectionNode> { originalOperation.SelectionSet.Selections[0], originalOperation.SelectionSet.Selections[0] })); document = document.WithDefinitions( new List <IDefinitionNode>(document.Definitions.Skip(1)) { operationWithDuplicates }); ServiceProvider services = new ServiceCollection() .AddValidation() .Services .BuildServiceProvider(); IDocumentValidatorFactory factory = services.GetRequiredService <IDocumentValidatorFactory>(); IDocumentValidator validator = factory.CreateValidator(); // act DocumentValidatorResult result = validator.Validate(schema, document); // assert Assert.False(result.HasErrors); }
private static DocumentNode PrepareSchemaDocument( DocumentNode document, NameString schemaName) { var definitions = new List <IDefinitionNode>(); foreach (IDefinitionNode definition in document.Definitions) { if (definition is ITypeDefinitionNode typeDefinition) { if (!IsIntrospectionType(typeDefinition)) { definitions.Add(typeDefinition.Rename( typeDefinition.Name.Value, schemaName)); } } else { definitions.Add(definition); } } return(document.WithDefinitions(definitions)); }