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);
}
