public void AddQueryConnectionField <TSource, TReturn>( ObjectGraphType <TSource> graph, string name, Func <ResolveEfFieldContext <TDbContext, TSource>, IQueryable <TReturn> > resolve, Type?itemGraphType = null, IEnumerable <QueryArgument>?arguments = null, int pageSize = 10) where TReturn : class { Guard.AgainstNull(nameof(graph), graph); Guard.AgainstNull(nameof(resolve), resolve); var connection = BuildQueryConnectionField(name, resolve, pageSize, itemGraphType); var field = graph.AddField(connection.FieldType); field.AddWhereArgument(arguments); }
public void AddQueryConnectionField <TSource, TReturn>( ObjectGraphType <TSource> graph, string name, Func <ResolveEfFieldContext <TDbContext, TSource>, IQueryable <TReturn> > resolve, Type?graphType = null, IEnumerable <QueryArgument>?arguments = null, int pageSize = 10) where TReturn : class { Guard.AgainstNull(nameof(graph), graph); //build the connection field var connection = BuildQueryConnectionField(name, resolve, pageSize, graphType); //add the field to the graph var field = graph.AddField(connection.FieldType); //append the optional where arguments to the field field.AddWhereArgument(arguments); }
public FieldType AddNavigationListField <TSource, TReturn>( ObjectGraphType <TSource> graph, string name, Func <ResolveEfFieldContext <TDbContext, TSource>, IEnumerable <TReturn> > resolve, Type graphType = null, IEnumerable <QueryArgument> arguments = null, IEnumerable <string> includeNames = null) where TReturn : class { Guard.AgainstNull(nameof(graph), graph); //graphType should represent the graph type of the enumerated value, not the list graph type //build the navigation field var field = BuildNavigationField(graphType, name, resolve, includeNames, arguments); //add it to the graph return(graph.AddField(field)); }
public void AddFields(ObjectGraphType objectGraphType) { objectGraphType.AddField(new EventStreamFieldType { Name = "terminalEquipmentConnectivityUpdated", Type = typeof(TerminalEquipmentAZConnectivityViewModelType), Resolver = new FuncFieldResolver <TerminalEquipmentAZConnectivityViewModel>(context => context.Source as TerminalEquipmentAZConnectivityViewModel), Arguments = new QueryArguments( new QueryArgument <NonNullGraphType <IdGraphType> > { Name = "routeNodeId" }, new QueryArgument <NonNullGraphType <IdGraphType> > { Name = "terminalEquipmentOrRackId" } ), Subscriber = new EventStreamResolver <TerminalEquipmentAZConnectivityViewModel>(context => { var messageHandlingContext = (MessageHandlingContext)context.UserContext; var graphQLUserContext = messageHandlingContext.Get <GraphQLUserContext>("GraphQLUserContext"); if (_authSetting.Enable && !graphQLUserContext.User.Identity.IsAuthenticated) { context.Errors.Add(new ExecutionError("Not authorized")); return(null); } var routeNodeId = context.GetArgument <Guid>("routeNodeId"); if (routeNodeId == Guid.Empty) { context.Errors.Add(new ExecutionError($"nameof(routeNodeId) guid cannot be empty.")); return(null); } var terminalEquipmentOrRackId = context.GetArgument <Guid>("terminalEquipmentOrRackId"); if (terminalEquipmentOrRackId == Guid.Empty) { context.Errors.Add(new ExecutionError($"{nameof(terminalEquipmentOrRackId)} guid cannot be empty.")); return(null); } return(_terminalEquipmentConnectivityObserver.WhenViewNeedsUpdate(routeNodeId, terminalEquipmentOrRackId)); }), }); }
public void prints_enum_default_args() { var root = new ObjectGraphType { Name = "Query" }; var f = new FieldType { Name = "bestColor", Arguments = new QueryArguments(new QueryArgument <RgbEnum> { Name = "color", DefaultValue = "RED" }), Type = typeof(RgbEnum) }; root.AddField(f); var schema = new Schema { Query = root }; schema.RegisterType <RgbEnum>(); var expected = new Dictionary <string, string> { { "Query", @"type Query { bestColor(color: RGB = RED): RGB }" }, { "RGB", @"enum RGB { RED GREEN BLUE }" }, }; AssertEqual(print(schema), expected); }
public DataGraphType(Builder builder, SchemaInfo schemaInfo) { Name = schemaInfo.DataType; foreach (var fieldInfo in schemaInfo.Fields) { var(resolvedType, resolver, args) = builder.GetGraphType(fieldInfo); if (resolver != null) { var fieldGraphType = new ObjectGraphType { Name = fieldInfo.LocalizedType }; var partitioning = builder.ResolvePartition(((RootField)fieldInfo.Field).Partitioning); foreach (var partitionKey in partitioning.AllKeys) { fieldGraphType.AddField(new FieldType { Name = partitionKey.EscapePartition(), Arguments = args, ResolvedType = resolvedType, Resolver = resolver, Description = fieldInfo.Field.RawProperties.Hints }).WithSourceName(partitionKey); } fieldGraphType.Description = $"The structure of the {fieldInfo.DisplayName} field of the {schemaInfo.DisplayName} content type."; AddField(new FieldType { Name = fieldInfo.FieldName, ResolvedType = fieldGraphType, Resolver = ContentResolvers.Field }).WithSourceName(fieldInfo); } } Description = $"The structure of the {schemaInfo.DisplayName} data type."; }
public void test_outputs() { var innerObject = new ObjectGraphType(); innerObject.AddField(new FieldType { Name = "test", ResolvedType = new StringGraphType(), Type = typeof(StringGraphType) }); var list = new ListGraphType(innerObject); var obj = new ObjectGraphType(); obj.AddField(new FieldType { Name = "list", ResolvedType = list, Type = list.GetType() }); var schema = new Schema { Query = obj }; schema.Initialize(); }
public void Activate(ObjectGraphType objectGraph, IWebHostEnvironment env, IServiceProvider sp) { objectGraph.AddField(new EventStreamFieldType { Name = "cityAdded", Type = typeof(CityAddedMessageGType), Resolver = new FuncFieldResolver <CityAddedMessage>(context => context.Source as CityAddedMessage), Arguments = new QueryArguments( new QueryArgument <NonNullGraphType <StringGraphType> > { Name = "countryName" } ), Subscriber = new EventStreamResolver <CityAddedMessage>(context => { var subscriptionServices = (ISubscriptionServices)sp.GetService(typeof(ISubscriptionServices)); var countryName = context.GetArgument <string>("countryName"); return(subscriptionServices.CityAddedService.GetMessages(countryName)); }) }); }
public void AddQueryConnectionField <TReturn>( ObjectGraphType graph, string name, Func <ResolveEfFieldContext <TDbContext, object>, IQueryable <TReturn> > resolve, Type graphType = null, IEnumerable <QueryArgument> arguments = null, int pageSize = 10) where TReturn : class { if (graph == null) { throw new ArgumentNullException(nameof(graph)); } //build the connection field var connection = BuildQueryConnectionField(name, resolve, pageSize, graphType); //add the field to the graph var field = graph.AddField(connection.FieldType); //append the optional where arguments to the field field.AddWhereArgument(arguments); }
private ObjectGraphType CreateQuery() { var entityFields = new List <FieldType>(CreateEntityFields(_edmModel, _graphTypeBuilder)); foreach (IEdmModel refModel in _edmModel.ReferencedModels) { if (refModel.EntityContainer != null) { entityFields.AddRange(CreateEntityFields(refModel, _graphTypeBuilder)); } } var query = new ObjectGraphType(); foreach (FieldType entityField in entityFields) { _graphTypeBuilder.AddNavigationProperties(entityField); query.AddField(entityField); } return(query); }
public void can_have_unknown_input_types_mapped_to_auto_registering_graph() { var schema = new CustomTypesSchema(); var query = new ObjectGraphType(); var field = new FieldType() { Name = "test", Type = typeof(IntGraphType), Arguments = new QueryArguments { new QueryArgument(typeof(GraphQLClrInputTypeReference <CustomData>)) { Name = "arg" } } }; query.AddField(field); schema.Query = query; schema.Initialize(); schema.Query.Fields.Find("test").Arguments[0].ResolvedType.ShouldBeOfType <AutoRegisteringInputObjectGraphType <CustomData> >(); }
public SchemaWithDuplicateInterfaceFields() { Query = new ObjectGraphType { Name = "Query" }; var iface = new InterfaceGraphType { Name = "Dup", ResolveType = _ => null }; iface.AddField(new FieldType { Name = "field", ResolvedType = new StringGraphType() }); iface.AddField(new FieldType { Name = "field_2", ResolvedType = new StringGraphType() }); // bypass HasField check iface.Fields.List[1].Name = "field"; Query.AddField(new FieldType { Name = "field", ResolvedType = new StringGraphType() }); RegisterType(iface); Query.ResolvedInterfaces.Add(iface); }
private IGraphTypeOfGraphQLNet Convert(IGraphType graphType) { try { //Enumerable if (graphType.IsEnumerable) { var elementGraphType = _graphTypeProvider.GetGraphType(graphType.Type, false, false); var listGraphType = new ListGraphType(Convert(elementGraphType)); return(graphType.IsRequired ? new NonNullGraphType(listGraphType) : (IGraphTypeOfGraphQLNet)listGraphType); } //Scalar if (!graphType.Fields.Any()) { if (graphType.IsEnum) { var enumGraphType = typeof(EnumerationGraphType <>).MakeGenericType(graphType.Type); enumGraphType = graphType.IsRequired ? typeof(NonNullGraphType <>).MakeGenericType(enumGraphType) : enumGraphType; return((IGraphTypeOfGraphQLNet)Activator.CreateInstance(enumGraphType)); } if (graphType.Type == typeof(string)) { var stringType = new StringGraphType(); return(graphType.IsRequired ? (IGraphTypeOfGraphQLNet) new NonNullGraphType(stringType) : stringType); } var scalarType = graphType.Type.IsGenericType && graphType.Type.GetGenericTypeDefinition() == typeof(Nullable <>) ? GraphTypeTypeRegistry.Get(graphType.Type.GenericTypeArguments[0]) : GraphTypeTypeRegistry.Get(graphType.Type); if (null != scalarType) { var resolvedGraphType = (IGraphTypeOfGraphQLNet)Activator.CreateInstance(scalarType); return(graphType.IsRequired ? new NonNullGraphType(resolvedGraphType) : resolvedGraphType); } throw new GraphException($"Unknown GraphType '{graphType.Name}'"); } //Complex var objectGraphType = new ObjectGraphType { Name = graphType.Name }; foreach (var field in graphType.Fields.Values) { var fieldType = new FieldType { Name = field.Name, ResolvedType = Convert(field.GraphType) }; if (field.Arguments.Any()) { fieldType.Arguments = new QueryArguments(); } foreach (var argument in field.Arguments.Values) { var queryArgument = new QueryArgument(Convert(argument.GraphType)) { Name = argument.Name }; fieldType.Arguments.Add(queryArgument); } objectGraphType.AddField(fieldType); } return(graphType.IsRequired ? (IGraphTypeOfGraphQLNet) new NonNullGraphType(objectGraphType) : objectGraphType); } catch (Exception ex) { throw; } }
public DataGraphType(Builder builder, SchemaInfo schemaInfo) { // The name is used for equal comparison. Therefore it is important to treat it as readonly. Name = schemaInfo.DataType; foreach (var fieldInfo in schemaInfo.Fields) { var partitioning = builder.ResolvePartition(((RootField)fieldInfo.Field).Partitioning); if (fieldInfo.Field.IsComponentLike()) { var fieldGraphType = new ObjectGraphType { // The name is used for equal comparison. Therefore it is important to treat it as readonly. Name = fieldInfo.LocalizedType }; foreach (var partitionKey in partitioning.AllKeys) { fieldGraphType.AddField(new FieldType { Name = partitionKey.EscapePartition(), Arguments = ContentActions.Json.Arguments, ResolvedType = AllTypes.Json, Resolver = FieldVisitor.JsonPath, Description = fieldInfo.Field.RawProperties.Hints }).WithSourceName(partitionKey); } fieldGraphType.Description = $"The dynamic structure of the {fieldInfo.DisplayName} field of the {schemaInfo.DisplayName} content type."; AddField(new FieldType { Name = fieldInfo.FieldNameDynamic, ResolvedType = fieldGraphType, Resolver = ContentResolvers.Field }).WithSourceName(fieldInfo); } var(resolvedType, resolver, args) = builder.GetGraphType(fieldInfo); if (resolver != null) { var fieldGraphType = new ObjectGraphType { // The name is used for equal comparison. Therefore it is important to treat it as readonly. Name = fieldInfo.LocalizedType }; foreach (var partitionKey in partitioning.AllKeys) { fieldGraphType.AddField(new FieldType { Name = partitionKey.EscapePartition(), Arguments = args, ResolvedType = resolvedType, Resolver = resolver, Description = fieldInfo.Field.RawProperties.Hints }).WithSourceName(partitionKey); } fieldGraphType.Description = $"The structure of the {fieldInfo.DisplayName} field of the {schemaInfo.DisplayName} content type."; AddField(new FieldType { Name = fieldInfo.FieldName, ResolvedType = fieldGraphType, Resolver = ContentResolvers.Field }).WithSourceName(fieldInfo); } } Description = $"The structure of the {schemaInfo.DisplayName} data type."; }
public void Initialize(IGraphModel model, ISchemaEntity schema) { var schemaType = schema.TypeName(); var schemaName = schema.DisplayName(); Name = $"{schemaType}DataDto"; foreach (var field in schema.SchemaDef.Fields.ForApi()) { var(resolvedType, valueResolver) = model.GetGraphType(schema, field); if (valueResolver != null) { var fieldType = field.TypeName(); var fieldName = field.DisplayName(); var fieldGraphType = new ObjectGraphType { Name = $"{schemaType}Data{fieldType}Dto" }; var partition = model.ResolvePartition(field.Partitioning); foreach (var partitionItem in partition) { var key = partitionItem.Key; var partitionResolver = new FuncFieldResolver <object>(c => { if (((ContentFieldData)c.Source).TryGetValue(key, out var value)) { return(valueResolver(value, c)); } else { return(null); } }); fieldGraphType.AddField(new FieldType { Name = key.EscapePartition(), Resolver = partitionResolver, ResolvedType = resolvedType, Description = field.RawProperties.Hints }); } fieldGraphType.Description = $"The structure of the {fieldName} field of the {schemaName} content type."; var fieldResolver = new FuncFieldResolver <NamedContentData, IReadOnlyDictionary <string, IJsonValue> >(c => { return(c.Source.GetOrDefault(field.Name)); }); AddField(new FieldType { Name = field.Name.ToCamelCase(), Resolver = fieldResolver, ResolvedType = fieldGraphType, Description = $"The {fieldName} field." }); } } Description = $"The structure of the {schemaName} content type."; }