private void GetFieldsAndFragmentNames( GraphQLSelectionSet node, Dictionary <string, ICollection <NodeAndDefinitions> > nodeDefinitions, ICollection <string> fragmentNames, GraphQLBaseType parentType, string presumedParentName = null) { foreach (var selection in node.Selections) { switch (selection.Kind) { case ASTNodeKind.Field: var fieldSelection = selection as GraphQLFieldSelection; var fieldName = fieldSelection.Name.Value; GraphQLObjectTypeFieldInfo fieldDefinition = null; if (parentType is GraphQLComplexType) { fieldDefinition = ((GraphQLComplexType)parentType).GetFieldInfo(fieldName); } var responseName = fieldSelection.Alias != null ? fieldSelection.Alias.Value : fieldName; if (!nodeDefinitions.ContainsKey(responseName)) { nodeDefinitions.Add(responseName, new List <NodeAndDefinitions>()); } nodeDefinitions[responseName].Add(new NodeAndDefinitions() { PresumedParentName = presumedParentName, ParentType = parentType, Selection = fieldSelection, FieldDefinition = fieldDefinition }); break; case ASTNodeKind.FragmentSpread: fragmentNames.Add(((GraphQLFragmentSpread)selection).Name.Value); break; case ASTNodeKind.InlineFragment: var inlineFragment = selection as GraphQLInlineFragment; var typeCondition = inlineFragment.TypeCondition; var inlineFragmentType = typeCondition != null ? this.SchemaRepository.GetSchemaOutputTypeByName(typeCondition.Name.Value) : parentType; this.GetFieldsAndFragmentNames( inlineFragment.SelectionSet, nodeDefinitions, fragmentNames, inlineFragmentType, typeCondition?.Name?.Value); break; } } }
private string ComposeBadValueForDefaultArgMessage(string varName, GraphQLBaseType type, string value, string[] verboseErrors = null) { var message = verboseErrors.Length > 0 ? "\n" + string.Join("\n", verboseErrors) : string.Empty; return($"Variable \"${varName}\" of type \"{type}\" has invalid " + $"default value {value}.{message}"); }
internal IEnumerable <GraphQLException> IsValid(GraphQLBaseType type, GraphQLValue astValue) { if (astValue is GraphQLVariable) { return new GraphQLException[] { } } ; if (astValue is GraphQLNullValue || astValue == null) { return(this.ValidateNullType(type, astValue)); } if (type is GraphQLNonNull) { return(this.IsValid(((GraphQLNonNull)type).UnderlyingNullableType, astValue)); } if (type is GraphQLList) { return(this.ValidateListType(type, astValue)); } if (type is GraphQLInputType) { return(this.ValidateInputType(type, astValue)); } return(new GraphQLException[] { }); }
private string PrintType(GraphQLBaseType type) { if (type is GraphQLEnumType) { return(PrintEnum((GraphQLEnumType)type)); } if (type is GraphQLScalarType) { return(PrintScalar((GraphQLScalarType)type)); } if (type is GraphQLObjectType) { return(this.PrintObject((GraphQLObjectType)type)); } if (type is GraphQLInterfaceType) { return(this.PrintInterface((GraphQLInterfaceType)type)); } if (type is GraphQLUnionType) { return(this.PrintUnion((GraphQLUnionType)type)); } if (type is GraphQLInputObjectType) { return(this.PrintInputObject((GraphQLInputObjectType)type)); } throw new GraphQLException($"Type {type.Name} can't be printed."); }
public object TranslatePerDefinition(object inputObject, GraphQLBaseType typeDefinition) { if (typeDefinition is GraphQLNonNull) { return(this.TranslatePerDefinition(inputObject, ((GraphQLNonNull)typeDefinition).UnderlyingNullableType)); } if (typeDefinition is GraphQLInputObjectType) { return(this.CreateObjectFromDynamic((GraphQLInputObjectType)typeDefinition, (ExpandoObject)inputObject)); } if (typeDefinition is GraphQLList) { if (inputObject == null) { return(null); } if (ReflectionUtilities.IsCollection(inputObject.GetType())) { return(ReflectionUtilities.ChangeValueType(this.CreateList((IEnumerable)inputObject, (GraphQLList)typeDefinition), this.schemaRepository.GetInputSystemTypeFor(typeDefinition))); } return(this.CreateSingleValueList(inputObject, (GraphQLList)typeDefinition)); } return(inputObject); }
public static bool IsPossibleType( GraphQLBaseType parent, GraphQLBaseType child, ISchemaRepository schemaRepository) { return(parent .Introspect(schemaRepository) .Value .Interfaces.Any(e => e.Value.Name == child.Name)); }
private void AddOutputType(GraphQLBaseType type) { if (type is ISystemTypeBound) { this.outputBindings.Add(((ISystemTypeBound)type).SystemType, type); } else { this.outputBindings.Add(type.GetType(), type); } }
private Type GetNonNullInputSystemTypeFor(GraphQLBaseType type) { var systemType = this.GetSystemTypeFor(type); if (!ReflectionUtilities.IsValueType(systemType)) { return(ReflectionUtilities.CreateNonNullableType(systemType)); } return(systemType); }
private IEnumerable <GraphQLException> ValidateListType(GraphQLBaseType type, GraphQLValue astValue) { var itemType = ((GraphQLList)type).MemberType; if (astValue.Kind == ASTNodeKind.ListValue) { return(this.ValidateListMembers(itemType, (GraphQLListValue)astValue)); } return(this.IsValid(itemType, astValue)); }
public Type GetInputSystemTypeFor(GraphQLBaseType type) { if (type is GraphQLNonNull) { return(this.GetNonNullInputSystemTypeFor(((GraphQLNonNull)type).UnderlyingNullableType)); } var inputType = ReflectionUtilities.CreateNullableType( this.GetSystemTypeFor(type)); return(inputType); }
private IEnumerable <string> GetSuggestedFieldNames(IGraphQLSchema schema, GraphQLBaseType type, string fieldName) { if (type is GraphQLObjectType || type is GraphQLInterfaceType) { var introspectedType = type.Introspect(schema.SchemaRepository); var possibleFieldNames = introspectedType.Value.Fields.Select(e => e.Value.Name.Value); return(StringUtils.SuggestionList(fieldName, possibleFieldNames)); } return(Enumerable.Empty <string>()); }
public void AddKnownType(GraphQLBaseType type) { if (type is GraphQLInputType) { this.AddInputType((GraphQLInputType)type); } if (!(type is GraphQLInputType) || type is GraphQLScalarType) { this.AddOutputType(type); } }
private IEnumerable <GraphQLException> ValidateNullType(GraphQLBaseType type, GraphQLValue astValue) { if (type is GraphQLNonNull) { return(new GraphQLException[] { new GraphQLException($"Expected type \"{type}\", found null.") }); } return(new GraphQLException[] { }); }
private IEnumerable <GraphQLException> ValidateListMembers(GraphQLBaseType itemType, GraphQLListValue astValue) { var values = astValue.Values; for (int i = 0; i < values.Count(); i++) { foreach (var error in this.IsValid(itemType, values.ElementAt(i))) { yield return(new GraphQLException($"In element #{i}: {error.Message}")); } } }
private IEnumerable <Conflict> FindConflictsBetweenSubSelectionSets( GraphQLBaseType type1, GraphQLBaseType type2, GraphQLSelectionSet selectionSet1, GraphQLSelectionSet selectionSet2, bool areMutuallyExclusive) { var conflicts = new List <Conflict>(); var fieldMap1 = new Dictionary <string, ICollection <NodeAndDefinitions> >(); var fragmentNames1 = new List <string>(); this.GetFieldsAndFragmentNames( selectionSet1, fieldMap1, fragmentNames1, type1); var fieldMap2 = new Dictionary <string, ICollection <NodeAndDefinitions> >(); var fragmentNames2 = new List <string>(); this.GetFieldsAndFragmentNames( selectionSet2, fieldMap2, fragmentNames2, type2); conflicts.AddRange(this.CollectConflictsBetween(areMutuallyExclusive, fieldMap1, fieldMap2)); foreach (var frag in fragmentNames2) { conflicts.AddRange(this.CollectConflictsBetweenFieldsAndFragment( fieldMap1, frag, areMutuallyExclusive)); } foreach (var frag in fragmentNames1) { conflicts.AddRange(this.CollectConflictsBetweenFieldsAndFragment( fieldMap2, frag, areMutuallyExclusive)); } foreach (var frag1 in fragmentNames1) { foreach (var frag2 in fragmentNames2) { conflicts.AddRange(this.CollectConflictsBetweenFragments( frag1, frag2, areMutuallyExclusive)); } } return(conflicts); }
public GraphQLBaseType GetUnderlyingType(GraphQLBaseType type) { if (type is GraphQLList) { return(this.GetUnderlyingType(((GraphQLList)type).MemberType)); } if (type is GraphQLNonNull) { return(this.GetUnderlyingType(((GraphQLNonNull)type).UnderlyingNullableType)); } return(type); }
private Type GetSystemTypeFor(GraphQLBaseType type) { if (type is GraphQLList) { return(ReflectionUtilities.CreateListTypeOf( this.GetInputSystemTypeFor(((GraphQLList)type).MemberType))); } var reflectedType = this.inputBindings .Where(e => e.Value.Name == type.Name) .Select(e => e.Key) .FirstOrDefault(); return(reflectedType); }
private bool DoTypesConflict( GraphQLBaseType type1, GraphQLBaseType type2) { if (type1 is GraphQLList) { return(type2 is GraphQLList ? this.DoTypesConflict( ((GraphQLList)type1).MemberType, ((GraphQLList)type2).MemberType) : true); } if (type2 is GraphQLList) { return(type1 is GraphQLList ? this.DoTypesConflict( ((GraphQLList)type1).MemberType, ((GraphQLList)type2).MemberType) : true); } if (type1 is GraphQLNonNull) { return(type2 is GraphQLNonNull ? this.DoTypesConflict( ((GraphQLNonNull)type1).UnderlyingNullableType, ((GraphQLNonNull)type2).UnderlyingNullableType) : true); } if (type2 is GraphQLNonNull) { return(type1 is GraphQLNonNull ? this.DoTypesConflict( ((GraphQLNonNull)type1).UnderlyingNullableType, ((GraphQLNonNull)type2).UnderlyingNullableType) : true); } if (type1.IsLeafType || type2.IsLeafType) { return(type1.Name != type2.Name); } return(false); }
private void ValidateInlineFragmentTypes(GraphQLInlineFragment node, GraphQLBaseType fragmentType, GraphQLBaseType parentType) { if (parentType is GraphQLList) { parentType = ((GraphQLList)parentType).MemberType; this.ValidateInlineFragmentTypes(node, fragmentType, parentType); } else if (fragmentType != null && parentType != null && !this.DoTypesOverlap(fragmentType, parentType)) { this.Errors.Add( new GraphQLException( this.GetIncompatibleTypeInAnonymousFragmentMessage(fragmentType, parentType), new[] { node })); } }
private IEnumerable <GraphQLException> ValidateInputType(GraphQLBaseType type, GraphQLValue astValue) { var result = ((GraphQLInputType)type).GetFromAst(astValue, this.schemaRepository); if (type is GraphQLInputObjectType) { return(this.ValidateObjectFields((GraphQLInputObjectType)type, (GraphQLObjectValue)astValue)); } if (!result.IsValid) { return(new GraphQLException[] { new GraphQLException($"Expected type \"{type}\", found {astValue}.") }); } return(new GraphQLException[] { }); }
private bool DoTypesOverlap(GraphQLBaseType fragmentType, GraphQLBaseType parentType) { if (fragmentType == parentType) { return(true); } var parentImplementsFragmentType = fragmentType .Introspect(this.SchemaRepository).Value .Interfaces?.Any(e => e.Value.Name == parentType.Name) ?? false; var fragmentTypeImplementsParent = parentType .Introspect(this.SchemaRepository).Value .Interfaces?.Any(e => e.Value.Name == fragmentType.Name) ?? false; var fragmentTypeIsWithinPossibleTypes = parentType .Introspect(this.SchemaRepository).Value .PossibleTypes?.Any(e => e.Value.Name == fragmentType.Name) ?? false; return(parentImplementsFragmentType || fragmentTypeImplementsParent || fragmentTypeIsWithinPossibleTypes); }
private IEnumerable <string> GetSuggestedTypeNames(IGraphQLSchema schema, GraphQLBaseType type, string fieldName) { var introspectedType = type.Introspect(schema.SchemaRepository); var suggestedObjectTypes = new List <string>(); var interfaceUsageCount = new Dictionary <string, int>(); if (introspectedType.Value.PossibleTypes == null) { return(suggestedObjectTypes); } foreach (var possibleType in introspectedType.Value.PossibleTypes) { if (possibleType.Value.Fields.Any(e => e.Value.Name == fieldName)) { suggestedObjectTypes.Add(possibleType.Value.Name); foreach (var possibleInterface in possibleType.Value.Interfaces) { if (possibleInterface.Value.Fields.Any(e => e.Value.Name == fieldName)) { if (!interfaceUsageCount.ContainsKey(possibleInterface.Value.Name)) { interfaceUsageCount.Add(possibleInterface.Value.Name, 1); } else { interfaceUsageCount[possibleInterface.Value.Name]++; } } } } } var suggestedInterfaceTypes = interfaceUsageCount.OrderByDescending(e => e.Value).Select(e => e.Key); return(suggestedInterfaceTypes.Concat(suggestedObjectTypes)); }
protected GraphQLFieldInfo GetField(GraphQLBaseType type, string fieldName) { if (this.IsQueryRootType(type)) { if (fieldName == "__schema") { return(this.GetIntrospectedSchemaField()); } if (fieldName == "__type") { return(this.GetIntrospectedTypeField()); } } if (type is GraphQLNonNull) { return(this.GetField(((GraphQLNonNull)type).UnderlyingNullableType, fieldName)); } if (type is GraphQLInputObjectType) { return(((GraphQLInputObjectType)type).GetFieldInfo(fieldName)); } if (type is GraphQLComplexType) { return(((GraphQLComplexType)type).GetFieldInfo(fieldName)); } if (type is GraphQLList) { return(this.GetField(((GraphQLList)type).MemberType, fieldName)); } return(null); }
private string GetIncompatibleTypeInFragmentMessage( GraphQLBaseType fragmentType, GraphQLBaseType parentType, string fragmentName) { return($"Fragment {fragmentName} cannot be spread here as objects of " + $"type \"{parentType}\" can never be of type \"{fragmentType}\"."); }
private string ComposeDefaultForNonNullArgMessage(string varName, GraphQLBaseType type, GraphQLBaseType guessType) { return($"Variable \"${varName}\" of type \"{type}\" is required and " + "will not use the default value. " + $"Perhaps you meant to use type \"{guessType}\"."); }
private string RequiredSubselectionMessage(string fieldName, GraphQLBaseType type) { return($"Field \"{fieldName}\" of type \"{type}\" must have a " + $"selection of subfields. Did you mean \"{fieldName} " + "{ ... }\"?"); }
private string NoScalarSubselection(string fieldName, GraphQLBaseType type) { return($"Field \"{fieldName}\" must not have a selection since " + $"type \"{type}\" has no subfields."); }
private GraphQLBaseType GetEffectiveType(GraphQLBaseType type, GraphQLVariableDefinition definition) { return(definition.DefaultValue == null || type is GraphQLNonNull ? type : new GraphQLNonNull(type)); }
private static string PrintDescription(GraphQLBaseType type, string indentation = "", bool firstInBlock = true) { return(PrintDescription(type.Description, indentation, firstInBlock)); }
private string ComposeUnknownArgumentMessage(string argName, string fieldName, GraphQLBaseType type, IEnumerable <string> suggestedArgs) { var message = $"Unknown argument \"{argName}\" on field \"{fieldName}\" of type \"{type}\"."; if (suggestedArgs.Any()) { message += $" Did you mean {StringUtils.QuotedOrList(suggestedArgs)}?"; } return(message); }