public async Task <GraphQLResult> ExecuteRequest( string operationType, string operationName, VariableDefinitions variableDefinitions, ISelection selection, JObject variables) => await ExecuteRequest(RequestBuilder.AstToRequest(operationType, operationName, variableDefinitions, selection, variables));
public override int GetHashCode() { var result = OperationType.GetHashCode(); if (Name != null) { result ^= Name.GetHashCode(); } if (VariableDefinitions != null) { result = VariableDefinitions.Aggregate(result, (x, y) => x ^ y.GetHashCode()); } if (Directives != null) { result = Directives.Aggregate(result, (x, y) => x ^ y.GetHashCode()); } if (SelectionSet != null) { result = SelectionSet.Aggregate(result, (x, y) => x ^ y.GetHashCode()); } return(result); }
/// <summary> /// Returns all of the variable values defined for the document from the attached <see cref="Inputs"/> object. /// </summary> public static Variables GetVariableValues(Document document, ISchema schema, VariableDefinitions variableDefinitions, Inputs inputs) { var variables = new Variables(); if (variableDefinitions != null) { foreach (var v in variableDefinitions) { var variable = new Variable { Name = v.Name }; if (inputs.TryGetValue(v.Name, out var variableValue)) { variable.Value = GetVariableValue(document, schema, v, variableValue); } else { var value = GetVariableValue(document, schema, v, v.DefaultValue?.Value); if (value != null) { variable.Value = value; } } variables.Add(variable); } } return(variables); }
/// <summary> /// Returns all of the variable values defined for the operation from the attached <see cref="Inputs"/> object. /// </summary> public static Variables GetVariableValues(Document document, ISchema schema, VariableDefinitions variableDefinitions, Inputs inputs) { if ((variableDefinitions?.List?.Count ?? 0) == 0) { return(Variables.None); } var variables = new Variables(variableDefinitions.List.Count); if (variableDefinitions != null) { foreach (var variableDef in variableDefinitions.List) { // find the IGraphType instance for the variable type var graphType = variableDef.Type.GraphTypeFromType(schema); if (graphType == null) { var error = new InvalidVariableError(variableDef.Name, $"Variable has unknown type '{variableDef.Type.Name()}'"); error.AddLocation(variableDef, document); throw error; } // create a new variable object var variable = new Variable { Name = variableDef.Name }; // attempt to retrieve the variable value from the inputs if (inputs.TryGetValue(variableDef.Name, out var variableValue)) { // parse the variable via ParseValue (for scalars) and ParseDictionary (for objects) as applicable variable.Value = GetVariableValue(document, graphType, variableDef, variableValue); } else if (variableDef.DefaultValue != null) { // if the variable was not specified in the inputs, and a default literal value was specified, use the specified default variable value // parse the variable literal via ParseLiteral (for scalars) and ParseDictionary (for objects) as applicable variable.Value = CoerceValue(graphType, variableDef.DefaultValue, variables, null).Value; variable.IsDefault = true; } else if (graphType is NonNullGraphType) { ThrowNullError(variable.Name); } // if the variable was not specified and no default was specified, do not set variable.Value // add the variable to the list of parsed variables defined for the operation variables.Add(variable); } } // return the list of parsed variables defined for the operation return(variables); }
protected bool matchVariable(out int cursor) { while ((lineBuffer = reader.ReadLine()) != null) { lineBuffer = lineBuffer.Trim(); if (lineBuffer.Length > 0) { cursor = 0; string variable = grabToken(ref cursor); if (variable.ToUpper() == "MOVES") { // encountering the "moves" section of the file, we // are done with variable definitions Moves = new List <string>(); return(false); } if (cursor == lineBuffer.Length) { throw new Exception("Unexpected end-of-line encountered"); } if (lineBuffer[cursor] != '=') { throw new Exception("Unexpected character found; expected ="); } cursor++; // gobble up any additional whitespace while (cursor < lineBuffer.Length && Char.IsWhiteSpace(lineBuffer[cursor])) { cursor++; } if (cursor == lineBuffer.Length) { throw new Exception("Unexpected end-of-line encountered"); } // value of the variable extend to end of (previously trimmed) line string value; if (lineBuffer[cursor] == '"') { if (lineBuffer[lineBuffer.Length - 1] != '"') { throw new Exception("Unmatched quote in variable definition loading saved game file"); } value = lineBuffer.Substring(cursor + 1, lineBuffer.Length - cursor - 2); } else { value = lineBuffer.Substring(cursor); } VariableDefinitions.Add(variable, value); return(true); } } // End of file and no "Moves" section, so we're done cursor = 0; return(false); }
protected override VariableNode RewriteVariable( VariableNode node, Context context) { if (!context.Variables.ContainsKey(node.Name.Value)) { VariableDefinitionNode?variableDefinition = context.Operation !.VariableDefinitions .First(t => t.Variable.Name.Value.EqualsOrdinal(node.Name.Value)); context.Variables[node.Name.Value] = variableDefinition !; } return(base.RewriteVariable(node, context)); }
public Variables GetVariableValues(Document document, ISchema schema, VariableDefinitions variableDefinitions, Inputs inputs) { var variables = new Variables(); variableDefinitions?.Apply(v => { var variable = new Variable(); variable.Name = v.Name; object variableValue = null; inputs?.TryGetValue(v.Name, out variableValue); variable.Value = GetVariableValue(document, schema, v, variableValue); variables.Add(variable); }); return(variables); }
public override string WriteOperator(TensorOp op, string[] operands) { switch (op) { case TensorOp.Assign: case TensorOp.ElementWiseAssign: case TensorOp.IndexedAssign: StringBuilder sb = new StringBuilder(); while (VariableDefinitions.Count > 0) { sb.Append(VariableDefinitions.Dequeue()); } sb.Append(base.WriteOperator(op, operands)); return(sb.ToString()); default: return(base.WriteOperator(op, operands)); } }
public GraphQLRequest AstToRequest( string operationType, string operationName, VariableDefinitions variableDefinitions, ISelection selection, JObject variables ) { var formattedVariableDefinitions = variableDefinitions.Any() ? "(" + string.Join(", ", variableDefinitions.Select(AstPrinter.Print)) + ")" : ""; return(new GraphQLRequest { Query = $"{operationType} {operationName}{formattedVariableDefinitions} {{\n {AstPrinter.Print(selection)} \n}}", OperationName = operationName, Variables = variables }); }
public string Format(string subject, string body) { var text = new StringBuilder(CustomFormat); foreach (var var in VariableDefinitions .Where(x => !string.IsNullOrWhiteSpace(x.Name) && !string.IsNullOrWhiteSpace(x.Regex))) { Match match; try { switch (var.Target) { case VariableMatchingTarget.Subject: match = Regex.Match(subject, var.Regex); break; case VariableMatchingTarget.Body: match = Regex.Match(body, var.Regex); break; default: throw new ArgumentOutOfRangeException(); } } catch (ArgumentException) { continue; } if (match.Success) { var value = match.Groups[var.GroupIndex].Value; text.Replace($"{{{var.Name}}}", value); } } return(text.ToString()); }
public override bool Equals(object obj) { if (obj is OperationDefinition operationDefinition) { return (OperationType.Equals(operationDefinition.OperationType) && ( Name == null && operationDefinition.Name == null || Name != null && operationDefinition.Name != null && Name.Equals(operationDefinition.Name) ) && ( VariableDefinitions == null && operationDefinition.VariableDefinitions == null || VariableDefinitions != null && operationDefinition.VariableDefinitions != null && VariableDefinitions.SequenceEqual(operationDefinition.VariableDefinitions) ) && ( Directives == null && operationDefinition.Directives == null || Directives != null && operationDefinition.Directives != null && Directives.SequenceEqual(operationDefinition.Directives) ) && ( SelectionSet == null && operationDefinition.SelectionSet == null || SelectionSet != null && operationDefinition.SelectionSet != null && SelectionSet.SequenceEqual(operationDefinition.SelectionSet) )); } return(base.Equals(obj)); }
public static Variables GetVariableValues(Document document, ISchema schema, VariableDefinitions variableDefinitions, Inputs inputs) { var variables = new Variables(); if (variableDefinitions != null) { foreach (var v in variableDefinitions) { var variable = new Variable { Name = v.Name }; object variableValue = null; inputs?.TryGetValue(v.Name, out variableValue); variable.Value = GetVariableValue(document, schema, v, variableValue); variables.Add(variable); } } return(variables); }
public Variables GetVariableValues(ISchema schema, VariableDefinitions variableDefinitions, Inputs inputs) { var variables = new Variables(); variableDefinitions.Apply(v => { var variable = new Variable(); variable.Name = v.Name; object variableValue; if (inputs != null && inputs.TryGetValue(v.Name, out variableValue)) { var valueAst = AstFromValue(schema, variableValue, v.Type.GraphTypeFromType(schema)); variable.Value = GetVariableValue(schema, v, valueAst); } else { variable.Value = GetVariableValue(schema, v, v.DefaultValue); } variables.Add(variable); }); return(variables); }
protected virtual void ExitVariableDefinitions(TContext context, VariableDefinitions variableDefinitions) { }
public Variables GetVariableValues(Document document, ISchema schema, VariableDefinitions variableDefinitions, Inputs inputs) { var variables = new Variables(); variableDefinitions.Apply(v => { var variable = new Variable(); variable.Name = v.Name; object variableValue = null; inputs?.TryGetValue(v.Name, out variableValue); variable.Value = GetVariableValue(document, schema, v, variableValue); variables.Add(variable); }); return variables; }
public Operation() { OperationType = OperationType.Query; Directives = new Directives(); Variables = new VariableDefinitions(); }
/// <inheritdoc/> public async Task <(IValidationResult validationResult, Variables variables)> ValidateAsync( ISchema schema, Document document, VariableDefinitions variableDefinitions, IEnumerable <IValidationRule> rules = null, IDictionary <string, object> userContext = null, Inputs inputs = null) { schema.Initialize(); var context = System.Threading.Interlocked.Exchange(ref _reusableValidationContext, null) ?? new ValidationContext(); context.Schema = schema; context.Document = document; context.TypeInfo = new TypeInfo(schema); context.UserContext = userContext; context.Inputs = inputs; try { Variables variables = null; bool useOnlyStandardRules = rules == null; if (useOnlyStandardRules) { rules = CoreRules; } if (!rules.Any()) { variables = context.GetVariableValues(schema, variableDefinitions, inputs); // can report errors even without rules enabled } else { List <INodeVisitor> visitors; List <IVariableVisitor> variableVisitors = null; if (useOnlyStandardRules) // standard rules don't validate variables { // No async/await related allocations since all standard rules return completed tasks from ValidateAsync. visitors = new List <INodeVisitor>(); foreach (var rule in (List <IValidationRule>)rules) // no iterator boxing { var visitor = rule.ValidateAsync(context)?.Result; if (visitor != null) { visitors.Add(visitor); } } } else { var awaitedVisitors = rules.Select(rule => { if (rule is IVariableVisitorProvider provider) { var variableVisitor = provider.GetVisitor(context); if (variableVisitor != null) { (variableVisitors ??= new List <IVariableVisitor>()).Add(variableVisitor); } } return(rule.ValidateAsync(context)); }).Where(x => x != null); visitors = (await Task.WhenAll(awaitedVisitors)).ToList(); } visitors.Insert(0, context.TypeInfo); new BasicVisitor(visitors).Visit(document, context); variables = context.GetVariableValues(schema, variableDefinitions, inputs ?? Inputs.Empty, variableVisitors == null ? null : variableVisitors.Count == 1 ? variableVisitors[0] : new CompositeVariableVisitor(variableVisitors)); } return(context.HasErrors ? (new ValidationResult(context.Errors), variables) : (SuccessfullyValidatedResult.Instance, variables)); } finally { if (!context.HasErrors) { context.Reset(); _ = System.Threading.Interlocked.CompareExchange(ref _reusableValidationContext, context, null); } } }
public Error[] Compile() { if (!compilationTurnedOn) { return(new Error[] { new Error("Uncompiled program.") }); } //D.Log("Compiling " + this.ToString()); StopAndReset(); //_sprakRunner = new SprakRunner(new StringReader(sourceCodeContent), FunctionDefinitions.ToArray(), VariableDefinitions.ToArray()); if (_sprakRunner == null) { //D.Log("Creating new SprakRunner for " + this.ToString()); _sprakRunner = new SprakRunner(new StringReader(sourceCodeContent), FunctionDefinitions.ToArray(), VariableDefinitions.ToArray()); } else { _sprakRunner.Reset(); } PrintErrorsToD(); return(GetErrors()); }
public Variables GetVariableValues(ISchema schema, VariableDefinitions variableDefinitions, Inputs inputs) { var variables = new Variables(); variableDefinitions.Apply(v => { var variable = new Variable(); variable.Name = v.Name; object variableValue; if (inputs != null && inputs.TryGetValue(v.Name, out variableValue)) { var valueAst = variableValue.AstFromValue(schema, v.Type.GraphTypeFromType(schema)); variable.Value = GetVariableValue(schema, v, valueAst); } else { variable.Value = GetVariableValue(schema, v, v.DefaultValue); } variables.Add(variable); }); return variables; }
/// <summary> /// Returns all of the variable values defined for the operation from the attached <see cref="Inputs"/> object. /// </summary> public Variables GetVariableValues(ISchema schema, VariableDefinitions variableDefinitions, Inputs inputs, IVariableVisitor visitor = null) { if ((variableDefinitions?.List?.Count ?? 0) == 0) { return(Variables.None); } var variables = new Variables(variableDefinitions.List.Count); if (variableDefinitions != null) { foreach (var variableDef in variableDefinitions.List) { // find the IGraphType instance for the variable type var graphType = variableDef.Type.GraphTypeFromType(schema); if (graphType == null) { ReportError(new InvalidVariableError(this, variableDef, variableDef.Name, $"Variable has unknown type '{variableDef.Type.Name()}'")); continue; } // create a new variable object var variable = new Variable(variableDef.Name); // attempt to retrieve the variable value from the inputs if (inputs.TryGetValue(variableDef.Name, out var variableValue)) { // parse the variable via ParseValue (for scalars) and ParseDictionary (for objects) as applicable try { variable.Value = GetVariableValue(graphType, variableDef, variableValue, visitor); } catch (ValidationError error) { ReportError(error); continue; } } else if (variableDef.DefaultValue != null) { // if the variable was not specified in the inputs, and a default literal value was specified, use the specified default variable value // parse the variable literal via ParseLiteral (for scalars) and ParseDictionary (for objects) as applicable try { variable.Value = ExecutionHelper.CoerceValue(graphType, variableDef.DefaultValue, variables, null).Value; } catch (Exception ex) { ReportError(new InvalidVariableError(this, variableDef, variableDef.Name, "Error coercing default value.", ex)); continue; } variable.IsDefault = true; } else if (graphType is NonNullGraphType) { ReportError(new InvalidVariableError(this, variableDef, variable.Name, "No value provided for a non-null variable.")); continue; } // if the variable was not specified and no default was specified, do not set variable.Value // add the variable to the list of parsed variables defined for the operation variables.Add(variable); } } // return the list of parsed variables defined for the operation return(variables); }
protected override void ExitVariableDefinitions(PrinterContext context, VariableDefinitions variableDefinition) { context.Append(')'); }
// Pre: name and operationName are both non-null and not empty // Pre: fieldType is non null public Result <GraphQLRequest> BuildRequest <TResult, TArg1, TArg2, TArg3>( string name, string operationName, string operationType, FieldType fieldType, TArg1 arg1, TArg2 arg2, TArg3 arg3 ) { var typeList = new List <Type> { typeof(TArg1), typeof(TArg2), typeof(TArg3) }; var argList = new List <object> { arg1, arg2, arg3 }; if (!fieldType.ResolvedType.IsCompatibleType(typeof(TResult))) { var refType = fieldType.ResolvedType.GetNamedType() as GraphQLTypeReference; var typename = refType?.TypeName ?? "unknown type"; return(Results.Fail <GraphQLRequest>($"Result type {typeof(TResult).Name} doesn't match GraphQL result type {typename}")); } if (!typeof(TResult).IsGraphQLType()) { return(Results.Fail <GraphQLRequest>($"Result type {typeof(TResult).Name} doesn't have GraphQLModel attribute")); } VariableDefinitions variableDefinitions = new VariableDefinitions(); JObject variables = new JObject(); Arguments arguments = new Arguments(); var fieldArgs = fieldType.Arguments.ToList(); for (int i = 0; i < fieldArgs.Count; i++) { var fieldArg = fieldArgs[i]; var argType = typeList[i]; var arg = argList[i]; if (arg == null) { if (fieldArg.ResolvedType.IsNonNullGraphType() && arg == null) { return(Results.Fail <GraphQLRequest>( new FluentResults.ExceptionalError( new ArgumentNullException(nameof(name), $"Argument is null, but GraphQL is requiring {fieldArg.Name} to be non-null.")))); } continue; } if (!fieldArg.ResolvedType.IsCompatibleType(argType)) { var refType = fieldArg.ResolvedType.GetNamedType() as GraphQLTypeReference; var typename = refType?.TypeName ?? "unknown type"; return(Results.Fail <GraphQLRequest>($"Argument type {argType.Name} doesn't match GraphQL type {typename}")); } if (!argType.IsGraphQLType()) { return(Results.Fail <GraphQLRequest>($"Argument type {argType.Name} doesn't have GraphQLModel attribute")); } arguments.Add(new Argument(new NameNode(fieldArg.Name)) { Value = new VariableReference(new NameNode(fieldArg.Name)) }); variableDefinitions.Add(new VariableDefinition(new NameNode(fieldArg.Name)) { Type = fieldArg.ResolvedType.ToIType() }); variables[fieldArg.Name] = JToken.FromObject(arg); } // FIXME: pick up the depth from the model type SelectionSet selections = typeof(TResult).GetCSNamedType().AsSelctionSet(3); var requestField = new Field(null, new NameNode(name)) { Arguments = arguments, Directives = new Directives(), SelectionSet = selections }; return(Results.Ok(AstToRequest( operationType, operationName, variableDefinitions, requestField, variables))); }