public ExecutionContext(Schema schema, DocumentNode queryDocument, OperationDefinitionNode operation, VariableCollection variables, object rootValue, object userContext) { Schema = schema ?? throw new ArgumentNullException(nameof(schema)); QueryDocument = queryDocument ?? throw new ArgumentNullException(nameof(queryDocument)); Operation = operation ?? throw new ArgumentNullException(nameof(operation)); Variables = variables ?? throw new ArgumentNullException(nameof(variables)); RootValue = rootValue; UserContext = userContext; Fragments = new FragmentCollection(schema, queryDocument); _fieldCollector = new FieldCollector(schema, variables, Fragments); }
protected override void VisitOperationDefinition( OperationDefinitionNode operation, ImmutableStack <ISyntaxNode> path) { foreach (VariableDefinitionNode variableDefinition in operation.VariableDefinitions) { if (Schema.TryGetTypeFromAst(variableDefinition.Type, out IType type) && !type.IsInputType()) { Errors.Add(new ValidationError( "The type of variable " + $"`{variableDefinition.Variable.Name.Value}` " + "is not an input type.", variableDefinition)); } } }
public void QueryWithNonNullVariableAndDefaultWhereValueIsNull() { // arrange Schema schema = CreateSchema(); OperationDefinitionNode operation = CreateQuery( "query test($test: String! = \"foo\") { a }"); Dictionary <string, IValueNode> variableValues = new Dictionary <string, IValueNode>(); // act VariableValueBuilder resolver = new VariableValueBuilder(schema, operation); VariableCollection coercedVariableValues = resolver.CreateValues(variableValues); // assert Assert.Equal("foo", coercedVariableValues.GetVariable <string>("test")); }
public void QueryWithNonNullVariableAndDefaultWhereValueWasNotProvided() { // arrange Schema schema = CreateSchema(); OperationDefinitionNode operation = CreateQuery( "query test($test: String! = \"foo\") { a }"); var variableValues = new Dictionary <string, object> { { "test", NullValueNode.Default } }; // act var resolver = new VariableValueBuilder(schema, operation); Action action = () => resolver.CreateValues(variableValues); // assert Assert.Throws <QueryException>(action); }
protected override ISyntaxVisitorAction Leave( OperationDefinitionNode node, IDocumentValidatorContext context) { if (context.FieldSets.Count > 0) { TryMergeFieldsInSet(context, context.FieldSets[node.SelectionSet]); } if (node.SelectionSet.Selections.Count == 0) { context.Errors.Add(context.NoSelectionOnRootType( node, context.Schema.GetOperationType(node.Operation))); } return(base.Leave(node, context)); }
private DocumentNode RewriteDocument( OperationDefinitionNode operation) { var definitions = new List <IDefinitionNode>(); var variables = operation.VariableDefinitions.ToList(); variables.AddRange(_visitor.VariableDeclarations); operation = operation.WithVariableDefinitions(variables); definitions.Add(operation); foreach (var fragmentName in _visitor.TouchedFragments) { definitions.Add(_fragments[fragmentName]); } return(new DocumentNode(definitions)); }
public void MergeFieldsWithFragmentSpreads() { // arrange DocumentNode query = Parser.Default.Parse( FileResource.Open("MergeQuery.graphql")); OperationDefinitionNode operation = query.Definitions.OfType <OperationDefinitionNode>().Single(); var schema = Schema.Create( FileResource.Open("MergeSchema.graphql"), c => c.Use(next => context => Task.CompletedTask)); var fragments = new FragmentCollection(schema, query); var variables = new VariableCollection( TypeConversion.Default, new Dictionary <string, object>()); // act var collector = new FieldCollector(fragments, (f, s) => null); IReadOnlyCollection <FieldSelection> selections = collector.CollectFields(schema.QueryType, operation.SelectionSet, Path.New("foo")); // assert Assert.Collection(selections, selection => { Assert.Collection(selection.Selection.SelectionSet.Selections, selectionNode => { FragmentSpreadNode fragment = Assert.IsType <FragmentSpreadNode>( selectionNode); Assert.Equal("app", fragment.Name.Value); }, selectionNode => { FragmentSpreadNode fragment = Assert.IsType <FragmentSpreadNode>( selectionNode); Assert.Equal("parts", fragment.Name.Value); }); }); }
private void CreateClassModels( IModelGeneratorContext context, OperationDefinitionNode operation, IType fieldType, FieldNode fieldSelection, PossibleSelections possibleSelections, IFragmentNode returnType, IInterfaceDescriptor interfaceDescriptor, Path path) { var resultParserTypes = new List <ResultParserTypeDescriptor>(); IReadOnlyCollection <SelectionInfo> selections = possibleSelections.Variants; if (selections.Count == 1) { CreateClassModel( context, returnType, interfaceDescriptor, selections.Single(), resultParserTypes); } else { CreateClassModels( context, fieldSelection, returnType, interfaceDescriptor, selections, resultParserTypes, path); } context.Register( new ResultParserMethodDescriptor( GetPathName(path), operation, fieldType, fieldSelection, path, interfaceDescriptor, resultParserTypes)); }
public void FieldsAndInlineFragments() { // arrange Schema schema = CreateSchema(); DocumentNode query = Parser.Default.Parse(@" { a ... on Foo { z:a } ... on Fa { x:a } } "); VariableCollection variables = new VariableCollection( new Dictionary <string, object>()); FragmentCollection fragments = new FragmentCollection(schema, query); OperationDefinitionNode operation = query.Definitions .OfType <OperationDefinitionNode>().First(); // act FieldResolver fieldResolver = new FieldResolver(schema, variables, fragments); IReadOnlyCollection <FieldSelection> fields = fieldResolver .CollectFields(schema.GetType <ObjectType>("Foo"), operation.SelectionSet, e => { }); // assert Assert.Collection(fields, f => { Assert.Equal("a", f.ResponseName); Assert.Equal("a", f.Field.Name); Assert.Equal("String", f.Field.Type.TypeName()); }, f => { Assert.Equal("z", f.ResponseName); Assert.Equal("a", f.Field.Name); Assert.Equal("String", f.Field.Type.TypeName()); }); }
public void Fields() { // arrange var errorRaised = false; Schema schema = CreateSchema(); DocumentNode query = Parser.Default.Parse(@" { a x:c } "); var variables = new VariableCollection( TypeConversion.Default, new Dictionary <string, object>()); var fragments = new FragmentCollection(schema, query); OperationDefinitionNode operation = query.Definitions .OfType <OperationDefinitionNode>().First(); // act var fieldResolver = new FieldCollector(fragments, (f, s) => null); IReadOnlyCollection <FieldSelection> fields = fieldResolver .CollectFields( schema.GetType <ObjectType>("Foo"), operation.SelectionSet, null); // assert Assert.Collection(fields.Where(t => t.IsVisible(variables)), f => { Assert.Equal("a", f.ResponseName); Assert.Equal("a", f.Field.Name); Assert.Equal("String", f.Field.Type.TypeName()); }, f => { Assert.Equal("x", f.ResponseName); Assert.Equal("c", f.Field.Name); Assert.Equal("String", f.Field.Type.TypeName()); }); Assert.False(errorRaised); }
public void Prepare_Fragment_Definition() { // arrange ISchema schema = SchemaBuilder.New() .AddStarWarsTypes() .Create(); DocumentNode document = Utf8GraphQLParser.Parse( @"{ hero(episode: EMPIRE) { name ... abc ... def } } fragment abc on Droid { primaryFunction } fragment def on Human { homePlanet } "); OperationDefinitionNode operation = document.Definitions.OfType <OperationDefinitionNode>().Single(); var fragments = new FragmentCollection(schema, document); // act IReadOnlyDictionary <SelectionSetNode, SelectionVariants> selectionSets = OperationCompiler.Compile(schema, fragments, operation); // assert var op = new Operation( "abc", document, operation, schema.QueryType, selectionSets); op.Print().MatchSnapshot(); }
public void Object_Field_Visibility_Is_Correctly_Inherited_3() { // arrange var variables = new Mock <IVariableValueCollection>(); variables.Setup(t => t.GetVariable <bool>(It.IsAny <NameString>())) .Returns((NameString name) => name.Equals("v")); ISchema schema = SchemaBuilder.New() .AddStarWarsTypes() .Create(); ObjectType droid = schema.GetType <ObjectType>("Droid"); DocumentNode document = Utf8GraphQLParser.Parse( @"query foo($v: Boolean, $q: Boolean) { hero(episode: EMPIRE) @include(if: $v) { name @include(if: $q) } }"); OperationDefinitionNode operationDefinition = document.Definitions.OfType <OperationDefinitionNode>().Single(); // act var operation = (Operation)OperationCompiler.Compile( "a", document, operationDefinition, schema, schema.QueryType); // assert ISelectionSet rootSelections = operation.RootSelectionVariants.GetSelectionSet( operation.RootSelectionVariants.GetPossibleTypes().First()); ISelectionSet droidSelections = operation.GetSelectionSet(rootSelections.Selections[0].SelectionSet !, droid); Assert.Empty(droidSelections.Selections.Where(t => t.IsIncluded(variables.Object))); operation.Print().MatchSnapshot(); }
private ObjectType GetOperationType( Schema schema, OperationDefinitionNode operation) { switch (operation.Operation) { case OperationType.Query: return(schema.QueryType); case OperationType.Mutation: return(schema.MutationType); case OperationType.Subscription: return(schema.SubscriptionType); default: throw new NotSupportedException( "The specified operation type is not supported."); } }
public ResultParserDescriptor( string name, string ns, OperationDefinitionNode operation, ICodeDescriptor resultDescriptor, IReadOnlyList <IResultParserMethodDescriptor> parseMethods) { Name = name ?? throw new ArgumentNullException(nameof(name)); Namespace = ns ?? throw new ArgumentNullException(nameof(ns)); Operation = operation ?? throw new ArgumentNullException(nameof(operation)); ResultDescriptor = resultDescriptor ?? throw new ArgumentNullException(nameof(resultDescriptor)); ParseMethods = parseMethods ?? throw new ArgumentNullException(nameof(parseMethods)); InvolvedLeafTypes = CollectLeafTypes(parseMethods); }
public ExecutionContext(Schema schema, DocumentNode queryDocument, OperationDefinitionNode operation, VariableCollection variables, IServiceProvider services, object rootValue, object userContext) { if (schema == null) { throw new ArgumentNullException(nameof(schema)); } if (queryDocument == null) { throw new ArgumentNullException(nameof(queryDocument)); } if (operation == null) { throw new ArgumentNullException(nameof(operation)); } if (variables == null) { throw new ArgumentNullException(nameof(variables)); } if (services == null) { throw new ArgumentNullException(nameof(services)); } Schema = schema; QueryDocument = queryDocument; Operation = operation; Variables = variables; RootValue = rootValue; UserContext = userContext; _services = services; Data = new OrderedDictionary(); Fragments = new FragmentCollection(schema, queryDocument); FieldResolver = new FieldResolver(schema, variables, Fragments); Errors = new List <IQueryError>(); NextBatch = new List <FieldResolverTask>(); }
protected virtual void VisitOperationDefinition( OperationDefinitionNode operation, ImmutableStack <ISyntaxNode> path) { IType operationType = Schema.GetOperationType(operation.Operation); if (operationType != null) { ImmutableStack <ISyntaxNode> newPath = path.Push(operation); VisitSelectionSet( operation.SelectionSet, operationType, newPath); VisitDirectives(operation.Directives, newPath); } _visitedFragments.Clear(); }
public void QueryWithNonNullVariableAndDefaultWhereValueWasNotProvided() { // arrange Schema schema = CreateSchema(); OperationDefinitionNode operation = CreateQuery( "query test($test: String! = \"foo\") { a }"); Dictionary <string, IValueNode> variableValues = new Dictionary <string, IValueNode>(); variableValues.Add("test", new NullValueNode(null)); // act VariableValueResolver resolver = new VariableValueResolver(); Action action = () => resolver.CoerceVariableValues(schema, operation, variableValues); // assert Assert.Throws <QueryException>(action); }
private ICodeDescriptor GenerateOperationSelectionSet( ObjectType operationType, OperationDefinitionNode operation, Path path, Queue <FieldSelection> backlog) { PossibleSelections possibleSelections = _fieldCollector.CollectFields( operationType, operation.SelectionSet, path); EnqueueFields(backlog, possibleSelections.ReturnType.Fields, path); ICodeDescriptor resultDescriptor = _objectModelGenerator.Generate( _context, operation, operationType, new NonNullType(operationType), new FieldNode( null, new NameNode(operation.Name !.Value), null, new[] { new DirectiveNode( GeneratorDirectives.Type, new ArgumentNode("name", operation.Name.Value)), new DirectiveNode(GeneratorDirectives.Operation) }, Array.Empty <ArgumentNode>(), null), possibleSelections, path); _operationModelGenerator.Generate( _context, operationType, operation, resultDescriptor); return(resultDescriptor); }
public void QueryWithNonNullVariableAndDefaultWhereValueIsNull() { // arrange Schema schema = CreateSchema(); OperationDefinitionNode operation = CreateQuery( "query test($test: String! = \"foo\") { a }"); Dictionary <string, IValueNode> variableValues = new Dictionary <string, IValueNode>(); // act VariableValueResolver resolver = new VariableValueResolver(); Dictionary <string, object> coercedVariableValues = resolver.CoerceVariableValues(schema, operation, variableValues); // assert Assert.True(coercedVariableValues.ContainsKey("test")); Assert.IsType <string>(coercedVariableValues["test"]); Assert.Equal("foo", coercedVariableValues["test"]); }
public void FindUndeclaredVariablesInlineFragment() { // arrange ISchema schema = SchemaBuilder.New() .AddStarWarsTypes() .Create(); DocumentNode document = Utf8GraphQLParser.Parse( @" query getHero { ... on Query { hero(episode: $ep) { name } } }"); OperationDefinitionNode operation = document.Definitions .OfType <OperationDefinitionNode>() .First(); var visitor = new CollectVariablesVisitor(schema); var visitationMap = new CollectVariablesVisitationMap(); // act operation.Accept( visitor, visitationMap, node => VisitorAction.Continue); // assert var variables = operation.VariableDefinitions.ToList(); variables.AddRange(visitor.VariableDeclarations); operation = operation.WithVariableDefinitions(variables); QuerySyntaxSerializer.Serialize( new DocumentNode( new IDefinitionNode[] { operation })).MatchSnapshot(); }
protected override ISyntaxVisitorAction Leave( OperationDefinitionNode node, IDocumentValidatorContext context) { context.Unused.ExceptWith(context.Used); context.Used.ExceptWith(context.Declared); if (context.Unused.Count > 0) { context.Errors.Add(context.VariableNotUsed(node)); } if (context.Used.Count > 0) { context.Errors.Add(context.VariableNotDeclared(node)); } return(base.Leave(node, context)); }
public void QueryWithNullableVariableAndNoDefaultWhereNoValueWasProvided() { // arrange Schema schema = CreateSchema(); OperationDefinitionNode operation = CreateQuery( "query test($test: String) { a }"); var variableValues = new Dictionary <string, object>(); variableValues.Add("test", NullValueNode.Default); var resolver = new VariableValueBuilder(schema, operation); // act VariableCollection coercedVariableValues = resolver.CreateValues(variableValues); // assert Assert.Null(coercedVariableValues.GetVariable <string>("test")); }
public void InvalidFieldError() { // arrange bool errorRaised = false; Schema schema = CreateSchema(); DocumentNode query = Parser.Default.Parse(@" { a x:c xyz } "); VariableCollection variables = new VariableCollection( new Dictionary <string, object>()); FragmentCollection fragments = new FragmentCollection(schema, query); OperationDefinitionNode operation = query.Definitions .OfType <OperationDefinitionNode>().First(); // act FieldResolver fieldResolver = new FieldResolver(schema, variables, fragments); IReadOnlyCollection <FieldSelection> fields = fieldResolver .CollectFields(schema.GetType <ObjectType>("Foo"), operation.SelectionSet, e => { errorRaised = true; }); // assert Assert.Collection(fields, f => { Assert.Equal("a", f.ResponseName); Assert.Equal("a", f.Field.Name); Assert.Equal("String", f.Field.Type.TypeName()); }, f => { Assert.Equal("x", f.ResponseName); Assert.Equal("c", f.Field.Name); Assert.Equal("String", f.Field.Type.TypeName()); }); Assert.True(errorRaised); }
private static void AddVariables( IQueryRequestBuilder builder, DocumentNode query, IEnumerable <Delegation.VariableValue> variableValues) { OperationDefinitionNode operation = query.Definitions.OfType <OperationDefinitionNode>().First(); var usedVariables = new HashSet <string>( operation.VariableDefinitions.Select(t => t.Variable.Name.Value)); foreach (Delegation.VariableValue variableValue in variableValues) { if (usedVariables.Contains(variableValue.Name)) { builder.AddVariableValue(variableValue.Name, variableValue.Value); } } }
public void QueryWithNullableVariableAndNoDefaultWhereNoValueWasProvided() { // arrange Schema schema = CreateSchema(); OperationDefinitionNode operation = CreateQuery( "query test($test: String) { a }"); Dictionary <string, IValueNode> variableValues = new Dictionary <string, IValueNode>(); variableValues.Add("test", new NullValueNode(null)); // act VariableValueResolver resolver = new VariableValueResolver(); Dictionary <string, object> coercedVariableValues = resolver.CoerceVariableValues(schema, operation, variableValues); // assert Assert.True(coercedVariableValues.ContainsKey("test")); Assert.Equal(null, coercedVariableValues["test"]); }
public void Variable_InputObjectAsClrType_NonNullFieldNull() { // arrange Schema schema = CreateSchema(); OperationDefinitionNode operation = CreateQuery( "query test($test: BazInput) { a }"); var variableValues = new Dictionary <string, object> { { "test", new Baz { Bar = "bar" } } }; // act var resolver = new VariableValueBuilder(schema, operation); Action action = () => resolver.CreateValues(variableValues); // assert Assert.Throws <QueryException>(action); }
public void Variable_List_NonNullListItemNull() { // arrange Schema schema = CreateSchema(); OperationDefinitionNode operation = CreateQuery( "query test($test: [String!]) { a }"); var variableValues = new Dictionary <string, object> { { "test", new List <string> { null } } }; // act var resolver = new VariableValueBuilder(schema, operation); Action action = () => resolver.CreateValues(variableValues); // assert Assert.Throws <QueryException>(action); }
public void Prepare_Fragment_Definition() { // arrange ISchema schema = SchemaBuilder.New() .AddStarWarsTypes() .Create(); DocumentNode document = Utf8GraphQLParser.Parse( @"{ hero(episode: EMPIRE) { name ... abc ... def } } fragment abc on Droid { primaryFunction } fragment def on Human { homePlanet } "); OperationDefinitionNode operationDefinition = document.Definitions.OfType <OperationDefinitionNode>().Single(); // act IPreparedOperation operation = OperationCompiler.Compile( "a", document, operationDefinition, schema, schema.QueryType, new(new DefaultTypeConverter())); // assert operation.Print().MatchSnapshot(); }
public override ICodeDescriptor Generate( IModelGeneratorContext context, OperationDefinitionNode operation, ObjectType namedType, IType fieldType, FieldNode fieldSelection, PossibleSelections possibleSelections, Path path) { IFragmentNode returnType = ResolveReturnType( context, namedType, fieldSelection, possibleSelections.ReturnType); IInterfaceDescriptor interfaceDescriptor = CreateInterfaceModel( context, returnType, path); context.Register(fieldSelection, interfaceDescriptor); var resultParserTypes = new List <ResultParserTypeDescriptor>(); CreateClassModel( context, returnType, interfaceDescriptor, possibleSelections.ReturnType, resultParserTypes); context.Register( new ResultParserMethodDescriptor( GetPathName(path), operation, fieldType, fieldSelection, path, interfaceDescriptor, resultParserTypes)); return(interfaceDescriptor); }
public void MergeMerged() { // arrange DocumentNode query = Utf8GraphQLParser.Parse( FileResource.Open("MergeQuery.graphql")); OperationDefinitionNode operation = query.Definitions.OfType <OperationDefinitionNode>().Single(); var schema = Schema.Create( FileResource.Open("MergeSchema.graphql"), c => c.Use(next => context => Task.CompletedTask)); var fragments = new FragmentCollection(schema, query); var variables = new VariableValueCollection( TypeConversion.Default, new Dictionary <string, object>()); var collector = new FieldCollector( fragments, (f, s) => null, TypeConversion.Default, Array.Empty <IArgumentCoercionHandler>()); IReadOnlyCollection <FieldSelection> selections = collector.CollectFields(schema.QueryType, operation.SelectionSet, Path.New("foo")); // act selections = collector.CollectFields( schema.GetType <ObjectType>("Application"), selections.Single().Selection.SelectionSet, Path.New("bat")); // assert Assert.Collection(selections, selection => Assert.Equal("id", selection.ResponseName), selection => Assert.Equal("name", selection.ResponseName), selection => Assert.Equal("parts", selection.ResponseName)); }