public MethodInfo FindMethod(GraphQLType gqlType, QueryType requestType) { Dictionary <string, MethodInfo> loopThrough; if (requestType == QueryType.MUTATION) { loopThrough = Mutations; } else if (requestType == QueryType.QUERY) { loopThrough = Queries; } else if (requestType == QueryType.FIELD) { loopThrough = FieldResolvers; } else { return(null); } foreach (var q in loopThrough) { if (GraphQLType.FindOrGenerate(q.Value.ReturnType).TypeName == gqlType.TypeName) { return(q.Value); } } return(null); }
private GraphQLType ParseType() { GraphQLType type = null; var start = this.currentToken.Start; if (this.Skip(TokenKind.BRACKET_L)) { type = this.ParseType(); this.Expect(TokenKind.BRACKET_R); type = new GraphQLListType() { Type = type, Location = this.GetLocation(start) }; } else { type = this.ParseNamedType(); } if (this.Skip(TokenKind.BANG)) { return(new GraphQLNonNullType() { Type = type, Location = this.GetLocation(start) }); } return(type); }
private IGraphType ToGraphType(GraphQLType astType) { switch (astType.Kind) { case ASTNodeKind.NonNullType: { var type = ToGraphType(((GraphQLNonNullType)astType).Type); return(new NonNullGraphType(type)); } case ASTNodeKind.ListType: { var type = ToGraphType(((GraphQLListType)astType).Type); return(new ListGraphType(type)); } case ASTNodeKind.NamedType: { var namedType = (GraphQLNamedType)astType; var type = GetType(namedType.Name.Value); return(type ?? new GraphQLTypeReference(namedType.Name.Value)); } default: throw new ArgumentOutOfRangeException($"Unknown GraphQL type {astType.Kind}"); } }
public SchemaQueryType(Schema schema, GraphQLType baseQueryType) { Fields = baseQueryType.Fields .Where(f => !f.IsMutation) .Select(f => new SchemaField(this, f, schema)) .ToDictionary(f => f.FieldName, f => f as ISchemaField <Info>); }
public IType Type(GraphQLType type) { switch (type.Kind) { case ASTNodeKind.NamedType: { var name = (GraphQLNamedType)type; return(new NamedType(Name(name.Name)).WithLocation(name, _body)); } case ASTNodeKind.NonNullType: { var nonNull = (GraphQLNonNullType)type; return(new NonNullType(Type(nonNull.Type)).WithLocation(nonNull, _body)); } case ASTNodeKind.ListType: { var list = (GraphQLListType)type; return(new ListType(Type(list.Type)).WithLocation(list, _body)); } } throw new ExecutionError($"Unmapped type {type.Kind}"); }
private void UnPackType(GraphQLType type, ValueTypeReference target) { try { if (type is GraphQLNonNullType nonNullType) { target.CanValueBeNull = true; UnPackType(nonNullType.Type, target); } else if (type is GraphQLListType listType) { target.IsCollection = true; if (target.CanValueBeNull) { target.CanValueBeNull = false; target.CanCollectionBeNull = true; } UnPackType(listType.Type, target); } else if (type is GraphQLNamedType namedType) { target.Type = ResolveType(namedType); } else { throw new Exception("dunno???"); } }catch (Exception ex) { throw; } }
protected virtual GraphQLBaseType GetInputType(GraphQLType type) { if (type is GraphQLNamedType) { return(this.GetInputTypeFromNamedType((GraphQLNamedType)type)); } if (type is GraphQLNonNullType) { var inputType = this.GetInputType(((GraphQLNonNullType)type).Type); if (inputType == null) { return(null); } return(new GraphQLNonNull(inputType)); } if (type is GraphQLListType) { return(new GraphQLList(this.GetInputType(((GraphQLListType)type).Type))); } throw new NotImplementedException(); }
public static IType TypeFromAst(ISchema schema, GraphQLType type) { if (type == null) { return(null); } if (type.Kind == ASTNodeKind.NonNullType) { var innerType = TypeFromAst(schema, ((GraphQLNonNullType)type).Type); return(innerType != null ? new NonNull(innerType) : null); } if (type.Kind == ASTNodeKind.ListType) { var innerType = TypeFromAst(schema, ((GraphQLListType)type).Type); return(innerType != null ? new List(innerType) : null); } if (type.Kind == ASTNodeKind.NamedType) { var namedType = (GraphQLNamedType)type; return(schema.GetNamedType(namedType.Name.Value)); } throw new GraphQLError( $"Unexpected type kind: {type.Kind}"); }
internal ValueTypeReference ResolveValueType(GraphQLType type) { var result = new ValueTypeReference(); UnPackType(type, result); return(result); }
public SchemaType OfType(GraphQLType type) { SchemaType existing; if (_typeMap.TryGetValue(type, out existing)) { return(existing); } return(_typeMap[type] = new SchemaType(type, this)); }
protected TypeSyntax GetCSharpTypeFromGraphQLType(GraphQLType type, IEnumerable <ASTNode> allDefinitions) { switch (type.Kind) { case ASTNodeKind.NamedType: return(this.GetCSharpTypeFromGraphQLNamedType((GraphQLNamedType)type, allDefinitions)); case ASTNodeKind.NonNullType: return(this.GetCSharpTypeFromGraphQLNonNullType((GraphQLNonNullType)type, allDefinitions)); case ASTNodeKind.ListType: return(this.GetCSharpTypeFromGraphQLListType((GraphQLListType)type, allDefinitions)); } throw new NotImplementedException($"GetCSharpTypeFromGraphQLType: Unknown type.Kind: {type.Kind}"); }
internal SchemaType(GraphQLType type, Schema schema) { _type = type; _fields = new Lazy <IReadOnlyDictionary <string, ISchemaField <Info> > >(() => type.GetAllFieldIncludeBaseType() .Select(f => new SchemaField(this, f, schema)) // There might be duplicates (i.e. '__typename' on types with a base type) - ignore them. .Aggregate( new Dictionary <string, ISchemaField <Info> >(), (dict, field) => { dict[field.FieldName] = field; return(dict); } )); }
private GraphQLScalarType GetTypeDefinition(GraphQLType typeDefinition) { if (typeDefinition is GraphQLNamedType) { return(this.typeTranslator.GetType((GraphQLNamedType)typeDefinition)); } if (typeDefinition is Language.AST.GraphQLNonNullType) { return(new Type.GraphQLNonNullType((GraphQLNullableType)this.GetTypeDefinition(((Language.AST.GraphQLNonNullType)typeDefinition).Type))); } if (typeDefinition is GraphQLListType) { return(new GraphQLList(this.GetTypeDefinition(((GraphQLListType)typeDefinition).Type))); } return(null); }
public GraphQLServer(int port = 8080) { _httpListener = new HttpListener(); // Allow the server to listen on any address, with https and http, on a port _httpListener.Prefixes.Add($"http://+:{port}/"); // Set up request handle thread _handleThread = new Thread(HandleRequests); // Set up types try { GraphQLType.RegisterIntrinsic(); } catch (Exception e) { Console.WriteLine(e); } }
protected virtual GraphQLBaseType GetOutputType(GraphQLType type) { if (type is GraphQLNamedType) { return(this.GetOutputTypeFromNamedType((GraphQLNamedType)type)); } if (type is GraphQLNonNullType) { return(this.GetOutputType(((GraphQLNonNullType)type).Type)); } if (type is GraphQLListType) { return(this.GetOutputType(((GraphQLListType)type).Type)); } throw new NotImplementedException(); }
private GraphQLBaseType GetTypeDefinition(GraphQLType typeDefinition) { if (typeDefinition is GraphQLNamedType) { return(this.schemaRepository.GetSchemaInputTypeByName(((GraphQLNamedType)typeDefinition).Name.Value)); } if (typeDefinition is GraphQLNonNullType) { return(new GraphQLNonNull(this.GetTypeDefinition(((GraphQLNonNullType)typeDefinition).Type))); } if (typeDefinition is GraphQLListType) { return(new GraphQLList(this.GetTypeDefinition(((GraphQLListType)typeDefinition).Type))); } return(null); }
public static bool IsArrayType(this GraphQLType graphqlType) { var isArray = false; switch (graphqlType.Kind) { case ASTNodeKind.NonNullType: { isArray = IsArrayType(((GraphQLNonNullType)graphqlType).Type !); break; } case ASTNodeKind.ListType: { isArray = true; break; } } return(isArray); }
internal SchemaType(GraphQLType type, Schema schema) { _type = type; _fields = new Lazy <IReadOnlyDictionary <string, ISchemaField <Info> > >(() => type.GetQueryFields() .Select(f => new SchemaField(this, f, schema)) // There might be duplicates (i.e. '__typename' on types with a base type) - ignore them. .Aggregate( new Dictionary <string, ISchemaField <Info> >(), (dict, field) => { dict[field.FieldName] = field; return(dict); } )); _possibleTypes = new Lazy <IEnumerable <ISchemaQueryType <Info> > >( () => type.PossibleTypes.Select(schema.OfType)); _interfaces = new Lazy <IEnumerable <ISchemaQueryType <Info> > >( () => type.Interfaces.Select(schema.OfType)); }
public Info(GraphQLType type) { Type = type; }
public GraphQLController() { var controllerAttr = (GQLController)GetType().GetCustomAttribute(typeof(GQLController)); gqlType = GraphQLType.FindOrGenerate(controllerAttr.type); }
private static List <RequestNode> GetFieldGroups(string query, GraphQLTypeIntrinsic.GQLInterface parentType, JObject variables) { List <RequestNode> groups = new List <RequestNode>(); while (query.Length > 0) { query = query.Trim(' ', '\n'); if (query == "") { break; } var(start, end) = NextBracketSection(query); // If non sub group fields are the only ones that remain if (end == -1) { foreach (var fName in query.Split('\n')) { var(name, args) = ParseArgs(fName, variables); GraphQLType t = null; foreach (var f in parentType.Fields) { if (f.Name == name) { t = f.type; break; } } if (t != null) { RequestNode n = new RequestNode { QueryType = QueryType.FIELD, NodeType = t, Name = name, Args = args }; groups.Add(n); } } break; } var fullGroup = query.Substring(0, end); var names = fullGroup.Split('{')[0]; // Parse possible fields that are above a sub group var fields2 = names.Split('\n'); for (int i = 0; i < fields2.Length - 1; i++) { var(name, args) = ParseArgs(fields2[i], variables); GraphQLType t = null; foreach (var f in parentType.Fields) { if (f.Name == name) { t = f.type; break; } } if (t != null) { RequestNode n = new RequestNode { QueryType = QueryType.FIELD, NodeType = t, Name = name, Args = args }; groups.Add(n); } } // Parse the sub group if (fullGroup.Length > 0) { var(name, args) = ParseArgs(fields2[fields2.Length - 1], variables); GraphQLType t = null; foreach (var f in parentType.Fields) { if (f.Name == name) { t = f.type; break; } } if (t != null) { List <RequestNode> fields = new List <RequestNode>(); if (t is GraphQLTypeIntrinsic.GQLInterface) { fields = GetFieldGroups(query.Substring(start, end - start), (GraphQLTypeIntrinsic.GQLInterface)t, variables); } RequestNode n = new RequestNode { QueryType = QueryType.FIELD, NodeType = t, Name = name, Fields = fields, Args = args }; groups.Add(n); } } query = query.Substring(end); } return(groups); }
/// <summary> /// Searches a schema for a graph type specified by an AST type after unwrapping any /// <see cref="GraphQLNonNullType"/> or <see cref="GraphQLListType"/> layers. If the type cannot be /// found, returns <see langword="null"/>. /// </summary> /// <param name="type">The AST type to search for.</param> /// <param name="schema">The schema to search within.</param> public static IGraphType?NamedGraphTypeFromType(this GraphQLType type, ISchema schema) => type switch {
public IsType(Type type) { Type = (GraphQLType)Activator.CreateInstance(type); }
public SchemaRootType(Schema schema, GraphQLType baseQueryType) { Fields = baseQueryType.OwnFields .Select(f => new SchemaField(this, f, schema)) .ToDictionary(f => f.FieldName, f => f as ISchemaField <Info>); }