public ExpressionResult ParseGqlarg(IMethodType fieldArgumentContext, EntityGraphQLParser.GqlargContext context)
{
ExpressionResult gqlVarValue = null;
if (context.gqlVar() != null)
{
string varKey = context.gqlVar().GetText().TrimStart('$');
object value = variables.GetValueFor(varKey);
gqlVarValue = (ExpressionResult)Expression.Constant(value);
}
else
{
// this is an expression
gqlVarValue = constantVisitor.Visit(context.gqlvalue);
}
string argName = context.gqlfield.GetText();
if (fieldArgumentContext != null && fieldArgumentContext.HasArgumentByName(argName))
{
var argType = fieldArgumentContext.GetArgumentType(argName);
if (gqlVarValue != null && gqlVarValue.Type == typeof(string) && gqlVarValue.NodeType == ExpressionType.Constant)
{
string strValue = (string)((ConstantExpression)gqlVarValue).Value;
if (
(argType.Type == typeof(Guid) || argType.Type == typeof(Guid?) ||
argType.Type == typeof(RequiredField <Guid>) || argType.Type == typeof(RequiredField <Guid?>)) && ConstantVisitor.GuidRegex.IsMatch(strValue))
{
return((ExpressionResult)Expression.Constant(Guid.Parse(strValue)));
}
if (argType.Type.IsConstructedGenericType && argType.Type.GetGenericTypeDefinition() == typeof(EntityQueryType <>))
{
string query = strValue;
if (query.StartsWith("\""))
{
query = query.Substring(1, context.gqlvalue.GetText().Length - 2);
}
return(BuildEntityQueryExpression(fieldArgumentContext, fieldArgumentContext.Name, argName, query));
}
var argumentNonNullType = argType.Type.IsNullableType() ? Nullable.GetUnderlyingType(argType.Type) : argType.Type;
if (argumentNonNullType.GetTypeInfo().IsEnum)
{
var enumName = strValue;
var valueIndex = Enum.GetNames(argumentNonNullType).ToList().FindIndex(n => n == enumName);
if (valueIndex == -1)
{
throw new EntityGraphQLCompilerException($"Value {enumName} is not valid for argument {context.gqlfield.GetText()}");
}
var enumValue = Enum.GetValues(argumentNonNullType).GetValue(valueIndex);
return((ExpressionResult)Expression.Constant(enumValue));
}
}
}
return(gqlVarValue);
}
public override ExpressionResult VisitIdentity(EntityGraphQLParser.IdentityContext context)
{
var field = context.GetText();
string name = schemaProvider.GetSchemaTypeNameForDotnetType(currentContext.Type);
if (!schemaProvider.TypeHasField(name, field, null, claims))
{
var enumOrConstantValue = constantVisitor.Visit(context);
if (enumOrConstantValue == null)
{
throw new EntityGraphQLCompilerException($"Field {field} not found on type {name}");
}
return(enumOrConstantValue);
}
var exp = schemaProvider.GetExpressionForField(currentContext, name, field, null, claims);
return(exp);
}
public override GraphQLOperation VisitGqlTypeDef(EntityGraphQLParser.GqlTypeDefContext context)
{
var argName = context.gqlVar().GetText().TrimStart('$');
var isArray = context.arrayType != null;
var type = isArray ? context.arrayType.type.GetText() : context.type.GetText();
var required = context.required != null;
ExpressionResult defaultValue = null;
if (context.defaultValue != null)
{
defaultValue = constantVisitor.Visit(context.defaultValue);
}
if (required && !variables.ContainsKey(argName) && defaultValue == null)
{
throw new QueryException($"Missing required variable '{argName}' on query '{this.operation.Name}'");
}
this.operation.AddArgument(argName, type, isArray, required, defaultValue != null ? defaultValue : null);
return(this.operation);
}