private static void ResolveScopedVariableArguments( IResolverContext context, NameString schemaName, SelectionPathComponent component, IOutputField field, ICollection <Delegation.VariableValue> variables, ExtractFieldQuerySyntaxRewriter rewriter) { foreach (ArgumentNode argument in component.Arguments) { if (!field.Arguments.TryGetField(argument.Name.Value, out IInputField arg)) { throw new QueryException( ErrorBuilder.New() .SetMessage( StitchingResources.DelegationMiddleware_ArgumentNotFound, argument.Name.Value) .SetExtension("argument", argument.Name.Value) .SetCode(ErrorCodes.ArgumentNotFound) .Build()); } if (argument.Value is ScopedVariableNode sv) { Delegation.VariableValue variable = _resolvers.Resolve(context, sv, arg.Type); IValueNode value = rewriter.RewriteValueNode( schemaName, arg.Type, variable.Value); variables.Add(variable.WithValue(value)); } } }
public ITypeDefinitionNode Rewrite( ISchemaInfo schema, ITypeDefinitionNode typeDefinition) { if (typeDefinition.Name.Value.Equals("Query") && typeDefinition is ObjectTypeDefinitionNode objectType) { var path = new SelectionPathComponent( new NameNode("foo"), new[] { new ArgumentNode( "a", new ScopedVariableNode( ScopeNames.ContextData, "foo_a")) }); Dictionary <string, FieldDefinitionNode> fields = objectType.Fields.ToDictionary(t => t.Name.Value); fields["foo"] = fields["foo"] .WithArguments(Array.Empty <InputValueDefinitionNode>()) .AddDelegationPath("someSchema", path); return(objectType.WithFields(fields.Values.ToArray())); } return(typeDefinition); }
private static void ResolveScopedVariableArguments( IResolverContext context, SelectionPathComponent component, IOutputField field, ICollection <VariableValue> variables) { foreach (ArgumentNode argument in component.Arguments) { if (!field.Arguments.TryGetField(argument.Name.Value, out IInputField arg)) { throw new QueryException(new Error { Message = string.Format( CultureInfo.InvariantCulture, StitchingResources .DelegationMiddleware_ArgumentNotFound, argument.Name.Value) }); } if (argument.Value is ScopedVariableNode sv) { variables.Add(_resolvers.Resolve( context, sv, arg.Type.ToTypeNode())); } } }
private static IReadOnlyList <VariableValue> ResolveScopedVariables( IResolverContext context, NameString schemaName, OperationType operationType, IEnumerable <SelectionPathComponent> components) { IStitchingContext stitchingContext = context.Service <IStitchingContext>(); ISchema remoteSchema = stitchingContext.GetRemoteSchema(schemaName); IComplexOutputType type = remoteSchema.GetOperationType(operationType); var variables = new List <VariableValue>(); SelectionPathComponent[] comps = components.Reverse().ToArray(); for (int i = 0; i < comps.Length; i++) { SelectionPathComponent component = comps[i]; if (!type.Fields.TryGetField(component.Name.Value, out IOutputField field)) { throw new QueryException(new Error { Message = string.Format( CultureInfo.InvariantCulture, StitchingResources .DelegationMiddleware_PathElementInvalid, component.Name.Value, type.Name) }); } ResolveScopedVariableArguments( context, component, field, variables); if (i + 1 < comps.Length) { if (!field.Type.IsComplexType()) { throw new QueryException(new Error { Message = StitchingResources .DelegationMiddleware_PathElementTypeUnexpected }); } type = (IComplexOutputType)field.Type.NamedType(); } } return(variables); }
private FieldNode CreateSelection( FieldNode previous, SelectionPathComponent next) { var selectionSet = new SelectionSetNode( null, new List <ISelectionNode> { previous }); return(CreateSelection(selectionSet, next, null)); }
private static void ResolveScopedVariableArguments( IResolverContext context, SelectionPathComponent component, IOutputField field, ICollection <VariableValue> variables) { ITypeConversion typeConversion = context.Service <IServiceProvider>() .GetTypeConversion(); foreach (ArgumentNode argument in component.Arguments) { if (!field.Arguments.TryGetField(argument.Name.Value, out IInputField arg)) { throw new QueryException(new Error { Message = string.Format( CultureInfo.InvariantCulture, StitchingResources .DelegationMiddleware_ArgumentNotFound, argument.Name.Value) }); } if (argument.Value is ScopedVariableNode sv) { VariableValue variable = _resolvers.Resolve(context, sv, arg.Type.ToTypeNode()); object value = variable.Value; if (!arg.Type.IsInstanceOfType(value)) { value = ConvertValue(typeConversion, arg.Type, value); } variable = new VariableValue ( variable.Name, variable.Type, arg.Type.Serialize(value), variable.DefaultValue ); variables.Add(variable); } } }
private FieldNode CreateSelection( SelectionSetNode selectionSet, SelectionPathComponent next, string alias) { var aliasNode = string.IsNullOrEmpty(alias) ? null : new NameNode(alias); return(new FieldNode ( null, next.Name, aliasNode, Array.Empty <DirectiveNode>(), RewriteVariableNames(next.Arguments).ToList(), selectionSet )); }
private DocumentNode CreateDelegationQuery( OperationType operation, Stack <SelectionPathComponent> path, FieldNode selection) { FieldNode current = selection; if (path.Any()) { string responseName = current.Alias == null ? current.Name.Value : current.Alias.Value; SelectionPathComponent component = path.Pop(); string alias = component.Name.Value.EqualsOrdinal(responseName) ? null : responseName; current = CreateSelection( current.SelectionSet, component, responseName); while (path.Any()) { current = CreateSelection(current, path.Pop()); } } return(new DocumentNode( null, new List <IDefinitionNode> { CreateOperation(operation, current) })); }
private static void ResolveScopedVariableArguments( IResolverContext context, SelectionPathComponent component, IOutputField field, ICollection <VariableValue> variables) { ITypeConversion typeConversion = context.Service <IServiceProvider>() .GetTypeConversion(); foreach (ArgumentNode argument in component.Arguments) { if (!field.Arguments.TryGetField(argument.Name.Value, out IInputField arg)) { throw new QueryException(new Error { Message = string.Format( CultureInfo.InvariantCulture, StitchingResources .DelegationMiddleware_ArgumentNotFound, argument.Name.Value) }); } if (argument.Value is ScopedVariableNode sv) { VariableValue variable = _resolvers.Resolve(context, sv, arg.Type.ToTypeNode()); if (context.Schema.TryGetType( arg.Type.NamedType().Name, out INamedInputType inputType)) { object value = variable.Value; if (!inputType.IsInstanceOfType(value)) { value = typeConversion.Convert( typeof(object), inputType.ClrType, value); } variable = new VariableValue ( variable.Name, variable.Type, inputType.Serialize(value), variable.DefaultValue ); } else { // TODO : resources throw new QueryException( ErrorBuilder.New() .SetMessage(string.Format( CultureInfo.InvariantCulture, "Serialize argument {0} of type {1}.", arg.Name, arg.Type.Visualize())) .SetPath(context.Path) .Build()); } variables.Add(variable); } } }