public static SchemaBuilder Sdl(this SchemaBuilder builder, TypeSystemDocument document)
{
var reader = new SdlReader(document, builder);
reader.Read();
return(builder);
}
public static TypeSystemDocument WithTypeSystem(this TypeSystemDocument left, TypeSystemDocument right)
{
var schemaDefinitions = left.SchemaDefinitions ?? Array.Empty <SchemaDefinition>();
var typeDefinitions = left.TypeDefinitions ?? Array.Empty <TypeDefinition>();
var directiveDefinitions = left.DirectiveDefinitions ?? Array.Empty <DirectiveDefinition>();
var schemaExtensions = left.SchemaExtensions ?? Array.Empty <SchemaExtension>();
var typeExtensions = left.TypeExtensions ?? Array.Empty <TypeExtension>();
var imports = left.Imports ?? Array.Empty <Import>();
return(new TypeSystemDocument(
right.SchemaDefinitions != null
? schemaDefinitions.Concat(right.SchemaDefinitions).ToList()
: schemaDefinitions,
right.TypeDefinitions != null
? typeDefinitions.Concat(right.TypeDefinitions).ToList()
: typeDefinitions,
right.DirectiveDefinitions != null
? directiveDefinitions.Concat(right.DirectiveDefinitions).ToList()
: directiveDefinitions,
right.SchemaExtensions != null
? schemaExtensions.Concat(right.SchemaExtensions).ToList()
: schemaExtensions,
right.TypeExtensions != null
? typeExtensions.Concat(right.TypeExtensions).ToList()
: typeExtensions,
right.Imports != null
? imports.Concat(right.Imports).ToList()
: imports
));
}
public static TypeSystemDocument WithSchemaExtensions(
this TypeSystemDocument document, IReadOnlyList <SchemaExtension>?definitions)
{
return(new TypeSystemDocument(
document.SchemaDefinitions,
document.TypeDefinitions,
document.DirectiveDefinitions,
definitions,
document.TypeExtensions));
}
private void VisitTypeSystemDocument(TypeSystemDocument node)
{
EnterNode(node);
if (node.Imports != null)
{
foreach (var import in node.Imports)
{
Visit(import);
}
}
if (node.DirectiveDefinitions != null)
{
foreach (var definition in node.DirectiveDefinitions)
{
Visit(definition);
}
}
if (node.TypeDefinitions != null)
{
foreach (var definition in node.TypeDefinitions)
{
Visit(definition);
}
}
if (node.SchemaDefinitions != null)
{
foreach (var definition in node.SchemaDefinitions)
{
Visit(definition);
}
}
if (node.TypeExtensions != null)
{
foreach (var extension in node.TypeExtensions)
{
Visit(extension);
}
}
if (node.SchemaExtensions != null)
{
foreach (var extension in node.SchemaExtensions)
{
Visit(extension);
}
}
ExitNode(node);
}
public void FromString()
{
/* Given */
/* When */
TypeSystemDocument original = "scalar Scalar extend scalar Scalar @a";
/* Then */
Assert.NotNull(original.TypeDefinitions);
Assert.Single(original.TypeDefinitions);
Assert.NotNull(original.TypeExtensions);
Assert.Single(original.TypeExtensions);
}
public async Task Execute_with_StaticLink()
{
/* Given */
TypeSystemDocument schemaOne =
@"
extend type User {
id: ID!
name: String!
}
extend type Query {
userById(id: ID!): User
}
extend schema {
query: Query
}
";
TypeSystemDocument schemaTwo =
@"
type Address {
city: String!
}
type User {
address: Address!
}
type Query {
}
";
var schemaOneResolvers = RemoteSchemaTools.CreateLinkResolvers(
schemaOne,
RemoteLinks.Static(new ExecutionResult
{
Data = new Dictionary <string, object>
{
["userById"] = new Dictionary <string, object>
{
["id"] = "1",
["name"] = "name"
}
}
}));
var schemaTwoResolvers =
new ResolversMap
{
//todo: use ResolversBuilder.AddLinkedTypes()
/// <summary>
/// Create resolvers for ObjectTypes and ObjectType extensions in <see cref="TypeSystemDocument"/> which
/// resolve the values using the given <paramref name="link"/>
/// </summary>
/// <param name="remoteTypes"></param>
/// <param name="link"></param>
/// <param name="createResolver"></param>
/// <param name="createSubscriber"></param>
/// <returns></returns>
public static ResolversMap CreateLinkResolvers(
TypeSystemDocument remoteTypes,
ExecutionResultLink link,
Func <ExecutionResultLink, Resolver> createResolver = null,
Func <ExecutionResultLink, Subscriber> createSubscriber = null)
{
if (createResolver == null)
{
createResolver = DefaultCreateRemoteResolver;
}
if (createSubscriber == null)
{
createSubscriber = DefaultCreateRemoteSubscriber;
}
var objectDefinitionsAndExtensions = GetObjectDefinitions(remoteTypes);
var rootTypes = objectDefinitionsAndExtensions.Where(type => RootTypes.Contains(type.Name.Value))
.OfType <ObjectDefinition>();
ResolversMap resolvers = new ResolversMap();
foreach (var rootType in rootTypes)
{
foreach (var field in rootType.Fields)
{
if (rootType.Name != "Subscription")
{
resolvers.Add(rootType.Name.Value, field.Name.Value, createResolver(link));
}
else
{
resolvers.Add(rootType.Name.Value, field.Name.Value, createSubscriber(link));
}
}
}
var resolver = DefaultDictionaryResolver();
foreach (var objectType in objectDefinitionsAndExtensions.Where(type => !RootTypes.Contains(type.Name.Value))
.OfType <ObjectDefinition>())
{
foreach (var field in objectType.Fields)
{
resolvers.Add(objectType.Name.Value, field.Name.Value, resolver);
}
}
return(resolvers);
}
public void FromBytes()
{
/* Given */
/* When */
TypeSystemDocument original = Encoding.UTF8.GetBytes("scalar Scalar extend scalar Scalar @a")
.AsReadOnlySpan();
/* Then */
Assert.NotNull(original.TypeDefinitions);
Assert.Single(original.TypeDefinitions);
Assert.NotNull(original.TypeExtensions);
Assert.Single(original.TypeExtensions);
}
public static IEnumerable <NamedType> GetNamedTypes(this TypeSystemDocument document)
{
if (document.DirectiveDefinitions is not null)
{
foreach (var definition in document.DirectiveDefinitions)
{
yield return(new NamedType(definition.Name, definition.Location));
}
}
if (document.TypeDefinitions is not null)
{
foreach (var definition in document.TypeDefinitions)
{
yield return(new NamedType(definition.Name, definition.Location));
}
}
}
private static IEnumerable <ObjectDefinition> GetObjectDefinitions(TypeSystemDocument typeSystem)
{
if (typeSystem.TypeDefinitions != null)
{
foreach (var typeDefinition in typeSystem.TypeDefinitions)
{
if (typeDefinition is ObjectDefinition objectDefinition)
{
yield return(objectDefinition);
}
}
}
if (typeSystem.TypeExtensions != null)
{
foreach (var typeExtension in typeSystem.TypeExtensions)
{
if (typeExtension.ExtendedKind == NodeKind.ObjectDefinition)
{
yield return((ObjectDefinition)typeExtension.Definition);
}
}
}
}
public SdlReader(TypeSystemDocument document, SchemaBuilder?builder = null)
{
_document = document;
_builder = builder ?? new SchemaBuilder();
}
protected virtual void ExitTypeSystemDocument(TContext context, TypeSystemDocument typeSystemDocument)
{
}
