public IObjectFieldDescriptor ResolveNode(FieldResolverDelegate fieldResolver)
{
Definition.Resolver = fieldResolver ??
throw new ArgumentNullException(nameof(fieldResolver));
return(_configureNodeField());
}
public void ObjectTypeExtension_SetArgumentContextData()
{
// arrange
FieldResolverDelegate resolver =
ctx => new ValueTask <object>(null);
// act
ISchema schema = SchemaBuilder.New()
.AddQueryType <FooType>()
.AddType(new ObjectTypeExtension(d => d
.Name("Foo")
.Field("name")
.Type <StringType>()
.Argument("a", a => a
.Type <StringType>()
.Extend()
.OnBeforeCreate(c => c.ContextData["foo"] = "bar"))))
.Create();
// assert
ObjectType type = schema.GetType <ObjectType>("Foo");
Assert.True(type.Fields["name"].Arguments["a"]
.ContextData.ContainsKey("foo"));
}
private static FieldResolverDelegate BuildMiddleware(
IEnumerable <FieldMiddleware> components,
IEnumerable <FieldMiddleware> mappedComponents,
FieldResolverDelegate first)
{
FieldDelegate next = async ctx =>
{
if (!ctx.IsResultModified && first != null)
{
ctx.Result = await first(ctx);
}
};
foreach (FieldMiddleware component in mappedComponents.Reverse())
{
next = component(next);
}
foreach (FieldMiddleware component in components.Reverse())
{
next = component(next);
}
return(async ctx =>
{
var context = new MiddlewareContext(ctx, () => first(ctx));
await next(context);
return context.Result;
});
}
public void InterfaceTypeExtension_SetArgumentContextData()
{
// arrange
FieldResolverDelegate resolver =
ctx => Task.FromResult <object>(null);
// act
ISchema schema = SchemaBuilder.New()
.AddQueryType <DummyQuery>()
.AddType <FooType>()
.AddType(new InterfaceTypeExtension(d => d
.Name("Foo")
.Field("name")
.Type <StringType>()
.Argument("a", a => a
.Type <StringType>()
.Extend()
.OnBeforeCreate(c => c.ContextData["foo"] = "bar"))))
.ModifyOptions(o => o.StrictValidation = false)
.Create();
// assert
InterfaceType type = schema.GetType <InterfaceType>("Foo");
Assert.True(type.Fields["name"].Arguments["a"]
.ContextData.ContainsKey("foo"));
}
public static FieldDelegate Compile(
IReadOnlyList <FieldMiddleware> globalComponents,
IReadOnlyList <FieldMiddleware> fieldComponents,
FieldResolverDelegate fieldResolver,
bool isIntrospection)
{
if (globalComponents == null)
{
throw new ArgumentNullException(nameof(globalComponents));
}
if (fieldComponents == null)
{
throw new ArgumentNullException(nameof(fieldComponents));
}
if (isIntrospection ||
(globalComponents.Count == 0 &&
fieldComponents.Count == 0))
{
if (fieldResolver == null)
{
return(null);
}
return(CreateResolverMiddleware(fieldResolver));
}
return(BuildMiddleware(
globalComponents,
fieldComponents,
fieldResolver));
}
public void AddResolver_Resolver_ResolverIsSet()
{
// arrange
var queryType = new ObjectType(t => t
.Name("TestMe")
.Field("foo")
.Type <StringType>());
FieldResolverDelegate resolverDelegate =
c => Task.FromResult <object>(null);
var resolverDescriptor =
new FieldResolver("TestMe", "foo", resolverDelegate);
// act
ISchema schema = SchemaBuilder.New()
.AddQueryType(queryType)
.AddResolver(resolverDescriptor)
.Create();
// assert
ObjectType type = schema.GetType <ObjectType>("TestMe");
Assert.NotNull(type);
Assert.Equal(resolverDelegate, type.Fields["foo"].Resolver);
}
public new IObjectFieldDescriptor <T> Resolver(
FieldResolverDelegate fieldResolver,
Type resultType)
{
base.Resolver(fieldResolver, resultType);
return(this);
}
public IObjectFieldDescriptor Resolver(
FieldResolverDelegate fieldResolver,
Type resultType)
{
if (fieldResolver == null)
{
throw new ArgumentNullException(nameof(fieldResolver));
}
Definition.Resolver = fieldResolver;
if (resultType != null)
{
Definition.SetMoreSpecificType(resultType, TypeContext.Output);
Type resultTypeDef = resultType.GetGenericTypeDefinition();
Type clrResultType = resultType.IsGenericType &&
resultTypeDef == typeof(NativeType <>)
? resultType.GetGenericArguments()[0]
: resultType;
if (!BaseTypes.IsSchemaType(clrResultType))
{
Definition.ResultType = clrResultType;
}
}
return(this);
}
IObjectFieldDescriptor IObjectFieldDescriptor.Resolver(
FieldResolverDelegate fieldResolver,
Type resultType)
{
Resolver(fieldResolver, resultType);
return(this);
}
public void ApplyBinding(
ISchemaContext schemaContext,
ResolverBindingInfo resolverBindingInfo)
{
if (resolverBindingInfo is ResolverDelegateBindingInfo b)
{
if (b.AsyncFieldResolver == null)
{
schemaContext.Resolvers.RegisterResolver(
new DelegateResolverBinding(
b.ObjectTypeName, b.FieldName, b.FieldResolver));
}
else
{
FieldResolverDelegate fieldResolverDelegate =
(ctx, ct) => b.AsyncFieldResolver(ctx, ct);
schemaContext.Resolvers.RegisterResolver(
new DelegateResolverBinding(
b.ObjectTypeName, b.FieldName, fieldResolverDelegate));
}
}
else
{
throw new NotSupportedException(
"The binding type is not supported by this handler.");
}
}
public static ISchemaBuilder AddResolver(
this ISchemaBuilder builder,
FieldCoordinate field,
FieldResolverDelegate resolver,
Type?resultType = null)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
if (!field.HasValue)
{
throw new ArgumentException(
TypeResources.SchemaBuilderExtensions_AddResolver_EmptyCooridnates,
nameof(builder));
}
if (resolver is null)
{
throw new ArgumentNullException(nameof(resolver));
}
return(AddResolverConfigInternal(builder, field, resolver, resultType));
}
public IResolverFieldBindingBuilder SetResolver(
FieldResolverDelegate resolver)
{
_bindingInfo.ResolverDelegate = resolver
?? throw new ArgumentNullException(nameof(resolver));
return(this);
}
public void InterfaceTypeExtension_Deprecate_Without_Reason()
{
// arrange
FieldResolverDelegate resolver =
ctx => new ValueTask <object>(null);
// act
ISchema schema = SchemaBuilder.New()
.AddQueryType <DummyQuery>()
.AddType <FooType>()
.AddType(new InterfaceTypeExtension(d => d
.Name("Foo")
.Field("description")
.Type <StringType>()
.Deprecated()))
.ModifyOptions(o => o.StrictValidation = false)
.Create();
// assert
InterfaceType type = schema.GetType <InterfaceType>("Foo");
Assert.True(type.Fields["description"].IsDeprecated);
Assert.Equal(
WellKnownDirectives.DeprecationDefaultReason,
type.Fields["description"].DeprecationReason);
}
public void ObjectTypeExtension_DeprecateField_Without_Reason()
{
// arrange
FieldResolverDelegate resolver =
ctx => new ValueTask <object>(null);
// act
ISchema schema = SchemaBuilder.New()
.AddQueryType <FooType>()
.AddType(new ObjectTypeExtension(d => d
.Name("Foo")
.Field("description")
.Type <StringType>()
.Deprecated()))
.Create();
// assert
ObjectType type = schema.GetType <ObjectType>("Foo");
Assert.True(type.Fields["description"].IsDeprecated);
Assert.Equal(
WellKnownDirectives.DeprecationDefaultReason,
type.Fields["description"].DeprecationReason);
schema.ToString().MatchSnapshot();
}
private void Initialize(FieldDescriptor descriptor)
{
if (string.IsNullOrEmpty(descriptor.Name))
{
throw new ArgumentException(
"A field name must not be null or empty.",
nameof(descriptor));
}
foreach (InputField argument in descriptor.GetArguments()
.Select(t => new InputField(t)))
{
_argumentMap[argument.Name] = argument;
}
_member = descriptor.Member;
_typeReference = descriptor.TypeReference;
SyntaxNode = descriptor.SyntaxNode;
Name = descriptor.Name;
Description = descriptor.Description;
DeprecationReason = descriptor.DeprecationReason;
IsDeprecated = !string.IsNullOrEmpty(descriptor.DeprecationReason);
Resolver = descriptor.Resolver;
}
public FieldDelegate CreateMiddleware(
IEnumerable <FieldMiddleware> middlewareComponents,
FieldResolverDelegate fieldResolver,
bool isIntrospection)
{
if (middlewareComponents == null)
{
throw new ArgumentNullException(nameof(middlewareComponents));
}
FieldMiddleware[] components = middlewareComponents.ToArray();
if (isIntrospection ||
(_middlewareComponents.Count == 0 &&
components.Length == 0))
{
if (fieldResolver == null)
{
return(null);
}
return(CreateResolverMiddleware(fieldResolver));
}
return(BuildMiddleware(
_middlewareComponents,
components,
fieldResolver));
}
public async Task DeriveResolverFromObjectTypeMethod()
{
// arrange
var dummyObjectType = new TestObjectB();
var resolverContext = new Mock <IResolverContext>();
resolverContext.Setup(t => t.Parent <TestObjectB>())
.Returns(dummyObjectType);
var source = @"type Dummy { bar2: String }";
// act
ISchema schema = SchemaBuilder.New()
.AddQueryType <DummyQuery>()
.AddDocumentFromString(source)
.BindRuntimeType <TestObjectB>("Dummy")
.Create();
// assert
ObjectType dummy = schema.GetType <ObjectType>("Dummy");
FieldResolverDelegate fieldResolver = dummy.Fields["bar2"].Resolver;
var result = await fieldResolver !(resolverContext.Object);
Assert.Equal(dummyObjectType.GetBar2(), result);
}
public FieldResolver(
string typeName, string fieldName,
FieldResolverDelegate resolver)
: base(typeName, fieldName)
{
Resolver = resolver
?? throw new ArgumentNullException(nameof(resolver));
}
protected void Resolver(
FieldResolverDelegate fieldResolver,
Type resultType)
{
FieldDescription.Resolver = fieldResolver;
FieldDescription.TypeReference = FieldDescription.TypeReference
.GetMoreSpecific(resultType, TypeContext.Output);
}
public FieldResolverDelegate CreateFieldMiddleware(
IEnumerable <FieldMiddleware> mappedMiddlewareComponents,
FieldResolverDelegate fieldResolver)
{
return(_schemaContext.Resolvers.CreateMiddleware(
mappedMiddlewareComponents,
fieldResolver));
}
private static FieldDelegate CompilePipeline(
IReadOnlyList <FieldMiddleware> components,
IReadOnlyList <FieldMiddlewareDefinition> mappedComponents,
IReadOnlyList <ResultConverterDefinition> resultConverters,
FieldResolverDelegate fieldResolver)
=> CompileMiddlewareComponents(components,
CompileMiddlewareComponents(mappedComponents,
CompileResultConverters(resultConverters,
CreateResolverMiddleware(fieldResolver))));
private static FieldDelegate BuildMiddleware(
IReadOnlyList <FieldMiddleware> components,
IReadOnlyList <FieldMiddleware> mappedComponents,
FieldResolverDelegate fieldResolver)
{
return(IntegrateComponents(components,
IntegrateComponents(mappedComponents,
CreateResolverMiddleware(fieldResolver))));
}
public FieldResolver WithResolver(FieldResolverDelegate resolver)
{
if (Equals(Resolver, resolver))
{
return(this);
}
return(new FieldResolver(TypeName, FieldName, resolver));
}
public FieldResolver(
FieldReference fieldReference,
FieldResolverDelegate resolver)
: base(fieldReference)
{
_fieldReference = fieldReference;
Resolver = resolver
?? throw new ArgumentNullException(nameof(resolver));
}
private static FieldDelegate CreateResolverMiddleware(
FieldResolverDelegate fieldResolver)
{
return(async ctx =>
{
if (!ctx.IsResultModified && fieldResolver is { })
{
ctx.Result = await fieldResolver(ctx).ConfigureAwait(false);
}
});
IFieldDescriptor IFieldDescriptor.Resolver(FieldResolverDelegate fieldResolver)
{
if (fieldResolver == null)
{
throw new ArgumentNullException(nameof(fieldResolver));
}
Resolver = fieldResolver;
return(this);
}
public FieldDelegate CreateMiddleware(
IEnumerable <FieldMiddleware> middlewareComponents,
FieldResolverDelegate fieldResolver,
bool isIntrospection)
{
return(_schemaContext.Resolvers.CreateMiddleware(
middlewareComponents,
fieldResolver,
isIntrospection));
}
public FieldResolver(
NameString typeName,
NameString fieldName,
FieldResolverDelegate resolver,
PureFieldDelegate?pureResolver = null)
: base(typeName, fieldName)
{
Resolver = resolver ?? throw new ArgumentNullException(nameof(resolver));
PureResolver = pureResolver;
}
public FieldResolver(
FieldReference fieldReference,
FieldResolverDelegate resolver,
PureFieldDelegate?pureResolver = null)
: base(fieldReference)
{
_fieldReference = fieldReference;
Resolver = resolver ?? throw new ArgumentNullException(nameof(resolver));
PureResolver = pureResolver;
}
public IResolverBindingBuilder SetResolver(
FieldResolverDelegate resolver)
{
if (resolver is null)
{
throw new ArgumentNullException(nameof(resolver));
}
_bindingInfo.Resolver = resolver;
return(this);
}
