public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
Expression instance,
ITypeConversion converter,
out Expression expression)
{
if (operation.Type == typeof(bool) &&
(value is BooleanValueNode || value.IsNull()))
{
MemberExpression property =
Expression.Property(instance, operation.Property);
object parserValue = type.ParseLiteral(value);
switch (operation.Kind)
{
case FilterOperationKind.Equals:
expression = FilterExpressionBuilder.Equals(
property, parserValue);
return(true);
case FilterOperationKind.NotEquals:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.Equals(
property, parserValue)
);
return(true);
}
}
expression = null;
return(false);
}
public IValueNode RewriteValue(
IValueNode value,
IType type,
IVariableValueCollection variables,
ITypeConversion typeConversion)
{
if (value is null)
{
throw new ArgumentNullException(nameof(value));
}
if (type is null)
{
throw new ArgumentNullException(nameof(type));
}
if (variables is null)
{
throw new ArgumentNullException(nameof(variables));
}
if (typeConversion is null)
{
throw new ArgumentNullException(nameof(typeConversion));
}
_variables = variables;
_typeConversion = typeConversion;
_type.Clear();
_type.Push(type);
return(RewriteValue(value, null));
}
protected override void OnCompleteType(
ICompletionContext context,
DirectiveTypeDefinition definition)
{
base.OnCompleteType(context, definition);
_converter = context.Services.GetTypeConversion();
MiddlewareComponents =
definition.MiddlewareComponents.ToList().AsReadOnly();
SyntaxNode = definition.SyntaxNode;
Locations = definition.Locations.ToList().AsReadOnly();
Arguments = new FieldCollection <Argument>(
definition.Arguments.Select(t => new Argument(t)));
IsExecutable = MiddlewareComponents.Count > 0;
if (!Locations.Any())
{
context.ReportError(SchemaErrorBuilder.New()
.SetMessage(string.Format(
CultureInfo.InvariantCulture,
TypeResources.DirectiveType_NoLocations,
Name))
.SetCode(TypeErrorCodes.MissingType)
.SetTypeSystemObject(context.Type)
.AddSyntaxNode(definition.SyntaxNode)
.Build());
}
FieldInitHelper.CompleteFields(context, definition, Arguments);
}
public QueryableFilterVisitor(
InputObjectType initialType,
Type source,
ITypeConversion converter,
IEnumerable <IExpressionOperationHandler> operationHandlers,
IEnumerable <IExpressionFieldHandler> fieldHandlers,
bool inMemory)
: base(initialType)
{
if (initialType is null)
{
throw new ArgumentNullException(nameof(initialType));
}
if (source is null)
{
throw new ArgumentNullException(nameof(source));
}
if (operationHandlers is null)
{
throw new ArgumentNullException(nameof(operationHandlers));
}
if (converter is null)
{
throw new ArgumentNullException(nameof(converter));
}
_opHandlers = operationHandlers.ToArray();
_fieldHandlers = fieldHandlers.ToArray();
_converter = converter;
_inMemory = inMemory;
Closures.Push(new QueryableClosure(source, "r", _inMemory));
}
public SerializedMessageHandler(RemoteMessageDispatcher remoteMessageDispatcher)
{
Assert(remoteMessageDispatcher != null);
_remoteMessageDispatcher = remoteMessageDispatcher;
_typeConversion = _remoteMessageDispatcher._typeConversion;
}
private static IError CheckForNullFieldViolation(
InputObjectType type,
object value,
ISet <object> processed,
ITypeConversion converter,
Func <string, IError> createError)
{
if (!processed.Add(value))
{
return(null);
}
foreach (InputField field in type.Fields)
{
object obj = (type.ClrType != null &&
!type.ClrType.IsInstanceOfType(value) &&
converter.TryConvert(typeof(object), type.ClrType,
value, out object converted))
? converted
: value;
object fieldValue = field.GetValue(obj);
IError error = CheckForNullValueViolation(
field.Type, fieldValue, processed,
converter, createError);
if (error != null)
{
return(error);
}
}
return(null);
}
private static bool TryConvertLeafValue(
ITypeConversion converter,
IHasClrType leafType,
object value,
out object scalarValue)
{
try
{
if (value is null)
{
scalarValue = value;
return(true);
}
if (!leafType.ClrType.IsInstanceOfType(value))
{
return(converter.TryConvert(
typeof(object),
leafType.ClrType,
value,
out scalarValue));
}
scalarValue = value;
return(true);
}
catch
{
scalarValue = null;
return(false);
}
}
protected override void OnCompleteType(
ICompletionContext context,
InputObjectTypeDefinition definition)
{
base.OnCompleteType(context, definition);
ITypeConversion typeConversion =
context.Services.GetTypeConversion();
_objectToValueConverter =
new InputObjectToObjectValueConverter(typeConversion);
_valueToObjectConverter =
new ObjectValueToInputObjectConverter(typeConversion);
_objectToDictionary =
new InputObjectToDictionaryConverter(typeConversion);
_dictionaryToObject =
new DictionaryToInputObjectConverter(typeConversion);
SyntaxNode = definition.SyntaxNode;
var fields = new List <InputField>();
OnCompleteFields(context, definition, fields);
Fields = new FieldCollection <InputField>(fields);
FieldInitHelper.CompleteFields(context, definition, Fields);
}
public IReadOnlyDictionary <NameString, ArgumentValue> CoerceArguments(
IVariableValueCollection variables,
ITypeConversion converter)
{
if (_hasArgumentErrors)
{
throw new QueryException(_args.Values.Select(t => t.Error));
}
if (_vars == null)
{
return(_args);
}
var args = _args.ToDictionary(t => t.Key, t => t.Value);
foreach (KeyValuePair <NameString, ArgumentVariableValue> var in _vars)
{
IError error = null;
if (variables.TryGetVariable(
var.Value.VariableName,
out object value))
{
value = var.Value.CoerceValue(value);
}
else
{
value = var.Value.DefaultValue;
if (var.Value.Type.NamedType().IsLeafType() &&
value is IValueNode literal)
{
value = var.Value.Type.ParseLiteral(literal);
}
if (var.Value.Type.IsNonNullType() &&
(value is null || value is NullValueNode))
{
error = ErrorBuilder.New()
.SetMessage(string.Format(
CultureInfo.InvariantCulture,
TypeResources.ArgumentValueBuilder_NonNull,
var.Key,
TypeVisualizer.Visualize(var.Value.Type)))
.AddLocation(Selection)
.SetExtension(_argumentProperty, Path.New(var.Key))
.SetPath(_path)
.Build();
}
}
if (error is null)
{
ValueKind kind = ValueKind.Unknown;
if (value is IValueNode literal)
{
kind = literal.GetValueKind();
protected override void OnCompleteType(
ICompletionContext context,
IDictionary <string, object> contextData)
{
_converter = context.Services.GetTypeConversion();
_objectToDictConverter = new ObjectToDictionaryConverter(_converter);
base.OnCompleteType(context, contextData);
}
public SelectionVisitor(
IResolverContext context,
ITypeConversion converter,
SelectionMiddlewareContext selectionMiddlewareContext)
: base(context)
{
_converter = converter;
_selectionMiddlewareContext = selectionMiddlewareContext;
}
public VariableCollection(
ITypeConversion converter,
Dictionary <string, object> variables)
{
_converter = converter
?? throw new ArgumentNullException(nameof(converter));
_variables = variables
?? throw new ArgumentNullException(nameof(variables));
}
public SelectionMiddleware(
FieldDelegate next,
SelectionMiddlewareContext context,
ITypeConversion converter)
{
_next = next ?? throw new ArgumentNullException(nameof(next));
_context = context ?? throw new ArgumentNullException(nameof(context));
_converter = converter ?? TypeConversion.Default;
}
public bool TryHandle(
FilterOperation operation,
IInputType type,
IValueNode value,
Expression instance,
ITypeConversion converter,
out Expression expression)
{
if (operation.Type == typeof(IComparable) &&
type.IsInstanceOfType(value))
{
MemberExpression property =
Expression.Property(instance, operation.Property);
switch (operation.Kind)
{
case FilterOperationKind.In:
expression = FilterExpressionBuilder.In(
property,
operation.Property.PropertyType,
ParseValue());
return(true);
case FilterOperationKind.NotIn:
expression = FilterExpressionBuilder.Not(
FilterExpressionBuilder.In(
property,
operation.Property.PropertyType,
ParseValue())
);
return(true);
}
}
expression = null;
return(false);
object ParseValue()
{
var parsedValue = type.ParseLiteral(value);
Type elementType = type.ElementType().ToClrType();
if (operation.Property.PropertyType != elementType)
{
Type listType = typeof(List <>).MakeGenericType(
operation.Property.PropertyType);
parsedValue = converter.Convert(
typeof(object),
listType,
parsedValue);
}
return(parsedValue);
}
}
public async Task ApplyFilterAsync <T>(
FieldDelegate next,
ITypeConversion converter,
IMiddlewareContext context)
{
if (GetOrCreateConfiguration().VisitorDefinition is { } definition)
{
await definition.ApplyFilter <T>(this, next, converter, context)
.ConfigureAwait(false);
}
private static Optional <T> CreateOptionalValue <T>(
IReadOnlyDictionary <string, object> values,
string fieldName,
ITypeConversion converter)
{
if (values.TryGetValue(fieldName, out object o))
{
return(o is T casted ? casted : converter.Convert <object, T>(o));
}
return(default);
public FilterMiddleware(
FieldDelegate next,
FilterMiddlewareContext contextData,
ITypeConversion converter)
{
_next = next ?? throw new ArgumentNullException(nameof(next));
_converter = converter ?? TypeConversion.Default;
_contextData = contextData ??
throw new ArgumentNullException(nameof(contextData));
}
public VariableValueBuilder(
ISchema schema,
OperationDefinitionNode operation)
{
_schema = schema
?? throw new ArgumentNullException(nameof(schema));
_operation = operation
?? throw new ArgumentNullException(nameof(operation));
_converter = _schema.Services.GetTypeConversion();
}
public FieldCollector(
FragmentCollection fragments,
Func <ObjectField, FieldNode, FieldDelegate> middlewareFactory,
ITypeConversion converter)
{
_fragments = fragments
?? throw new ArgumentNullException(nameof(fragments));
_factory = middlewareFactory
?? throw new ArgumentNullException(nameof(middlewareFactory));
_converter = converter
?? throw new ArgumentNullException(nameof(converter));
}
public static TTo Convert <TFrom, TTo>(
this ITypeConversion typeConversion,
object source)
{
if (typeConversion == null)
{
throw new ArgumentNullException(nameof(typeConversion));
}
return((TTo)typeConversion.Convert(
typeof(TFrom), typeof(TTo), source));
}
public QueryableFilterVisitor(
InputObjectType initialType,
Type source,
ITypeConversion converter)
: this(
initialType,
source,
converter,
ExpressionOperationHandlers.All,
ExpressionFieldHandlers.All)
{
}
public SelectionVisitorContext(
IResolverContext context,
ITypeConversion conversion,
FieldSelection fieldSelection,
SelectionMiddlewareContext selectionMiddlewareContext)
{
Conversion = conversion;
FieldSelection = fieldSelection;
SelectionContext = selectionMiddlewareContext;
_context = context;
_arguments = fieldSelection.CoerceArguments(context.Variables, conversion);
}
public static object Parse(
InputObjectType type,
ObjectValueNode value,
ITypeConversion converter)
{
var dict = new Dictionary <string, object>();
Parse(type, value, dict, converter);
SetDefaultValues(type, dict, converter);
return(dict);
}
public static Dictionary <string, object> Deserialize(
InputObjectType type,
IReadOnlyDictionary <string, object> value,
ITypeConversion converter)
{
var dict = new Dictionary <string, object>();
Deserialize(type, value, dict, converter);
SetDefaultValues(type, dict, converter);
return(dict);
}
public CompleteValueContext(
ITypeConversion converter,
IFieldHelper fieldHelper,
Action <ResolverTask> enqueueTask)
{
Converter = converter
?? throw new ArgumentNullException(nameof(converter));
_fieldHelper = fieldHelper
?? throw new ArgumentNullException(nameof(fieldHelper));
_enqueueTask = enqueueTask
?? throw new ArgumentNullException(nameof(enqueueTask));
}
public SelectionVisitorContext(
IResolverContext context,
ITypeConversion conversion,
IPreparedSelection fieldSelection)
{
Conversion = conversion;
FieldSelection = fieldSelection;
_context = context;
_arguments = CoerceArguments(
fieldSelection.Arguments,
context.Variables,
context.Path);
}
public QueryableFilterVisitor(
InputObjectType initialType,
Type source,
ITypeConversion converter)
: base(initialType)
{
_parameter = Expression.Parameter(source, _parameterName);
_opHandlers = ExpressionOperationHandlers.All;
_converter = converter;
Level.Push(new Queue <Expression>());
Instance.Push(_parameter);
}
public void Register_TypeConverter_As_Service()
{
// arrange
var services = new ServiceCollection();
// act
services.AddTypeConverter <IntToStringConverter>();
// assert
ITypeConversion conversion =
services.BuildServiceProvider().GetService <ITypeConversion>();
Assert.Equal("123_123", conversion.Convert <int, string>(123));
}
public QueryableFilterVisitorContext(
InputObjectType initialType,
Type source,
ITypeConversion converter,
bool inMemory)
: this(
initialType,
source,
ExpressionOperationHandlers.All,
ExpressionFieldHandlers.All,
converter,
inMemory)
{
}
async Task <object> INodeResolver.ResolveAsync(
IResolverContext context, object id)
{
if (id is TId c)
{
return(await ResolveAsync(context, c).ConfigureAwait(false));
}
ITypeConversion typeConversion =
context.Service <IServiceProvider>().GetTypeConversion();
c = typeConversion.Convert <object, TId>(id);
return(await ResolveAsync(context, c).ConfigureAwait(false));
}
