private IValueNode ReplaceVariable(
VariableNode variable,
IInputType type)
{
if (_variables.TryGetVariable(
variable.Name.Value,
out object v))
{
if (!type.ClrType.IsInstanceOfType(v) &&
!_typeConversion.TryConvert(
typeof(object),
type.ClrType,
v,
out v))
{
throw new QueryException(
ErrorBuilder.New()
.SetMessage(CoreResources.VarRewriter_CannotConvert)
.SetCode(ErrorCodes.Utilities.NoConverter)
.AddLocation(variable)
.Build());
}
return(type.ParseValue(v));
}
return(type.ParseValue(null));
}
private IValueNode ReplaceVariable(
VariableNode variable,
IInputType type)
{
if (_variables.TryGetVariable(
variable.Name.Value,
out object v))
{
if (!type.ClrType.IsInstanceOfType(v) &&
!_typeConversion.TryConvert(
typeof(object),
type.ClrType,
v,
out v))
{
// TODO : resource
// TODO : path?
throw new QueryException(
ErrorBuilder.New()
.SetMessage(
"Unable to convert the specified " +
"variable value.")
.Build());
}
return(type.ParseValue(v));
}
return(type.ParseValue(null));
}
public static IValueNode CreateDefaultValue(
ICompletionContext context,
ArgumentDefinition definition,
IInputType fieldType)
{
try
{
if (definition.NativeDefaultValue != null)
{
return(fieldType.ParseValue(
definition.NativeDefaultValue));
}
return(definition.DefaultValue.IsNull()
? NullValueNode.Default
: definition.DefaultValue);
}
catch (Exception ex)
{
// TODO : RESOURCES
context.ReportError(SchemaErrorBuilder.New()
.SetMessage(
"Could not parse the native value of input field " +
$"`{context.Type.Name}.{definition.Name}`.")
.SetCode(TypeErrorCodes.MissingType)
.SetTypeSystemObject(context.Type)
.AddSyntaxNode(definition.SyntaxNode)
.SetException(ex)
.Build());
return(NullValueNode.Default);
}
}
public static IValueNode CreateDefaultValue(
ITypeCompletionContext context,
ArgumentDefinition argumentDefinition,
IInputType argumentType,
FieldCoordinate argumentCoordinate)
{
try
{
return(argumentDefinition.NativeDefaultValue != null
? argumentType.ParseValue(argumentDefinition.NativeDefaultValue)
: argumentDefinition.DefaultValue);
}
catch (Exception ex)
{
context.ReportError(SchemaErrorBuilder.New()
.SetMessage(
TypeResources.FieldInitHelper_InvalidDefaultValue,
argumentCoordinate)
.SetCode(ErrorCodes.Schema.MissingType)
.SetTypeSystemObject(context.Type)
.AddSyntaxNode(argumentDefinition.SyntaxNode)
.SetException(ex)
.Build());
return(NullValueNode.Default);
}
}
public static IValueNode CreateDefaultValue(
ICompletionContext context,
ArgumentDefinition definition,
IInputType fieldType)
{
try
{
if (definition.NativeDefaultValue != null)
{
return(fieldType.ParseValue(
definition.NativeDefaultValue));
}
return(definition.DefaultValue.IsNull()
? NullValueNode.Default
: definition.DefaultValue);
}
catch (Exception ex)
{
context.ReportError(SchemaErrorBuilder.New()
.SetMessage(TypeResources.FieldInitHelper_InvalidDefaultValue)
.SetCode(TypeErrorCodes.MissingType)
.SetTypeSystemObject(context.Type)
.AddSyntaxNode(definition.SyntaxNode)
.SetException(ex)
.Build());
return(NullValueNode.Default);
}
}
private void CompleteDefaultValue(
IInputType type,
Action <SchemaError> reportError,
INamedType parentType)
{
try
{
if (DefaultValue == null)
{
if (_nativeDefaultValue == null)
{
DefaultValue = new NullValueNode();
}
else
{
DefaultValue = type.ParseValue(_nativeDefaultValue);
}
}
}
catch (Exception ex)
{
reportError(new SchemaError(
"Could not parse the native value for input field " +
$"`{parentType.Name}.{Name}`.", parentType, ex));
}
}
private EventDescription CreateEvent(
IExecutionContext executionContext)
{
IReadOnlyCollection <FieldSelection> selections = executionContext
.FieldHelper.CollectFields(
executionContext.Operation.RootType,
executionContext.Operation.Definition.SelectionSet);
if (selections.Count == 1)
{
FieldSelection selection = selections.Single();
Dictionary <string, ArgumentValue> argumentValues = selection
.CoerceArgumentValues(executionContext.Variables);
var arguments = new List <ArgumentNode>();
foreach (KeyValuePair <string, ArgumentValue> argumentValue in
argumentValues)
{
IInputType argumentType = argumentValue.Value.Type;
object value = argumentValue.Value.Value;
arguments.Add(new ArgumentNode(
argumentValue.Key,
argumentType.ParseValue(value)));
}
return(new EventDescription(selection.Field.Name, arguments));
}
else
{
// TODO : Error message
throw new QueryException();
}
}
private static EventDescription CreateEvent(
IExecutionContext executionContext)
{
IReadOnlyCollection <FieldSelection> selections = executionContext
.CollectFields(
executionContext.Operation.RootType,
executionContext.Operation.Definition.SelectionSet,
null);
if (selections.Count == 1)
{
FieldSelection selection = selections.Single();
IReadOnlyDictionary <NameString, ArgumentValue> argumentValues =
selection.CoerceArguments(executionContext.Variables);
var arguments = new List <ArgumentNode>();
foreach (KeyValuePair <NameString, ArgumentValue> argValue in
argumentValues)
{
IInputType argumentType = argValue.Value.Type;
object value = argValue.Value.Value;
arguments.Add(new ArgumentNode(
argValue.Key,
argumentType.ParseValue(value)));
}
return(new EventDescription(selection.Field.Name, arguments));
}
else
{
throw new QueryException(
CoreResources.Subscriptions_SingleRootField);
}
}
private IValueNode CreateValue(ITypeRegistry typeRegistry)
{
if (DefaultValue != null)
{
return(DefaultValue);
}
if (NativeDefaultValue != null)
{
IInputType type = CreateType(typeRegistry);
return(type.ParseValue(NativeDefaultValue));
}
return(new NullValueNode());
}
public IValueNode ParseValue(object value)
{
if (_isInputType)
{
if (value == null)
{
throw new ArgumentException(
"A non null type cannot parse null values.");
}
return(_inputType.ParseValue(value));
}
throw new InvalidOperationException(
"The specified type is not an input type.");
}
public static IValueNode CreateDefaultValue(
ICompletionContext context,
ArgumentDefinition definition,
IInputType fieldType)
{
try
{
if (definition.NativeDefaultValue != null)
{
return(fieldType.ParseValue(
definition.NativeDefaultValue));
}
return(definition.DefaultValue is { }
? definition.DefaultValue
: null);
}
public IValueNode ParseValue(object value)
{
if (_isInputType)
{
if (value == null)
{
throw new ArgumentException(
TypeResources.NonNullType_ValueIsNull,
nameof(value));
}
return(_inputType.ParseValue(value));
}
throw new InvalidOperationException(
TypeResources.NonNullType_NotAnInputType);
}
public VariableValue Resolve(
IResolverContext context,
ScopedVariableNode variable,
IInputType targetType)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (variable == null)
{
throw new ArgumentNullException(nameof(variable));
}
if (targetType == null)
{
throw new ArgumentNullException(nameof(targetType));
}
if (!ScopeNames.ScopedContextData.Equals(variable.Scope.Value))
{
throw new ArgumentException(StitchingResources
.ScopedCtxDataScopedVariableResolver_CannotHandleVariable,
nameof(variable));
}
context.ScopedContextData.TryGetValue(variable.Name.Value, out object?data);
IValueNode literal = data switch
{
IValueNode l => l,
null => NullValueNode.Default,
_ => targetType.ParseValue(data)
};
return(new VariableValue
(
variable.ToVariableName(),
targetType.ToTypeNode(),
literal,
null
));
}
}
public IValueNode ParseValue(object value)
{
if (_isInputType)
{
if (value == null)
{
return(new NullValueNode(null));
}
if (value is IEnumerable e)
{
var items = new List <IValueNode>();
foreach (object v in e)
{
items.Add(_inputType.ParseValue(value));
}
return(new ListValueNode(null, items));
}
}
throw new InvalidOperationException(
"The specified type is not an input type.");
}
private static IValueNode ParseScalar(
IInputType type, object fieldValue)
{
return(type.ParseValue(fieldValue));
}