private string PrintOperationDefinition(GraphQLOperationDefinition definition) { var name = PrintName(definition.Name); var directives = Join(definition.Directives?.Select(this.PrintDirective), " "); var selectionSet = this.PrintSelectionSet(definition.SelectionSet); var variableDefinitions = Wrap( "(", this.Join(definition.VariableDefinitions?.Select(this.PrintVariableDefinition), ", "), ")"); var operation = definition.Operation .ToString() .ToLower(); var variables = string.IsNullOrWhiteSpace(name) ? variableDefinitions : this.Join(new[] { name, variableDefinitions }); return(this.Join( new[] { operation, variables, directives, selectionSet }, " ")); }
internal static void Operation(this ILogger logger, GraphQLOperationDefinition operation) { OperationAction( logger, operation.Operation.ToString().ToLowerInvariant(), operation.Name?.Value, null); }
private static async Task <ExecutionResult> ExecuteSubscriptionEventAsync( IExecutorContext context, GraphQLOperationDefinition subscription, Dictionary <string, object> coercedVariableValues, object evnt, Func <Exception, Error> formatError) { var subscriptionType = context.Schema.Subscription; var selectionSet = subscription.SelectionSet; var path = new NodePath(); var data = await SelectionSets.ExecuteSelectionSetAsync( context, selectionSet, subscriptionType, evnt, coercedVariableValues, path).ConfigureAwait(false); var result = new ExecutionResult { Errors = context.FieldErrors.Select(formatError).ToList(), Data = data }; return(result); }
public static IReadOnlyDictionary <string, object> CoerceVariableValues( ISchema schema, GraphQLOperationDefinition operation, Dictionary <string, object> variableValues) { var coercedValues = new Dictionary <string, object>(); var variableDefinitions = operation.VariableDefinitions; if (variableDefinitions == null) { return(coercedValues); } foreach (var variableDefinition in variableDefinitions) { var variableName = variableDefinition.Variable.Name.Value; var variableType = Ast.TypeFromAst(schema, variableDefinition.Type); // should be assert? if (!TypeIs.IsInputType(variableType)) { throw new VariableException($"Variable is not of input type", variableName, variableType); } var defaultValue = variableDefinition.DefaultValue; var hasValue = variableValues.ContainsKey(variableName); var value = variableValues[variableName]; if (!hasValue && defaultValue != null) { coercedValues[variableName] = defaultValue; } if (variableType is NonNull && (!hasValue || value == null)) { throw new ValueCoercionException( $"Variable {variableName} type is non-nullable but value is null or not set", value, variableType); } if (hasValue) { if (value == null) { coercedValues[variableName] = null; } else { coercedValues[variableName] = Values.CoerceValue( schema.GetInputFields, value, variableType); } } } return(coercedValues); }
/// <summary> /// Builds a <see cref="ExecutionContext"/> instance from the provided values. /// </summary> protected virtual ExecutionContext BuildExecutionContext(ExecutionOptions options, GraphQLDocument document, GraphQLOperationDefinition operation, Variables variables, Metrics metrics) { var context = new ExecutionContext { Document = document, Schema = options.Schema !, RootValue = options.Root, UserContext = options.UserContext, Operation = operation, Variables = variables, Errors = new ExecutionErrors(), InputExtensions = options.Extensions ?? Inputs.Empty, OutputExtensions = new Dictionary <string, object?>(), CancellationToken = options.CancellationToken, Metrics = metrics, Listeners = options.Listeners, ThrowOnUnhandledException = options.ThrowOnUnhandledException, UnhandledExceptionDelegate = options.UnhandledExceptionDelegate, MaxParallelExecutionCount = options.MaxParallelExecutionCount, RequestServices = options.RequestServices, }; context.ExecutionStrategy = SelectExecutionStrategy(context); return(context); }
private bool ShouldBeSkipped(GraphQLOperationDefinition actualOperation, ValidationContext context) { if (context.Document.OperationsCount() <= 1) { return(false); } int i = 0; do { var ancestor = context.TypeInfo.GetAncestor(i++); if (ancestor == actualOperation) { return(false); } if (ancestor == context.Document) { return(true); } if (ancestor is GraphQLFragmentDefinition fragment) { //TODO: may be rewritten completely later var c = new FragmentBelongsToOperationVisitorContext(fragment); _visitor.VisitAsync(actualOperation, c).GetAwaiter().GetResult(); // TODO: need to think of something to avoid this return(!c.Found); } } while (true); }
public async Task <ExpandoObject> ComposeResultForSubscriptions( GraphQLComplexType type, GraphQLOperationDefinition operationDefinition) { if (string.IsNullOrWhiteSpace(this.clientId)) { throw new GraphQLException( "Can't invoke subscription without clientId specified", new ASTNode[] { operationDefinition }); } if (!this.subscriptionId.HasValue) { throw new GraphQLException( "Can't invoke subscription without subscriptionId specified", new ASTNode[] { operationDefinition }); } var context = this.CreateExecutionContext(operationDefinition); var scope = new FieldScope(context, type, null); return(await this.ProcessSubscription( (GraphQLSubscriptionType)type, context.FieldCollector, scope)); }
private string PrintOperationDefinition(GraphQLOperationDefinition definition) { var name = PrintName(definition.Name); var directives = Join(definition.Directives?.Select(PrintDirective), " "); var selectionSet = PrintSelectionSet(definition.SelectionSet); var variableDefinitions = Wrap( "(", Join(definition.VariableDefinitions?.Select(PrintVariableDefinition), ", "), ")"); var operation = definition.Operation .ToString() .ToLower(); return(string.IsNullOrWhiteSpace(name) && string.IsNullOrWhiteSpace(name) && string.IsNullOrWhiteSpace(name) && definition.Operation == OperationType.Query ? selectionSet : Join( new[] { operation, Join(new[] { name, variableDefinitions }), directives, selectionSet }, " ")); }
public Operation(GraphQLOperationDefinition op) { this.operation = op; Name = op.Name?.Value; Selection = new SetSelection(operation.SelectionSet); }
public static IEnumerable <VariableUsage> Get( GraphQLOperationDefinition operation, GraphQLDocument document, IGraphQLSchema schema) { var visitor = new VariableUsagesProvider(GetFragmentsFromDocument(document), schema); visitor.BeginVisitOperationDefinition(operation); return(visitor.variableUsages); }
public override GraphQLOperationDefinition BeginVisitOperationDefinition( GraphQLOperationDefinition definition) { { Tracker.EnterOperationDefinition?.Invoke(definition); } return(base.BeginVisitOperationDefinition(definition)); }
public override GraphQLOperationDefinition BeginVisitOperationDefinition(GraphQLOperationDefinition definition) { if (definition.Name == null && this.operationCount > 1) { this.Errors.Add(new GraphQLException("This anonymous operation must be the only defined operation.", new[] { definition })); } return(definition); }
public override GraphQLOperationDefinition EndVisitOperationDefinition( GraphQLOperationDefinition definition) { { Tracker.LeaveOperationDefinition?.Invoke(definition); } return(base.EndVisitOperationDefinition(definition)); }
private void VerifyUsage(GraphQLOperationDefinition operation, VariableUsage usage, string opName) { var variableName = usage.Variable.Name.Value; if (!this.variableDefinitions.Contains(variableName)) { this.Errors.Add(new GraphQLException(this.ComposeUndefinedVarMessage(variableName, opName), new ASTNode[] { usage.Variable, operation })); } }
public void Deconstruct(out ISchema schema, out GraphQLDocument document, out GraphQLOperationDefinition operation, out object initialValue, out Dictionary <string, object> coercedVariableValues) { schema = Schema; document = Document; operation = OperationDefinition; initialValue = InitialValue; coercedVariableValues = CoercedVariableValues; }
public virtual GraphQLOperationDefinition BeginVisitOperationDefinition(GraphQLOperationDefinition definition) { if (definition.Name != null) { this.BeginVisitNode(definition.Name); } this.BeginVisitNode(definition.SelectionSet); return(definition); }
private static Operation Operation(GraphQLOperationDefinition source) { return(new Operation(Name(source.Name), SelectionSet(source.SelectionSet)) { SourceLocation = Convert(source.Location), CommentNode = Comment(source.Comment), OperationType = ToOperationType(source.Operation), Variables = VariableDefinitions(source.VariableDefinitions), Directives = Directives(source.Directives) }); }
public override GraphQLOperationDefinition EndVisitOperationDefinition(GraphQLOperationDefinition definition) { var variableUsages = VariableUsagesProvider.Get(definition, this.document, this.Schema); foreach (var usage in variableUsages) { this.VerifyUsage(usage); } return(base.EndVisitOperationDefinition(definition)); }
public Operation Operation(GraphQLOperationDefinition source) { var name = source.Name != null?Name(source.Name) : null; var op = new Operation(name).WithLocation(source, _body); op.OperationType = ToOperationType(source.Operation); op.SelectionSet = SelectionSet(source.SelectionSet); op.Variables = VariableDefinitions(source.VariableDefinitions); op.Directives = Directives(source.Directives); return(op); }
private void ResolveOperationDefinition(GraphQLOperationDefinition graphQLOperationDefinition) { if (this.operation != null) { throw new Exception("Must provide operation name if query contains multiple operations."); } if (this.operation == null) { this.operation = graphQLOperationDefinition; } }
public override GraphQLOperationDefinition BeginVisitOperationDefinition(GraphQLOperationDefinition definition) { if (definition.Operation == OperationType.Subscription) { if (definition.SelectionSet?.Selections?.Count() != 1) { this.Errors.Add(new GraphQLException( this.SingleFieldOnlyMessage(definition.Name?.Value), definition.SelectionSet.Selections.Skip(1).ToArray())); } } return(definition); }
public BenchmarkInfo(string query, string inputs, Func <ISchema> schemaBuilder) { // this exercises all the code in case of any errors, in addition to prep for each stage of testing SchemaBuilder = schemaBuilder; Schema = BuildSchema(); Query = query; Document = Parse(); Operation = Document.Definitions.OfType <GraphQLOperationDefinition>().FirstOrDefault(); InputsString = inputs; Inputs = DeserializeInputs(); Variables = ParseVariables(); ExecutionResult = Execute(); _ = Serialize(); }
public override GraphQLOperationDefinition BeginVisitOperationDefinition(GraphQLOperationDefinition definition) { switch (definition.Operation) { case OperationType.Query: this.typeStack.Push(this.Schema.QueryType); break; default: throw new NotImplementedException(); } definition = base.BeginVisitOperationDefinition(definition); this.typeStack.Pop(); return(definition); }
public virtual GraphQLOperationDefinition BeginVisitOperationDefinition( GraphQLOperationDefinition definition) { if (definition.Name != null) { BeginVisitNode(definition.Name); } if (definition.VariableDefinitions != null) { BeginVisitVariableDefinitions(definition.VariableDefinitions); } BeginVisitNode(definition.SelectionSet); return(EndVisitOperationDefinition(definition)); }
public ExecutionResult Execute() { var context = new Execution.ExecutionContext { Document = Document, Schema = Schema, RootValue = null, UserContext = new Dictionary <string, object>(), Operation = Operation, Variables = Variables, Errors = new ExecutionErrors(), InputExtensions = Inputs.Empty, OutputExtensions = new Dictionary <string, object>(), CancellationToken = default,
private void ResolveOperationDefinition(GraphQLOperationDefinition graphQLOperationDefinition, string operationToExecute) { if (this.Operation != null && string.IsNullOrWhiteSpace(operationToExecute)) { throw new GraphQLException("Must provide operation name if query contains multiple operations."); } if (!string.IsNullOrWhiteSpace(operationToExecute) && graphQLOperationDefinition.Name.Value == operationToExecute) { this.Operation = graphQLOperationDefinition; } else if (string.IsNullOrWhiteSpace(operationToExecute) && this.Operation == null) { this.Operation = graphQLOperationDefinition; } }
private ExecutionContext CreateExecutionContext(GraphQLOperationDefinition operationDefinition) { var variableResolver = this.CreateVariableResolver(); var fieldCollector = new FieldCollector( this.fragments, this.graphQLSchema.SchemaRepository); return(new ExecutionContext() { FieldCollector = fieldCollector, OperationType = operationDefinition.Operation, Schema = this.graphQLSchema, SchemaRepository = this.graphQLSchema.SchemaRepository, VariableResolver = variableResolver }); }
public override GraphQLOperationDefinition EndVisitOperationDefinition(GraphQLOperationDefinition definition) { var variableUsages = VariableUsagesProvider.Get(definition, this.document, this.Schema); var operationName = definition.Name != null ? definition.Name.Value : null; foreach (var variableDefinition in this.variableDefinitions) { var variableName = variableDefinition.Variable.Name.Value; if (!variableUsages.Any(e => e.Variable.Name.Value == variableName)) { this.Errors.Add(new GraphQLException(this.GetUnusedVariablesMessage(variableName, operationName), new[] { variableDefinition })); } } return(base.EndVisitOperationDefinition(definition)); }
public ExecutorContext(ISchema schema, GraphQLDocument document, ExtensionsRunner extensionsRunner, IExecutionStrategy strategy, GraphQLOperationDefinition operation, IDictionary <string, GraphQLFragmentDefinition> fragments, IReadOnlyDictionary <string, object> coercedVariableValues) { Schema = schema ?? throw new ArgumentNullException(nameof(schema)); Document = document ?? throw new ArgumentNullException(nameof(document)); ExtensionsRunner = extensionsRunner ?? throw new ArgumentNullException(nameof(extensionsRunner)); Strategy = strategy ?? throw new ArgumentNullException(nameof(strategy)); Operation = operation; Fragments = fragments; CoercedVariableValues = coercedVariableValues; _errors = new List <Exception>(); }
public QueryContext( Func <Exception, Error> formatError, GraphQLDocument document, GraphQLOperationDefinition operation, ISchema schema, Dictionary <string, object> coercedVariableValues, object initialValue, Extensions extensions) { FormatError = formatError ?? throw new ArgumentNullException(nameof(formatError)); Document = document ?? throw new ArgumentNullException(nameof(document)); OperationDefinition = operation ?? throw new ArgumentNullException(nameof(operation)); Schema = schema ?? throw new ArgumentNullException(nameof(schema)); CoercedVariableValues = coercedVariableValues ?? throw new ArgumentNullException(nameof(coercedVariableValues)); InitialValue = initialValue; Extensions = extensions; }