public static IEnumerable <IArgumentValue> AllArgumentsSafely(this IResolverContext?context) { var argNames = AllArgumentSchemaNamesSafely(context); var argPairs = argNames.Select(n => { try { var argLiteral = context?.ArgumentLiteral <IValueNode>(n); var argValue = argLiteral != null && argLiteral.Location != null && argLiteral.Value != null ? argLiteral.Value : null; return(new ArgumentValue(n, argValue)); } catch { //Do nothing, if exception is thrown, as Argument just doesn't exist as expected. } return(new ArgumentValue(n, null)); } ) .Where(a => a.Value != null); return(argPairs); }
public static List <ISortOrderField>?GetSortingArgsSafely(this IResolverContext context, string sortOrderArgName = null !) { var results = new List <ISortOrderField>(); //Unfortunately the Try/Catch is required to make this safe for easier coding when the argument is not specified, // because the ResolverContext doesn't expose a method to check if an argument exists... try { var sortArgName = sortOrderArgName ?? SortConventionDefinition.DefaultArgumentName; //Get Sort Argument Fields and current Values... //NOTE: In order to correctly be able to Map names from GraphQL Schema to property/member names // we need to get both the Fields (Schema) and the current order values... //NOTE: Not all Queries have Fields (e.g. no Selections, just a literal result), so .Field may // throw internal NullReferenceException, hence we have the wrapper Try/Catch. IInputField sortArgField = context.Field.Arguments[sortArgName]; ObjectValueNode sortArgValue = context.ArgumentLiteral <ObjectValueNode>(sortArgName); //Validate that we have some sort args specified and that the Type is correct (ListType of SortInputType values)... //NOTE: The Following processing logic was adapted from 'QueryableSortProvider' implementation in HotChocolate.Data core. //FIX: The types changed in v11.0.1/v11.0.2 the Sort Field types need to be checked with IsNull() method, and // then against NonNullType.NamedType() is ISortInputType instead. if (!sortArgValue.IsNull() && sortArgField.Type is ListType lt && lt.ElementType is NonNullType nn && nn.NamedType() is ISortInputType sortInputType) { //Create a Lookup for the Fields... var sortFieldLookup = sortInputType.Fields.OfType <SortField>().ToLookup(f => f.Name.ToString().ToLower()); //Now only process the values provided, but initialize with the corresponding Field (metadata) for each value... var sortOrderFields = sortArgValue.Fields.Select( f => new SortOrderField( sortFieldLookup[f.Name.ToString().ToLower()].FirstOrDefault(), f.Value.ToString() ) ); results.AddRange(sortOrderFields); } return(results); } catch { //Always safely return at least an Empty List to help minimize Null Reference issues. return(results); } }
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.Arguments.Equals(variable.Scope.Value)) { throw new ArgumentException( StitchingResources.ArgumentScopedVariableResolver_CannotHandleVariable, nameof(variable)); } IInputField?argument = context.Field.Arguments.FirstOrDefault( t => t.Name.Value.EqualsOrdinal(variable.Name.Value)); if (argument == null) { throw new QueryException(ErrorBuilder.New() .SetMessage( StitchingResources.ArgumentScopedVariableResolver_InvalidArgumentName, variable.Name.Value) .SetCode(ErrorCodes.Stitching.ArgumentNotDefined) .SetPath(context.Path) .AddLocation(context.FieldSelection) .Build()); } return(new VariableValue ( variable.ToVariableName(), argument.Type.ToTypeNode(), context.ArgumentLiteral <IValueNode>(variable.Name.Value), argument.Type.IsNonNullType() && argument.DefaultValue.IsNull() ? null : argument.DefaultValue )); }
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 (!ScopeNames.Arguments.Equals(variable.Scope.Value)) { throw new ArgumentException( ArgumentScopedVariableResolver_CannotHandleVariable, nameof(variable)); } IInputField?argument = context.Field.Arguments.FirstOrDefault( t => t.Name.Value.EqualsOrdinal(variable.Name.Value)); if (argument is null) { throw ArgumentScopedVariableResolver_InvalidArgumentName( variable.Name.Value, context.FieldSelection, context.Path); } return(new VariableValue ( variable.ToVariableName(), argument.Type.ToTypeNode(), context.ArgumentLiteral <IValueNode>(variable.Name.Value), argument.Type.IsNonNullType() && argument.DefaultValue.IsNull() ? null : argument.DefaultValue )); }
public ScopedVariableValue 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 (!ScopeNames.Arguments.Equals(variable.Scope.Value)) { throw new ArgumentException( ArgumentScopedVariableResolver_CannotHandleVariable, nameof(variable)); } if (!context.Selection.Field.Arguments.TryGetField( variable.Name.Value, out IInputField? argument)) { throw ArgumentScopedVariableResolver_InvalidArgumentName( variable.Name.Value, context.Selection.SyntaxNode, context.Path); } return(new ScopedVariableValue ( variable.ToVariableName(), argument.Type.ToTypeNode(), context.ArgumentLiteral <IValueNode>(variable.Name.Value), argument.Type.IsNonNullType() && argument.DefaultValue.IsNull() ? null : argument.DefaultValue )); }
private static async ValueTask <object?> ResolveSingleNode( IResolverContext context, IIdSerializer serializer, NameString argumentName) { StringValueNode nodeId = context.ArgumentLiteral <StringValueNode>(argumentName); IdValue deserializedId = serializer.Deserialize(nodeId.Value); NameString typeName = deserializedId.TypeName; context.SetLocalValue(NodeId, nodeId.Value); context.SetLocalValue(InternalId, deserializedId.Value); context.SetLocalValue(InternalType, typeName); context.SetLocalValue(WellKnownContextData.IdValue, deserializedId); if (context.Schema.TryGetType <ObjectType>(typeName, out ObjectType? type) && type.ContextData.TryGetValue(NodeResolver, out var o) && o is FieldResolverDelegate resolver) { return(await resolver.Invoke(context).ConfigureAwait(false)); } return(null); }
private static async ValueTask <object?> ResolveManyNode( IResolverContext context, IIdSerializer serializer) { if (context.ArgumentKind(Ids) == ValueKind.List) { ListValueNode list = context.ArgumentLiteral <ListValueNode>(Ids); Task <object?>[] tasks = ArrayPool <Task <object?> > .Shared.Rent(list.Items.Count); var result = new object?[list.Items.Count]; try { for (var i = 0; i < list.Items.Count; i++) { context.RequestAborted.ThrowIfCancellationRequested(); // it is guaranteed that this is always a string literal. StringValueNode nodeId = (StringValueNode)list.Items[i]; IdValue deserializedId = serializer.Deserialize(nodeId.Value); NameString typeName = deserializedId.TypeName; context.SetLocalValue(NodeId, nodeId.Value); context.SetLocalValue(InternalId, deserializedId.Value); context.SetLocalValue(InternalType, typeName); context.SetLocalValue(WellKnownContextData.IdValue, deserializedId); tasks[i] = context.Schema.TryGetType <ObjectType>(typeName, out ObjectType? type) && type.ContextData.TryGetValue(NodeResolver, out var o) && o is FieldResolverDelegate resolver ? resolver.Invoke(context).AsTask() : _nullTask; } for (var i = 0; i < list.Items.Count; i++) { context.RequestAborted.ThrowIfCancellationRequested(); Task <object?> task = tasks[i]; if (task.IsCompleted) { if (task.Exception is null) { result[i] = task.Result; } else { result[i] = null; ReportError(context, i, task.Exception); } } else { try { result[i] = await task; } catch (Exception ex) { result[i] = null; ReportError(context, i, ex); } } } return(result); } finally { ArrayPool <Task <object?> > .Shared.Return(tasks); } } else { var result = new object?[1]; result[0] = await ResolveSingleNode(context, serializer, Ids); return(result); } }