private async Task <object> CompleteNonNullValueAsync( IExecutorContext executorContext, ObjectType objectType, IField field, ObjectType actualType, GraphQLFieldSelection selection, List <GraphQLFieldSelection> fields, object value, Dictionary <string, object> coercedVariableValues, NodePath path, NonNull nonNull) { var innerType = nonNull.WrappedType; var completedResult = await CompleteValueAsync( executorContext, objectType, field, innerType, actualType, selection, fields, value, coercedVariableValues, path).ConfigureAwait(false); if (completedResult == null) { throw new NullValueForNonNullException( objectType.Name, selection.Name.Value, path, selection); } return(completedResult); }
public virtual async Task <object> CompleteValueAsync(IExecutorContext executorContext, ObjectType objectType, IField field, IType fieldType, GraphQLFieldSelection selection, List <GraphQLFieldSelection> fields, Dictionary <string, object> coercedVariableValues, NodePath path) { object completedValue = null; completedValue = await CompleteValueAsync( executorContext, objectType, field, fieldType, ActualType, selection, fields, Value, coercedVariableValues, path).ConfigureAwait(false); return(completedValue); }
public static IReadOnlyDictionary <string, object> CoerceArgumentValues( ISchema schema, ObjectType objectType, GraphQLFieldSelection field, IReadOnlyDictionary <string, object> coercedVariableValues) { var coercedValues = new Dictionary <string, object>(); var argumentValues = field.Arguments?.ToList() ?? new List <GraphQLArgument>(); var fieldName = field.Name.Value; var argumentDefinitions = schema.GetField(objectType.Name, fieldName).Arguments; if (argumentDefinitions == null) { return(coercedValues); } foreach (var argumentDefinitionPair in argumentDefinitions) { var argumentDefinition = argumentDefinitionPair.Value; var argumentName = argumentDefinitionPair.Key; var argument = argumentValues.SingleOrDefault(a => a.Name.Value == argumentName); coercedValues[argumentName] = CoerceArgumentValue( schema, coercedVariableValues, argumentName, argumentDefinition, argument); } return(coercedValues); }
private IEdmEntitySet GetEntitySet(GraphQLFieldSelection selection) { var listGraphType = (ListGraphType)_schema.Query.Fields.Single(f => f.Name == selection.Name.Value).ResolvedType; Type entityType = listGraphType.ResolvedType.GetType().GetGenericArguments()[0]; return(OeEdmClrHelper.GetEntitySet(_edmModel, entityType)); }
public override GraphQLFieldSelection BeginVisitFieldSelection(GraphQLFieldSelection selection) { var type = this.GetUnderlyingType(this.GetLastType()); if (type != null) { var fieldName = selection.Name.Value; var fieldDef = this.GetField(type, fieldName); if (fieldDef == null) { var suggestedTypeNames = this.GetSuggestedTypeNames(this.Schema, type, fieldName); var suggestedFieldNames = suggestedTypeNames.Any() ? Enumerable.Empty <string>() : this.GetSuggestedFieldNames(this.Schema, type, fieldName); var errorMessage = this.ComposeErrorMessage( fieldName, type.Name, suggestedTypeNames, suggestedFieldNames); this.Errors.Add(new GraphQLException(errorMessage, new[] { selection })); } } return(base.BeginVisitFieldSelection(selection)); }
public static object Handle( IExecutorContext context, ObjectType objectType, string fieldName, IType fieldType, GraphQLFieldSelection fieldSelection, object completedValue, Exception error, NodePath path) { if (!(error is QueryExecutionException)) { error = new QueryExecutionException( "", error, path, fieldSelection); } if (fieldType is NonNull) { throw error; } context.AddError(error); return(completedValue); }
public override GraphQLFieldSelection BeginVisitFieldSelection(GraphQLFieldSelection selection) { this.fieldStack.Push(selection.Name.Value); this.argumentTypes.Clear(); if (selection.Name?.Value != null) { var arguments = this.translator.GetObjectTypeTranslatorFor(this.typeStack.Peek()).GetField(selection.Name.Value).Arguments; if (arguments != null) { foreach (var argument in this.translator.GetObjectTypeTranslatorFor(this.typeStack.Peek()).GetField(selection.Name.Value).Arguments) { this.argumentTypes.Add(argument.Key, argument.Value); } } } var obj = this.translator.GetObjectTypeTranslatorFor(this.typeStack.Peek()).GetField(selection.Name.Value).Type as GraphQLObjectType; if (obj != null) { this.typeStack.Push(obj); } return(base.BeginVisitFieldSelection(selection)); }
private async Task RegisterSubscription( GraphQLFieldSelection fieldSelection, GraphQLSubscriptionType type, GraphQLDocument document, FieldScope scope) { var fieldInfo = type.GetFieldInfo(fieldSelection.Name.Value) as GraphQLSubscriptionTypeFieldInfo; Expression <Func <object, bool> > filter = null; if (fieldInfo.Filter != null) { filter = entity => (bool)scope.InvokeWithArgumentsSync( fieldSelection.Arguments.ToList(), fieldInfo.Filter, entity); } await type.EventBus.Subscribe(EventBusSubscription.Create( fieldInfo.Channel, this.clientId, this.subscriptionId.Value, this.Operation?.Name?.Value ?? "Anonymous", this.variables, filter, this.ast)); }
private async Task <object> CompleteNonNullValueAsync( IExecutorContext executorContext, ObjectType objectType, IField field, ObjectType actualType, GraphQLFieldSelection selection, IReadOnlyCollection <GraphQLFieldSelection> fields, object value, NodePath path, NonNull nonNull) { var innerType = nonNull.OfType; var completedResult = await CompleteValueAsync( executorContext, objectType, field, innerType, actualType, selection, fields, value, path).ConfigureAwait(false); if (completedResult == null) { throw new NullValueForNonNullException( objectType.Name, selection.Name.Value, path, selection); } return(completedResult); }
public override GraphQLFieldSelection BeginVisitFieldSelection( GraphQLFieldSelection selection) { Tracker.EnterFieldSelection?.Invoke(selection); return(base.BeginVisitFieldSelection(selection)); }
private object CompleteValue(object input, GraphQLFieldSelection selection, IList <GraphQLArgument> arguments) { if (input == null) { return(null); } if (input is GraphQLObjectType) { return(this.CompleteObjectType((GraphQLObjectType)input, selection, arguments, this.parent)); } if (ReflectionUtilities.IsCollection(input.GetType())) { return(this.CompleteCollectionType((IEnumerable)input, selection, arguments)); } var schemaValue = this.typeTranslator.GetType(input.GetType()); if (schemaValue is GraphQLObjectType) { return(this.CompleteObjectType((GraphQLObjectType)schemaValue, selection, arguments, input)); } if (ReflectionUtilities.IsEnum(input.GetType())) { return(input.ToString()); } return(input); }
public override GraphQLFieldSelection EndVisitFieldSelection(GraphQLFieldSelection selection) { this.fieldStack.Pop(); this.argumentTypes.Clear(); return(base.EndVisitFieldSelection(selection)); }
public override GraphQLFieldSelection EndVisitFieldSelection(GraphQLFieldSelection selection) { this.fieldStack.Pop(); this.typeStack.Pop(); return(base.EndVisitFieldSelection(selection)); }
public virtual GraphQLFieldSelection BeginVisitFieldSelection(GraphQLFieldSelection selection) { BeginVisitNode(selection.Name); if (selection.Alias != null) { BeginVisitAlias((GraphQLName)BeginVisitNode(selection.Alias)); } if (selection.Arguments != null) { BeginVisitArguments(selection.Arguments); } if (selection.SelectionSet != null) { BeginVisitNode(selection.SelectionSet); } if (selection.Directives != null) { BeginVisitDirectives(selection.Directives); } return(EndVisitFieldSelection(selection)); }
private BinaryOperatorNode BuildFilterExpression(SingleResourceNode source, GraphQLFieldSelection selection) { BinaryOperatorNode compositeNode = null; IEdmEntityType entityType = source.NavigationSource.EntityType(); foreach (GraphQLArgument argument in selection.Arguments) { IEdmProperty edmProperty = FindEdmProperty(entityType, argument.Name.Value); var left = new SingleValuePropertyAccessNode(source, edmProperty); Object value = GetArgumentValue(edmProperty.Type, argument.Value); var right = new ConstantNode(value, ODataUriUtils.ConvertToUriLiteral(value, ODataVersion.V4)); var node = new BinaryOperatorNode(BinaryOperatorKind.Equal, left, right); compositeNode = ComposeExpression(compositeNode, node); } //foreach (ASTNode astNode in selection.SelectionSet.Selections) // if (astNode is GraphQLFieldSelection fieldSelection && fieldSelection.SelectionSet != null) // { // var navigationProperty = (IEdmNavigationProperty)FindEdmProperty(entityType, fieldSelection.Name.Value); // if (navigationProperty.Type is IEdmCollectionTypeReference) // continue; // var parentSource = new SingleNavigationNode(source, navigationProperty, null); // BinaryOperatorNode node = BuildFilterExpression(parentSource, fieldSelection); // compositeNode = ComposeExpression(compositeNode, node); // } return(compositeNode); }
private void AddToResultDictionaryIfNotAlreadyPresent( IDictionary <string, object> dictionary, string fieldName, GraphQLFieldSelection selection) { if (!dictionary.ContainsKey(fieldName)) { dictionary.Add(fieldName, this.GetDefinitionAndExecuteField(this.type, selection)); } }
private object GetDefinitionAndExecuteField(GraphQLObjectType type, GraphQLFieldSelection selection) { var arguments = this.GetArgumentsFromSelection(selection); var fieldInfo = this.GetFieldInfo(type, selection); var resolvedValue = this.ResolveField(fieldInfo, arguments, this.parent); return(this.CompleteValue(resolvedValue, selection, arguments)); }
private List <GraphQLArgument> GetArgumentsFromSelection(GraphQLFieldSelection selection) { var arguments = this.arguments.ToList(); arguments.RemoveAll(e => selection.Arguments.Any(arg => arg.Name.Value.Equals(e.Name.Value))); arguments.AddRange(selection.Arguments); return(arguments); }
private async Task <object> CompleteListValueAsync( IExecutorContext executorContext, ObjectType objectType, IField field, IType fieldType, ObjectType actualType, GraphQLFieldSelection selection, IReadOnlyCollection <GraphQLFieldSelection> fields, object value, NodePath path, List listType) { if (!(value is IEnumerable values)) { throw new CompleteValueException( $"Cannot complete value for list field '{selection.Name.Value}':'{fieldType}'. " + "Resolved value is not a collection", path, selection); } var innerType = listType.OfType; var result = new List <object>(); int i = 0; foreach (var resultItem in values) { var itemPath = path.Fork().Append(i++); try { var completedResultItem = await CompleteValueAsync( executorContext, objectType, field, innerType, actualType, selection, fields, resultItem, itemPath).ConfigureAwait(false); result.Add(completedResultItem); } catch (Exception e) { if (innerType is NonNull) { throw; } executorContext.AddError(e); result.Add(null); } } return(result); }
private List <GraphQLArgument> GetArgumentsFromSelection(GraphQLFieldSelection selection, GraphQLFieldInfo fieldInfo) { if (fieldInfo == null || fieldInfo.Arguments?.Count == 0) { return(null); } return(this.MergeArgumentsWithDefault(selection.Arguments, fieldInfo.Arguments)); }
public override GraphQLFieldSelection EndVisitFieldSelection( GraphQLFieldSelection selection) { { Tracker.LeaveFieldSelection?.Invoke(selection); } return(base.EndVisitFieldSelection(selection)); }
public ResolverContextFacts() { _objectType = new ObjectType("Test"); _objectValue = null; _field = new Field(ScalarType.ID); _selection = new GraphQLFieldSelection(); _schema = new SchemaBuilder() .Query(out _) .Build(); }
public Field Field(GraphQLFieldSelection source) { var alias = source.Alias != null?Name(source.Alias) : null; var field = new Field(alias, Name(source.Name)).WithLocation(source, _body); field.Arguments = Arguments(source.Arguments); field.Directives = Directives(source.Directives); field.SelectionSet = SelectionSet(source.SelectionSet); return(field); }
private object CompleteCollectionType(IEnumerable input, GraphQLFieldSelection selection, IList <GraphQLArgument> arguments) { var result = new List <object>(); foreach (var element in input) { result.Add(this.CompleteValue(element, selection, arguments)); } return(result); }
public FieldSelection(GraphQLFieldSelection op) { this.op = op; Name = op.Alias?.Value ?? op.Name.Value; if (op.SelectionSet != null) { Selection = new SetSelection(op.SelectionSet); } // to deduplocate part sof }
private IEdmEntitySet GetEntitySet(GraphQLFieldSelection selection) { foreach (FieldType fieldType in _context.Schema.Query.Fields) { if (String.Compare(fieldType.Name, selection.Name.Value, StringComparison.OrdinalIgnoreCase) == 0) { return(OeEdmClrHelper.GetEntitySet(_edmModel, fieldType.Name)); } } throw new InvalidOperationException("Field name " + selection.Name.Value + " not found in schema query"); }
private async Task <object> TryResolveNull(object input, Type inputType, GraphQLFieldSelection selection, IEnumerable <object> path) { return(await Task.Run(() => { if (input == null) { return (object)null; } return INVALID_RESULT; })); }
private async Task <object> TryResolveUnion(object input, Type inputType, GraphQLFieldSelection selection, IEnumerable <object> path) { if (ReflectionUtilities.IsDescendant(inputType, typeof(GraphQLUnionType))) { var unionSchemaType = this.context.SchemaRepository.GetSchemaTypeFor(inputType) as GraphQLUnionType; input = await this.CompleteValue(input, unionSchemaType.ResolveType(input), selection, this.arguments, path); return(input); } return(INVALID_RESULT); }
private bool HaveSameArguments(GraphQLFieldSelection selection1, GraphQLFieldSelection selection2) { if (selection1.Arguments.Count() != selection2.Arguments.Count()) { return(false); } return(selection1.Arguments .All(arg1 => selection2.Arguments .Any(arg2 => arg1.Name.Value == arg2.Name.Value && arg1.Value.ToString() == arg2.Value.ToString()))); }
private FilterClause BuildFilterClause(IEdmEntitySet entitySet, GraphQLFieldSelection selection) { ResourceRangeVariable resourceVariable = GetResorceVariable(entitySet); var resourceNode = new ResourceRangeVariableReferenceNode("", resourceVariable); BinaryOperatorNode filterExpression = BuildFilterExpression(resourceNode, selection); if (filterExpression == null) { return(null); } return(new FilterClause(filterExpression, resourceVariable)); }