private GraphQLException ComposeError(GraphQLArgument argument, GraphQLValue astValue, IEnumerable <GraphQLException> innerExceptions)
{
var innerMessage = string.Join("\n", innerExceptions.Select(e => e.Message));
var exceptionMessage = $"Argument \"{argument.Name.Value}\" has invalid value {astValue}.\n{innerMessage}";
return(new GraphQLException(exceptionMessage, new[] { argument.Value }));
}
public override object ParseLiteral(GraphQLValue value)
{
return(value switch
{
GraphQLStringValue s => Convert.FromBase64String((string)s.Value), // string conversion for NET48
_ => throw new NotSupportedException()
});
public override object ParseLiteral(GraphQLValue value)
{
if (value is GraphQLNullValue)
{
return(null);
}
if (value is GraphQLStringValue stringValue)
{
return(ParseValue(stringValue.Value));
}
if (value is GraphQLObjectValue objectValue)
{
var entries = objectValue.Fields.ToDictionary(x => x.Name.Value, x => _floatScalar.ParseLiteral(x.Value));
if (entries.Count != 3)
{
return(ThrowLiteralConversionError(value));
}
var x = (double)entries["x"];
var y = (double)entries["y"];
var z = (double)entries["z"];
return(new Vector3((float)x, (float)y, (float)z));
}
return(ThrowLiteralConversionError(value));
}
public void ToAST_Test(IGraphType type, object value, GraphQLValue expected)
{
var actual = type.ToAST(value).Print();
var result = expected.Print();
actual.ShouldBe(result);
}
internal IEnumerable <GraphQLException> IsValid(GraphQLBaseType type, GraphQLValue astValue)
{
if (astValue is GraphQLVariable)
{
return new GraphQLException[] { }
}
;
if (astValue is GraphQLNullValue || astValue == null)
{
return(this.ValidateNullType(type, astValue));
}
if (type is GraphQLNonNull)
{
return(this.IsValid(((GraphQLNonNull)type).UnderlyingNullableType, astValue));
}
if (type is GraphQLList)
{
return(this.ValidateListType(type, astValue));
}
if (type is GraphQLInputType)
{
return(this.ValidateInputType(type, astValue));
}
return(new GraphQLException[] { });
}
public override Result GetValueFromAst(GraphQLValue astValue, ISchemaRepository schemaRepository)
{
if (astValue.Kind == ASTNodeKind.BooleanValue)
{
return(new Result(((GraphQLScalarValue)astValue).Value.ParseBoolOrGiveNull()));
}
return(Result.Invalid);
}
public override Result GetValueFromAst(GraphQLValue astValue, ISchemaRepository schemaRepository)
{
if (astValue.Kind == ASTNodeKind.StringValue)
{
return(new Result(((GraphQLScalarValue)astValue).Value));
}
return(Result.Invalid);
}
private static GraphQLObjectField GetObjectField(GraphQLValue value)
{
return(new GraphQLObjectField()
{
Name = new GraphQLName()
{
Value = "fieldA"
},
Value = value
});
}
private GraphQLValue GetDefaultConstantValue()
{
GraphQLValue defaultValue = null;
if (this.Skip(TokenKind.EQUALS))
{
defaultValue = this.ParseConstantValue();
}
return(defaultValue);
}
public override Result GetValueFromAst(GraphQLValue astValue, ISchemaRepository schemaRepository)
{
if (this.UnderlyingNullableType is GraphQLInputType)
{
var result = ((GraphQLInputType)this.UnderlyingNullableType).GetFromAst(astValue, schemaRepository);
return(result.Value != null ? result : Result.Invalid);
}
return(Result.Invalid);
}
private IEnumerable GetListValue(GraphQLValue value)
{
IList output = new List <object>();
var list = ((GraphQLValue <IEnumerable <GraphQLValue> >)value).Value;
foreach (var item in list)
{
output.Add(this.GetValue(item));
}
return(output);
}
public override object ParseLiteral(GraphQLValue value)
{
if (value is GraphQLStringValue stringValue)
{
if (stringValue.Value.Equals("SerializedValue"))
{
return("DeserializedValue");
}
}
return(null);
}
public override Result GetValueFromAst(GraphQLValue astValue, ISchemaRepository schemaRepository)
{
if (astValue.Kind == ASTNodeKind.FloatValue || astValue.Kind == ASTNodeKind.IntValue)
{
var value = ((GraphQLScalarValue)astValue).Value.ParseFloatOrGiveNull();
if (value != null)
{
return(new Result(value));
}
}
return(Result.Invalid);
}
public void parse_literal_value_to_identifier(object value)
{
GraphQLValue ast = value switch
{
int i => new GraphQLIntValue(i),
long l => new GraphQLIntValue(l),
string s => new GraphQLStringValue(s),
_ => null
};
var ret = _type.ParseLiteral(ast);
ret.ShouldBeOfType(value.GetType());
ret.ShouldBe(value);
}
private Object GetArgumentValue(IEdmTypeReference typeReference, GraphQLValue graphValue)
{
if (graphValue is GraphQLScalarValue scalarValue)
{
if (typeReference.IsString())
{
return(scalarValue.Value);
}
return(ODataUriUtils.ConvertFromUriLiteral(scalarValue.Value, ODataVersion.V4, _edmModel, typeReference));
}
throw new NotSupportedException("argument " + graphValue.GetType().Name + " not supported");
}
public override Result GetValueFromAst(GraphQLValue astValue, ISchemaRepository schemaRepository)
{
if (astValue.Kind != ASTNodeKind.EnumValue)
{
return(Result.Invalid);
}
string value = ((GraphQLScalarValue)astValue).Value;
if (!Enum.IsDefined(this.SystemType, value))
{
return(Result.Invalid);
}
return(new Result(Enum.Parse(this.SystemType, value)));
}
public void GetValue_GraphQLObjectValueWithIntField_ReturnsExpandoObjectWithIntegerField()
{
var literalValue = new GraphQLValue <int>(ASTNodeKind.IntValue);
this.typeTranslator.GetLiteralValue(literalValue).Returns(123);
var value = new GraphQLObjectValue()
{
Fields = new GraphQLObjectField[] {
GetObjectField(literalValue)
}
};
var result = this.valueResolver.GetValue(value) as dynamic;
Assert.AreEqual(123, result.fieldA);
}
public void parseLiteral_other_fail(Type graphType, object value)
{
GraphQLValue astValue = value switch
{
int i => new GraphQLIntValue(i),
long l => new GraphQLIntValue(l),
bool b => b ? new GraphQLTrueBooleanValue() : new GraphQLFalseBooleanValue(),
double d => new GraphQLFloatValue(d),
string s => new GraphQLStringValue(s),
_ => null
};
var g = Create(graphType);
Should.Throw <Exception>(() => g.ParseLiteral(astValue));
g.CanParseLiteral(astValue).ShouldBeFalse();
}
public override Result GetValueFromAst(GraphQLValue astValue, ISchemaRepository schemaRepository)
{
if (astValue.Kind == ASTNodeKind.IntValue)
{
decimal value;
if (!decimal.TryParse(((GraphQLScalarValue)astValue).Value, out value))
{
return(Result.Invalid);
}
if (value <= int.MaxValue && value >= int.MinValue)
{
return(new Result(Convert.ToInt32(value)));
}
}
return(Result.Invalid);
}
private Object GetArgumentValue(IEdmTypeReference typeReference, GraphQLValue graphValue)
{
if (graphValue is GraphQLScalarValue scalarValue)
{
if (typeReference.IsString())
{
return(scalarValue.Value);
}
return(ODataUriUtils.ConvertFromUriLiteral(scalarValue.Value, ODataVersion.V4, _edmModel, typeReference));
}
else if (graphValue is GraphQLVariable variable)
{
Type clrType = _edmModel.GetClrType(typeReference.Definition);
return(_context.GetArgument(clrType, variable.Name.Value));
}
throw new NotSupportedException("Argument " + graphValue.GetType().Name + " not supported");
}
public void parseLiteral_other_ok(Type graphType, object value, object parsed)
{
GraphQLValue astValue = value switch
{
int i => new GraphQLIntValue(i),
long l => new GraphQLIntValue(l),
bool b => b ? new GraphQLTrueBooleanValue() : new GraphQLFalseBooleanValue(),
double f => new GraphQLFloatValue(f),
string s => new GraphQLStringValue(s),
_ => null
};
var g = Create(graphType);
var ret = g.ParseLiteral(astValue);
ret.ShouldBeOfType(parsed.GetType());
ret.ShouldBe(parsed);
g.CanParseLiteral(astValue).ShouldBeTrue();
}
public object GetValue(GraphQLValue value)
{
var literalValue = this.typeTranslator.GetLiteralValue(value);
if (literalValue != null)
{
return(literalValue);
}
switch (value.Kind)
{
case ASTNodeKind.ListValue: return(this.GetListValue(value));
case ASTNodeKind.Variable: return(this.variableResolver.GetValue((GraphQLVariable)value));
case ASTNodeKind.ObjectValue: return(this.CreateObjectFromObjectValue((GraphQLObjectValue)value));
default: throw new NotImplementedException($"Unknown kind {value.Kind}");
}
}
public Result GetFromAst(GraphQLValue astValue, ISchemaRepository schemaRepository)
{
if (!(this is GraphQLNonNull) && (astValue == null || astValue.Kind == ASTNodeKind.NullValue))
{
return(new Result(null));
}
if (astValue?.Kind == ASTNodeKind.Variable)
{
var result = schemaRepository.VariableResolver.GetValue((GraphQLVariable)astValue);
if (result.Value == null && this is GraphQLNonNull)
{
return(Result.Invalid);
}
return(result);
}
return(this.GetValueFromAst(astValue, schemaRepository));
}
public override Result GetValueFromAst(GraphQLValue astValue, ISchemaRepository schemaRepository)
{
if (astValue.Kind == ASTNodeKind.NullValue)
{
return(new Result(null));
}
var inputType = this.MemberType as GraphQLInputType;
var output = CreateOutputList(inputType, schemaRepository);
if (astValue.Kind != ASTNodeKind.ListValue)
{
var value = inputType.GetFromAst(astValue, schemaRepository);
if (!value.IsValid)
{
return(Result.Invalid);
}
output.Add(value.Value);
return(new Result(output));
}
var list = ((GraphQLListValue)astValue).Values;
foreach (var item in list)
{
var result = inputType.GetFromAst(item, schemaRepository);
if (!result.IsValid)
{
return(Result.Invalid);
}
output.Add(result.Value);
}
return(new Result(output));
}
public override Result GetValueFromAst(GraphQLValue astValue, ISchemaRepository schemaRepository)
{
if (!(astValue is GraphQLObjectValue))
{
return(Result.Invalid);
}
var objectAstValue = (GraphQLObjectValue)astValue;
var result = new T();
foreach (var field in this.Fields)
{
var astField = GetFieldFromAstObjectValue(objectAstValue, field.Key);
Result fieldResult;
if (astField == null && field.Value.DefaultValue.IsSet)
{
fieldResult = new Result(field.Value.DefaultValue.Value);
}
else
{
fieldResult = this.GetField(astField, field.Value, schemaRepository);
}
if (!fieldResult.IsValid)
{
return(Result.Invalid);
}
if (fieldResult.Value == null && field.Value.DefaultValue.IsSet)
{
fieldResult = new Result(field.Value.DefaultValue.Value);
}
this.AssignValueToObjectField(result, field.Value, fieldResult.Value);
}
return(new Result(result));
}
protected EqualsValueClauseSyntax GetDefault(GraphQLValue defaultValue, TypeSyntax type)
{
switch (defaultValue?.Kind)
{
case ASTNodeKind.IntValue:
return(SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(
SyntaxKind.NumericLiteralExpression,
SyntaxFactory.ParseToken(((GraphQLScalarValue)defaultValue).Value))));
case ASTNodeKind.FloatValue:
return(SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(
SyntaxKind.NumericLiteralExpression,
SyntaxFactory.ParseToken($"{((GraphQLScalarValue)defaultValue).Value}f"))));
case ASTNodeKind.StringValue:
return(SyntaxFactory.EqualsValueClause(
SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.ParseToken($"\"{((GraphQLScalarValue)defaultValue).Value}\""))));;
case ASTNodeKind.BooleanValue:
return(((GraphQLScalarValue)defaultValue).Value.ToLower() == "true"
? SyntaxFactory.EqualsValueClause(SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression))
: SyntaxFactory.EqualsValueClause(SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression)));
case ASTNodeKind.EnumValue:
return(SyntaxFactory.EqualsValueClause(SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
type.Kind() == SyntaxKind.NullableType
? ((NullableTypeSyntax)type).ElementType
: type,
SyntaxFactory.IdentifierName(((GraphQLScalarValue)defaultValue).Value))));
}
;
return(SyntaxFactory.EqualsValueClause(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)));
}
public override object ParseLiteral(GraphQLValue value)
{
if (value is GraphQLStringValue stringValue)
{
if (stringValue.Value == "externalNull")
{
return(null);
}
if (stringValue.Value == "error")
{
throw new Exception("Cannot parse value");
}
return((string)stringValue.Value);
}
if (value is GraphQLNullValue)
{
return("internalNull");
}
throw new NotSupportedException();
}
public IValue Value(GraphQLValue source)
{
switch (source.Kind)
{
case ASTNodeKind.StringValue:
{
var str = (GraphQLScalarValue)source;
return(new StringValue(str.Value).WithLocation(str, _body));
}
case ASTNodeKind.IntValue:
{
var str = (GraphQLScalarValue)source;
if (int.TryParse(str.Value, out var intResult))
{
return(new IntValue(intResult).WithLocation(str, _body));
}
// If the value doesn't fit in an integer, revert to using long...
if (long.TryParse(str.Value, out var longResult))
{
return(new LongValue(longResult).WithLocation(str, _body));
}
throw new ExecutionError($"Invalid number {str.Value}");
}
case ASTNodeKind.FloatValue:
{
var str = (GraphQLScalarValue)source;
return(new FloatValue(ValueConverter.ConvertTo <double>(str.Value)).WithLocation(str, _body));
}
case ASTNodeKind.BooleanValue:
{
var str = (GraphQLScalarValue)source;
return(new BooleanValue(ValueConverter.ConvertTo <bool>(str.Value)).WithLocation(str, _body));
}
case ASTNodeKind.EnumValue:
{
var str = (GraphQLScalarValue)source;
return(new EnumValue(str.Value).WithLocation(str, _body));
}
case ASTNodeKind.Variable:
{
var vari = (GraphQLVariable)source;
return(new VariableReference(Name(vari.Name)).WithLocation(vari, _body));
}
case ASTNodeKind.ObjectValue:
{
var obj = (GraphQLObjectValue)source;
var fields = obj.Fields.Select(ObjectField);
return(new ObjectValue(fields).WithLocation(obj, _body));
}
case ASTNodeKind.ListValue:
{
var list = (GraphQLListValue)source;
var values = list.Values.Select(Value);
return(new ListValue(values).WithLocation(list, _body));
}
case ASTNodeKind.NullValue:
{
var str = (GraphQLScalarValue)source;
return(new NullValue().WithLocation(str, _body));
}
}
throw new ExecutionError($"Unmapped value type {source.Kind}");
}
public static object ToValue(this GraphQLValue source)
{
if (source == null)
{
return(null);
}
switch (source.Kind)
{
case ASTNodeKind.NullValue:
{
return(null);
}
case ASTNodeKind.StringValue:
{
var str = source as GraphQLScalarValue;
Debug.Assert(str != null, nameof(str) + " != null");
return(str.Value);
}
case ASTNodeKind.IntValue:
{
var str = source as GraphQLScalarValue;
Debug.Assert(str != null, nameof(str) + " != null");
if (int.TryParse(str.Value, out var intResult))
{
return(intResult);
}
// If the value doesn't fit in an integer, revert to using long...
if (long.TryParse(str.Value, out var longResult))
{
return(longResult);
}
// If the value doesn't fit in an long, revert to using BigInteger...
if (BigInteger.TryParse(str.Value, out var bigIntegerResult))
{
return(bigIntegerResult);
}
throw new ExecutionError($"Invalid number {str.Value}");
}
case ASTNodeKind.FloatValue:
{
var str = source as GraphQLScalarValue;
Debug.Assert(str != null, nameof(str) + " != null");
return(ValueConverter.ConvertTo <double>(str.Value));
}
case ASTNodeKind.BooleanValue:
{
var str = source as GraphQLScalarValue;
Debug.Assert(str != null, nameof(str) + " != null");
return(ValueConverter.ConvertTo <bool>(str.Value));
}
case ASTNodeKind.EnumValue:
{
var str = source as GraphQLScalarValue;
Debug.Assert(str != null, nameof(str) + " != null");
return(str.Value);
}
case ASTNodeKind.ObjectValue:
{
var obj = source as GraphQLObjectValue;
var values = new Dictionary <string, object>();
Debug.Assert(obj != null, nameof(obj) + " != null");
obj.Fields.Apply(f => values[f.Name.Value] = ToValue(f.Value));
return(values);
}
case ASTNodeKind.ListValue:
{
var list = source as GraphQLListValue;
Debug.Assert(list != null, nameof(list) + " != null");
if (list.Values == null)
{
return(Array.Empty <object>());
}
object[] values = list.Values.Select(ToValue).ToArray();
return(values);
}
default:
throw new ExecutionError($"Unsupported value type {source.Kind}");
}
}
/// <inheritdoc/>
public override object?ParseLiteral(GraphQLValue value) => value switch
{
