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