private async Task <ISchema> Create() { // Do some async work to build the schema. For example // load SDL from file await Task.Delay(0); // Build simple schema from SDL string var builder = new SchemaBuilder() .Sdl( @" type Query { firstName: String! lastName: String! } schema { query: Query } "); // Bind resolvers and build return(SchemaTools .MakeExecutableSchemaWithIntrospection( builder, new ObjectTypeMap() { ["Query"] = new FieldResolversMap() { { "firstName", context => ResolveSync.As("Tanka") }, { "lastName", UseService() } } })); }
private static Resolver DefaultDictionaryResolver() { return(context => { object value = null; if (context.ObjectValue is IDictionary <string, object> dictionary) { value = dictionary[context.FieldName]; } else if (context.ObjectValue is KeyValuePair <string, object> keyValue) { value = keyValue.Value; } else if (context.ObjectValue is ExecutionResult er) { return new ValueTask <IResolveResult>(new PreExecutedResolveResult(er.Data)); } if (value is IDictionary <string, object> ) { return ResolveSync.As(value); } if (value is IEnumerable enumerable && !(value is string)) { return ResolveSync.As(enumerable); } return ResolveSync.As(value); }); }
public IntrospectionResolvers(string queryTypeName = "Query") { this[queryTypeName] = new FieldResolversMap { { "__schema", context => ResolveSync.As(context.Schema) }, { "__type", context => ResolveSync.As(context.Schema.GetNamedType(context.GetArgument <string>("name"))) } }; this[IntrospectionSchema.SchemaName] = new FieldResolversMap { { "types", context => ResolveSync.As(context.Schema .QueryTypes <TypeDefinition>(IsNotBuiltIn) .OrderBy(t => t.Name.Value)) }, { "queryType", context => ResolveSync.As(context.Schema.Query) }, { "mutationType", context => ResolveSync.As(context.Schema.Mutation) }, { "subscriptionType", context => ResolveSync.As(context.Schema.Subscription) }, { "directives", context => ResolveSync.As(context.Schema.QueryDirectiveTypes().OrderBy(t => t.Name.Value)) } }; this[IntrospectionSchema.TypeName] = new FieldResolversMap { { "kind", Resolve.PropertyOf <INode>((t, context) => KindOf(context.Schema, t)) },
public async Task Create_Field_Subscriber() { /* Given */ var builder = new SchemaBuilder(); builder.Query(out var query) .Connections(connections => { connections.Field(query, "field1", ScalarType.String, "test field", resolve => resolve.Run(context => ResolveSync.As(42)), subscribe => subscribe.Run((context, unsubscribe) => ResolveSync.Subscribe(new EventChannel <object>(), unsubscribe))); }); /* When */ var sut = builder.Build(); /* Then */ var result = await sut.GetSubscriber(query.Name, "field1")(null, CancellationToken.None); Assert.NotNull(result.Reader); }
public static ISchema InitializeSchema() { var events = new SingleValueEventChannel(); var builder = new SchemaBuilder(); Sdl.Import(Parser.ParseDocument( @" type Query { simple: String } type Mutation { simple: String } type Subscription { simple: String } schema { query: Query mutation: Mutation subscription: Subscription } "), builder); var resolvers = new ResolverMap { { "Query", new FieldResolverMap { { "simple", context => new ValueTask <IResolveResult>(Resolve.As("value")) } } }, { "Mutation", new FieldResolverMap { { "simple", context => new ValueTask <IResolveResult>(Resolve.As("value")) } } }, { "Subscription", new FieldResolverMap() { { "simple", (context, unsubscribe) => ResolveSync.Subscribe(events, unsubscribe), context => new ValueTask <IResolveResult>(Resolve.As(context.ObjectValue)) } } } }; var schema = SchemaTools.MakeExecutableSchema( builder, resolvers, resolvers); return(schema); }
public static Task <ISchema> InitializeSchema() { var events = new SingleValueEventChannel(); var builder = new SchemaBuilder() .Add( @" type Query { simple: String } type Mutation { simple: String } type Subscription { simple: String } schema { query: Query mutation: Mutation subscription: Subscription } "); var resolvers = new ResolversMap { { "Query", new FieldResolversMap { { "simple", context => new ValueTask <IResolverResult>(Resolve.As("value")) } } }, { "Mutation", new FieldResolversMap { { "simple", context => new ValueTask <IResolverResult>(Resolve.As("value")) } } }, { "Subscription", new FieldResolversMap { { "simple", (context, unsubscribe) => ResolveSync.Subscribe(events, unsubscribe), context => new ValueTask <IResolverResult>(Resolve.As(context.ObjectValue)) } } } }; return(builder.Build(resolvers, resolvers)); }
public static Resolver PropertyOf <T>(Func <T, IResolverContext, object?> getValue) { return(context => { var source = context.ObjectValue is T objectValue ? objectValue : default; if (source == null) { return ResolveSync.As(null); } var value = getValue(source, context); return ResolveSync.As(value); }); }
public SubscriptionsFacts() { // schema var builder = new SchemaBuilder() .Add(@" type Message { content: String } type Query { messages: [Message] } type Subscription { messageAdded: Message } "); // data var messages = new List <Message>(); _messagesChannel = new EventChannel <Message>(); // resolvers ValueTask <IResolverResult> GetMessagesAsync(IResolverContext context) { return(ResolveSync.As(messages)); } ValueTask <ISubscriberResult> OnMessageAdded(IResolverContext context, CancellationToken unsubscribe) { return(ResolveSync.Subscribe(_messagesChannel, unsubscribe)); } ValueTask <IResolverResult> ResolveMessage(IResolverContext context) { return(ResolveSync.As(context.ObjectValue)); } var resolvers = new ResolversMap {
public static Resolver PropertyOf <T>(Func <T, IEnumerable <object?>?> getValue) { return(context => { var source = context.ObjectValue is T objectValue ? objectValue : default; if (source == null) { return ResolveSync.As(null); } var values = getValue(source); if (values == null) { return ResolveSync.As(null); } return ResolveSync.As(values); }); }
public IntrospectionResolvers(ISchema source) { this[source.Query.Name] = new FieldResolverMap { { "__schema", context => ResolveSync.As(source) }, { "__type", context => ResolveSync.As( source.GetNamedType(context.GetArgument <string>("name"))) } }; this[IntrospectionSchema.SchemaName] = new FieldResolverMap { { "types", context => ResolveSync.As(source.QueryTypes <INamedType>()) }, { "queryType", context => ResolveSync.As(source.Query) }, { "mutationType", context => ResolveSync.As(source.Mutation) }, { "subscriptionType", context => ResolveSync.As(source.Subscription) }, { "directives", context => ResolveSync.As(source.QueryDirectiveTypes()) } }; this[IntrospectionSchema.TypeName] = new FieldResolverMap { { "kind", Resolve.PropertyOf <IType>(t => KindOf(t)) },
public async Task Part6_Custom_Scalar() { // Create builder and load sdl var builder = new SchemaBuilder() .Add(@" # Custom scalar defined in the SDL scalar Uri type Query { url: Uri! } "); // Build schema by binding resolvers from ObjectTypeMap var schema = await builder.Build(new SchemaBuildOptions { Resolvers = new ResolversMap { { "Query", new FieldResolversMap { { "url", context => ResolveSync.As(new Uri("https://localhost/")) } } } }, ValueConverters = new Dictionary<string, IValueConverter> { // this will add value converter for Uri scalar type ["Uri"] = new InlineConverter( value => { var uri = (Uri)value; return uri.ToString(); }, parseValue: value => new Uri(value.ToString()), parseLiteral: value => { if (value.Kind == NodeKind.StringValue) return new Uri((StringValue)value); throw new ArgumentOutOfRangeException( nameof(value), $"Cannot coerce Uri from value kind: '{value.Kind}'"); }, serializeLiteral: value => new StringValue(Encoding.UTF8.GetBytes(value.ToString()))) } }); // execute query var result = await Executor.ExecuteAsync(new ExecutionOptions { Schema = schema, Document = @"{ url }" }); var url = result.Data["url"]; Assert.Equal("https://localhost/", url.ToString()); }
public ValueTask <IResolverResult> QueryLastName(IResolverContext context) { return(ResolveSync.As("GraphQL")); }
public async Task Execute_with_StaticLink() { /* Given */ var schemaOneBuilder = new SchemaBuilder() .Sdl( @" type User { id: ID! name: String! } type Query { userById(id: ID!): User } schema { query: Query } "); var schemaTwoBuilder = new SchemaBuilder() .Sdl( @" type Address { city: String! } type User { address: Address! } type Query { } " ); var schemaOne = RemoteSchemaTools.MakeRemoteExecutable( schemaOneBuilder, RemoteLinks.Static(new ExecutionResult { Data = new Dictionary <string, object> { ["userById"] = new Dictionary <string, object> { ["id"] = "1", ["name"] = "name" } } })); var schemaTwo = SchemaTools.MakeExecutableSchema( schemaTwoBuilder, new ObjectTypeMap { ["Address"] = new FieldResolversMap { { "city", context => ResolveSync.As(context.ObjectValue) } }, ["User"] = new FieldResolversMap { { "address", context => ResolveSync.As("Vantaa") } } }); var schema = new SchemaBuilder() .Merge(schemaOne, schemaTwo) .Build(); /* When */ var result = await Executor.ExecuteAsync(new ExecutionOptions { Schema = schema, Document = Parser.ParseDocument(@" { userById(id: ""1"") { id name address { city } } }") }); /* Then */ result.ShouldMatchJson( @" { ""data"": { ""userById"": { ""address"": { ""city"": ""Vantaa"" }, ""name"": ""name"", ""id"": ""1"" } } } "); }
public async Task Subscriptions() { /* Given */ var schemaOneBuilder = new SchemaBuilder() .Sdl( @" type User { id: ID! name: String! } type Query { userById(id: ID!): User } type Subscription { userAdded: User } schema { query: Query subscription: Subscription } "); var schemaTwoBuilder = new SchemaBuilder() .Sdl( @" type Address { city: String! } type User { address: Address! } type Query { } type Subscription { } " ); var schemaOne = RemoteSchemaTools.MakeRemoteExecutable( schemaOneBuilder, RemoteLinks.Static(new ExecutionResult { Data = new Dictionary <string, object> { ["userAdded"] = new Dictionary <string, object> { ["id"] = "1", ["name"] = "name" } } })); var schemaTwo = SchemaTools.MakeExecutableSchema( schemaTwoBuilder, new ObjectTypeMap { ["Address"] = new FieldResolversMap { { "city", context => ResolveSync.As(context.ObjectValue) } }, ["User"] = new FieldResolversMap { { "address", context => ResolveSync.As("Vantaa") } } }); var schema = new SchemaBuilder() .Merge(schemaOne, schemaTwo) .Build(); var unsubscribe = new CancellationTokenSource(TimeSpan.FromSeconds(30)); /* When */ var subscriptionResult = await Executor.SubscribeAsync(new ExecutionOptions { Schema = schema, Document = Parser.ParseDocument(@" subscription { userAdded { id name address { city } } }") }, unsubscribe.Token); var result = await subscriptionResult.Source.Reader.ReadAsync(unsubscribe.Token); /* Then */ result.ShouldMatchJson( @" { ""data"": { ""userAdded"": { ""address"": { ""city"": ""Vantaa"" }, ""name"": ""name"", ""id"": ""1"" } } } "); }
public async Task Part6_Custom_Scalar() { // Create builder and load sdl var builder = new SchemaBuilder() .Sdl(@" # Custom scalar defined in the SDL scalar Uri type Query { url: Uri! } "); // Get query type builder.GetQuery(out var query); // Build schema by binding resolvers from ObjectTypeMap var schema = SchemaTools.MakeExecutableSchema( builder, new ObjectTypeMap { { query.Name, new FieldResolversMap { { "url", context => ResolveSync.As(new Uri("https://localhost/")) } } } }, converters: new Dictionary <string, IValueConverter>() { // this will add value converter for Uri scalar type ["Uri"] = new InlineConverter( serialize: value => { var uri = (Uri)value; return(uri.ToString()); }, parseValue: value => new Uri(value.ToString()), parseLiteral: value => { if (value.Kind == NodeKind.StringValue) { return(new Uri((StringValue)value)); } throw new ArgumentOutOfRangeException( nameof(value), $"Cannot coerce Uri from value kind: '{value.Kind}'"); }) }); // execute query var result = await Executor.ExecuteAsync(new ExecutionOptions() { Schema = schema, Document = Parser.ParseDocument(@"{ url }") }); var url = result.Data["url"]; Assert.Equal("https://localhost/", url.ToString()); }
public ValueTask <IResolveResult> ResolveMessageAsync(ResolverContext context) { return(ResolveSync.As(context.ObjectValue)); }
public SubscriptionsFacts() { // schema var builder = new SchemaBuilder(); builder.Object("Message", out var messageType) .Connections(connect => connect .Field(messageType, "content", ScalarType.String)); var messageListType = new List(messageType); builder.Query(out var query) .Connections(connect => connect .Field(query, "messages", messageListType)); builder.Subscription(out var subscription) .Connections(connect => connect .Field(subscription, "messageAdded", messageType)); var schema = builder.Build(); // data var messages = new List <Message>(); _messagesChannel = new EventChannel <Message>(); // resolvers ValueTask <IResolveResult> GetMessagesAsync(ResolverContext context) { return(ResolveSync.As(messages)); } ValueTask <ISubscribeResult> OnMessageAdded(ResolverContext context, CancellationToken unsubscribe) { return(ResolveSync.Subscribe(_messagesChannel, unsubscribe)); } ValueTask <IResolveResult> ResolveMessage(ResolverContext context) { return(ResolveSync.As(context.ObjectValue)); } var resolvers = new ResolverMap { ["Query"] = new FieldResolverMap { { "messages", GetMessagesAsync } }, ["Subscription"] = new FieldResolverMap { { "messageAdded", OnMessageAdded, ResolveMessage } }, ["Message"] = new FieldResolverMap { { "content", Resolve.PropertyOf <Message>(r => r.Content) } } }; // make executable _executable = SchemaTools.MakeExecutableSchema( schema, resolvers, resolvers); }