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