public ListType(IType elementType) : base(TypeKind.List) { if (elementType == null) { throw new ArgumentNullException(nameof(elementType)); } if (elementType.IsListType()) { throw new ArgumentException( "It is not possible to put a list type into list type.", nameof(elementType)); } _isInputType = elementType.IsInputType(); _inputType = elementType as IInputType; ElementType = elementType; if (_isInputType && _inputType != null) { NativeType = CreateListType(_inputType.NativeType); } }
private void VisitValue( IInputType type, object obj, Action <object> setValue, ISet <object> processed) { if (obj is null) { setValue(null); } else if (type.IsListType()) { VisitList( (ListType)type.ListType(), obj, setValue, processed); } else if (type.IsLeafType()) { VisitLeaf( (INamedInputType)type.NamedType(), obj, setValue, processed); } else if (type.IsInputObjectType()) { VisitInputObject( (InputObjectType)type.NamedType(), obj, setValue, processed); } else { throw new NotSupportedException(); } }
public Dictionary <string, ArgumentValue> CoerceArgumentValues( ObjectType objectType, FieldSelection fieldSelection, VariableCollection variables) { Dictionary <string, ArgumentValue> coercedArgumentValues = new Dictionary <string, ArgumentValue>(); Dictionary <string, IValueNode> argumentValues = fieldSelection.Node.Arguments .Where(t => t.Value != null) .ToDictionary(t => t.Name.Value, t => t.Value); foreach (InputField argument in fieldSelection.Field.Arguments.Values) { string argumentName = argument.Name; IInputType argumentType = argument.Type; IValueNode defaultValue = argument.DefaultValue; object argumentValue = CoerceArgumentValue( argumentName, argumentType, defaultValue, variables, argumentValues); if (argumentType is NonNullType && argumentValue == null) { throw new QueryException(new ArgumentError( $"The argument type of '{argumentName}' is a non-null type.", argumentName, fieldSelection.Node)); } coercedArgumentValues[argumentName] = new ArgumentValue( argumentType, argumentType.NativeType, argumentValue); } return(coercedArgumentValues); }
public static bool EndsWith( FilterOperation operation, IInputType type, IValueNode value, IQueryableFilterVisitorContext context, [NotNullWhen(true)] out Expression?result) { object parsedValue = type.ParseLiteral(value); if (parsedValue == null) { context.ReportError( ErrorHelper.CreateNonNullError(operation, type, value, context)); result = null; return(false); } if (operation.Type == typeof(string) && type.IsInstanceOfType(value)) { Expression property = GetProperty(operation, context); result = FilterExpressionBuilder.EndsWith(property, parsedValue); return(true); } else { throw new InvalidOperationException(); } }
private static object ConvertValue( ITypeConversion converter, IInputType type, object value) { Type sourceType = typeof(object); if (type.IsListType() && value is IEnumerable <object> e) { if (e.Any()) { Type elementType = e.FirstOrDefault()?.GetType(); if (elementType != null) { sourceType = typeof(IEnumerable <>).MakeGenericType(elementType); } } else { return(Activator.CreateInstance(type.ClrType)); } } return(converter.Convert(sourceType, type.ClrType, value)); }
public bool TryHandle( FilterOperation operation, IInputType type, IValueNode value, Expression instance, ITypeConversion converter, out Expression expression) { if (operation.Type == typeof(bool) && type.IsInstanceOfType(value)) { 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); }
protected override void VisitList( IList <object> list, ConverterContext context) { if (!context.InputType.IsListType()) { throw new QueryException(ErrorBuilder.New() .SetMessage($"The value of {context.Name} has a wrong structure.") .SetCode(ErrorCodes.Execution.InvalidType) .AddLocation(context.Node) .Build()); } IInputType originalType = context.InputType; ListType listType = context.InputType.ListType(); context.InputType = (IInputType)listType.ElementType; var items = new IValueNode[list.Count]; for (int i = 0; i < list.Count; i++) { context.Object = null; Visit(list[i], context); items[i] = (IValueNode)context.Object; } context.Object = new ListValueNode(items); context.InputType = originalType; }
private static void AddVariables( IResolverContext context, NameString schemaName, IQueryRequestBuilder builder, DocumentNode query, IEnumerable <VariableValue> variableValues) { OperationDefinitionNode operation = query.Definitions.OfType <OperationDefinitionNode>().First(); var usedVariables = new HashSet <string>( operation.VariableDefinitions.Select(t => t.Variable.Name.Value)); foreach (VariableValue variableValue in variableValues) { if (usedVariables.Contains(variableValue.Name)) { object value = variableValue.Value; if (context.Schema.TryGetType( variableValue.Type.NamedType().Name.Value, out InputObjectType inputType)) { IInputType wrapped = WrapType(inputType, variableValue.Type); value = ObjectVariableRewriter.RewriteVariable( schemaName, wrapped, value); } builder.AddVariableValue(variableValue.Name, value); } } }
private static object ParseListType( IInputType sourceType, Type targetType, IValueNode literal) { var sourceElementType = (IInputType)sourceType.ElementType(); Type targetElementType = GetListElementType(targetType); List <object> items = new List <object>(); if (literal is ListValueNode lv) { foreach (IValueNode element in lv.Items) { items.Add(ParseLiteral( sourceElementType, targetElementType, element)); } } else { items.Add(ParseLiteral( sourceElementType, targetElementType, literal)); } return(CreateListObject(targetType, targetElementType, items)); }
internal void CompleteInputField( ITypeRegistry typeRegistry, Action <SchemaError> reportError, INamedType parentType) { _type = _typeFactory(typeRegistry); if (_type == null) { reportError(new SchemaError( $"The type of the input field {Name} is null.", parentType)); } if (_defaultValueFactory == null) { DefaultValue = new NullValueNode(null); } else { DefaultValue = _defaultValueFactory(typeRegistry); } if (parentType is InputObjectType && Property == null && typeRegistry.TryGetTypeBinding(parentType, out InputObjectTypeBinding binding) && binding.Fields.TryGetValue(Name, out InputFieldBinding fieldBinding)) { Property = fieldBinding.Property; } }
public VariableValue Resolve( IResolverContext context, ScopedVariableNode variable, IInputType targetType) { if (context is null) { throw new ArgumentNullException(nameof(context)); } if (variable is null) { throw new ArgumentNullException(nameof(variable)); } if (_resolvers.TryGetValue(variable.Scope.Value, out IScopedVariableResolver? resolver)) { return(resolver.Resolve(context, variable, targetType)); } throw ThrowHelper.RootScopedVariableResolver_ScopeNotSupported( variable.Scope.Value, context.FieldSelection, context.Path); }
public bool TryHandle( FilterOperation operation, IInputType type, IValueNode value, Expression instance, ITypeConversion converter, out Expression expression) { if (operation.Type == typeof(string) && (value is StringValueNode || value.IsNull())) { object parsedValue = type.ParseLiteral(value); MemberExpression property = Expression.Property(instance, operation.Property); return(TryCreateExpression( operation, property, parsedValue, out expression)); } expression = null; return(false); }
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 (!ScopeNames.Fields.Equals(variable.Scope.Value)) { throw new ArgumentException( StitchingResources .FieldScopedVariableResolver_CannotHandleVariable, nameof(variable)); } if (context.ObjectType.Fields.TryGetField(variable.Name.Value, out IObjectField? field)) { object parent = context.Parent <object>(); IValueNode?valueLiteral = null; if (parent is IReadOnlyDictionary <string, object> dict && dict.TryGetValue(field.Name, out object?value)) { if (value is IValueNode v) { valueLiteral = v; } else if (field.Type.IsInputType() && field.Type is IInputType type) { valueLiteral = type.ParseValue(value); } } return(new VariableValue ( variable.ToVariableName(), targetType.ToTypeNode(), valueLiteral ?? NullValueNode.Default, null )); } throw new QueryException(ErrorBuilder.New() .SetMessage( StitchingResources.FieldScopedVariableResolver_InvalidFieldName, variable.Name.Value) .SetCode(ErrorCodes.Stitching.FieldNotDefined) .SetPath(context.Path) .AddLocation(context.FieldSelection) .Build()); }
public static object RewriteVariable( NameString schemaName, IInputType type, object value) { return(RewriteVariableValue(in schemaName, type, value)); }
private static IValueNode ParseValue( HashSet <object> processed, IInputType inputType, object obj) { if (inputType.IsNonNullType()) { return(ParseValue(processed, (IInputType)inputType.InnerType(), obj)); } else if (inputType.IsListType()) { return(ParseList(processed, inputType, obj)); } else if (inputType.IsScalarType() || inputType.IsEnumType()) { return(ParseScalar(inputType, obj)); } else if (inputType.IsInputObjectType() && !processed.Contains(obj)) { return(ParseObject(processed, (InputObjectType)inputType, obj)); } else { return(NullValueNode.Default); } }
public bool TryHandle( FilterOperation operation, IInputType type, IValueNode value, IQueryableFilterVisitorContext context, [NotNullWhen(true)] out Expression?expression) { if (operation.Type == typeof(bool) && type.IsInstanceOfType(value)) { Expression property = context.GetInstance(); if (!operation.IsSimpleArrayType()) { property = Expression.Property(context.GetInstance(), 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.NotEquals( property, parserValue); return(true); } } expression = null; return(false); }
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); var parsedValue = type.ParseLiteral(value); if (!operation.Property.PropertyType.IsInstanceOfType(parsedValue)) { parsedValue = converter.Convert( typeof(object), operation.Property.PropertyType, parsedValue); } return(TryCreateExpression( operation, property, parsedValue, out expression)); } expression = null; return(false); }
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 (_resolvers.TryGetValue(variable.Scope.Value, out IScopedVariableResolver resolver)) { return(resolver.Resolve(context, variable, targetType)); } throw new QueryException(ErrorBuilder.New() .SetMessage( StitchingResources.RootScopedVariableResolver_ScopeNotSupported, variable.Scope.Value) .SetCode(ErrorCodes.ScopeNotDefined) .SetPath(context.Path) .AddLocation(context.FieldSelection) .Build()); }
public bool TryHandle( FilterOperation operation, IInputType type, IValueNode value, IQueryableFilterVisitorContext context, out Expression expression) { if (operation.Type == typeof(string) && type.IsInstanceOfType(value)) { object parsedValue = type.ParseLiteral(value); Expression property = context.GetInstance(); if (!operation.IsSimpleArrayType()) { property = Expression.Property( context.GetInstance(), operation.Property); } return(TryCreateExpression( operation, property, parsedValue, out expression)); } expression = null; return(false); }
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)); } }
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); } }
public IValueNode Convert(object from, IInputType type, VariableDefinitionNode variable) { if (from == null) { throw new ArgumentNullException(nameof(from)); } if (type is null) { throw new ArgumentNullException(nameof(type)); } if (variable is null) { throw new ArgumentNullException(nameof(variable)); } var context = new ConverterContext { InputType = type, Node = variable, Name = "$" + variable.Variable.Name.Value }; Visit(from, context); return((IValueNode)context.Object); }
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 ArgumentValue(IInputType type, IError error) { Type = type ?? throw new ArgumentNullException(nameof(type)); Error = error ?? throw new ArgumentNullException(nameof(error)); Value = null; Literal = null; }
internal static IValueNode?CompleteDefaultValue( ITypeCompletionContext context, ArgumentDefinition argumentDefinition, IInputType argumentType, FieldCoordinate argumentCoordinate) { try { return(argumentDefinition.RuntimeDefaultValue != null ? context.DescriptorContext.InputFormatter.FormatValue( argumentDefinition.RuntimeDefaultValue, argumentType, Path.Root) : 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 ArgumentValue(IInputType type, object value) { Type = type ?? throw new ArgumentNullException(nameof(type)); Value = value; Error = null; Literal = null; }
public Variable( string name, IInputType type, object defaultValue) : this(name, type, defaultValue, defaultValue) { }
private static void HandleFieldValue( HashSet <object> processed, Dictionary <string, IValueNode> fieldValues, InputField field, IInputType fieldType, object fieldValue) { if (fieldValue == null) { fieldValues[field.Name] = NullValueNode.Default; } else if (fieldType.IsNonNullType()) { HandleFieldValue(processed, fieldValues, field, (IInputType)fieldType.InnerType(), fieldValue); } else if (fieldType.IsListType()) { fieldValues[field.Name] = ParseList( processed, fieldType, fieldValue); } else if (fieldType.IsScalarType() || fieldType.IsEnumType()) { fieldValues[field.Name] = ParseScalar( fieldType, fieldValue); } else if (fieldType.IsInputObjectType() && !processed.Contains(fieldValue)) { fieldValues[field.Name] = ParseObject( processed, (InputObjectType)fieldType, fieldValue); } }
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); } }
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)); }
/// <summary> /// Creates a new feature. /// </summary> /// <param name="name">Unique name of the feature</param> /// <param name="defaultValue">Default value</param> /// <param name="displayName">Display name of the feature</param> /// <param name="description">A brief description for this feature</param> /// <param name="scope">Feature scope</param> /// <param name="inputType">Input type</param> public Feature Create(string name, string defaultValue, ILocalizableString displayName = null, ILocalizableString description = null, FeatureScopes scope = FeatureScopes.All, IInputType inputType = null) { if (Features.ContainsKey(name)) { throw new OwException("There is already a feature with name: " + name); } var feature = new Feature(name, defaultValue, displayName, description, scope, inputType); Features[feature.Name] = feature; return feature; }
/// <summary> /// Creates a new feature. /// </summary> /// <param name="name">Unique name of the feature</param> /// <param name="defaultValue">Default value</param> /// <param name="displayName">Display name of the feature</param> /// <param name="description">A brief description for this feature</param> /// <param name="scope">Feature scope</param> /// <param name="inputType">Input type</param> public Feature(string name, string defaultValue, ILocalizableString displayName = null, ILocalizableString description = null, FeatureScopes scope = FeatureScopes.All, IInputType inputType = null) { if (name == null) { throw new ArgumentNullException("name"); } Name = name; DisplayName = displayName; Description = description; Scope = scope; DefaultValue = defaultValue; InputType = inputType ?? new CheckboxInputType(); _children = new List<Feature>(); Attributes = new Dictionary<string, object>(); }
/// <summary> /// Adds a child feature. /// </summary> /// <returns>Returns newly created child feature</returns> public Feature CreateChildFeature(string name, string defaultValue, ILocalizableString displayName = null, ILocalizableString description = null, FeatureScopes scope = FeatureScopes.All, IInputType inputType = null) { var feature = new Feature(name, defaultValue, displayName, description, scope, inputType) { Parent = this }; _children.Add(feature); return feature; }