public TypeNameMetaFieldType()
{
Name = "__typename";
Type = typeof(NonNullGraphType<StringGraphType>);
Description = "The name of the current Object type at runtime.";
Resolver = new FuncFieldResolver<object>((context) => context.ParentType.Name);
}
public TypeMetaFieldType()
{
Name = "__type";
Type = typeof(__Type);
Description = "Request the type information of a single type.";
Arguments = new QueryArguments(
new QueryArgument<NonNullGraphType<StringGraphType>>
{
Name = "name"
});
Resolver = new FuncFieldResolver<object>(context => context.Schema.FindType((string) context.Arguments["name"]));
}
public void SqlJunction_WhenFieldResolverIsNotNull_DoesntSetResolver()
{
var resolver = new FuncFieldResolver <string>(_ => "");
var fieldType = new FieldType
{
Name = "name",
Resolver = resolver
};
fieldType.SqlJunction("", (join, arguments, context, node) => { },
(join, arguments, context, node) => { });
fieldType.Resolver.Should().Be(resolver);
}
public void Initialize(IGraphModel model, ISchemaEntity schema)
{
var schemaType = schema.TypeName();
var schemaName = schema.DisplayName();
Name = $"{schemaType}DataDto";
foreach (var field in schema.SchemaDef.Fields.Where(x => !x.IsHidden))
{
var fieldInfo = model.GetGraphType(field);
if (fieldInfo.ResolveType != null)
{
var fieldName = field.RawProperties.Label.WithFallback(field.Name);
var fieldGraphType = new ObjectGraphType
{
Name = $"{schemaType}Data{field.Name.ToPascalCase()}Dto"
};
var partition = model.ResolvePartition(field.Partitioning);
foreach (var partitionItem in partition)
{
fieldGraphType.AddField(new FieldType
{
Name = partitionItem.Key,
Resolver = fieldInfo.Resolver,
ResolvedType = fieldInfo.ResolveType,
Description = field.RawProperties.Hints
});
}
fieldGraphType.Description = $"The structure of the {fieldName} of a {schemaName} content type.";
var fieldResolver = new FuncFieldResolver <NamedContentData, ContentFieldData>(c => c.Source.GetOrDefault(field.Name));
AddField(new FieldType
{
Name = field.Name.ToCamelCase(),
Resolver = fieldResolver,
ResolvedType = fieldGraphType,
Description = $"The {fieldName} field."
});
}
}
Description = $"The structure of a {schemaName} content type.";
}
public ChatSubscriptions(IChat chat)
{
_chat = chat;
AddField(new EventStreamFieldType
{
Name = "messageAdded",
Type = typeof(MessageType),
Resolver = new FuncFieldResolver <Message>(ResolveMessage),
Subscriber = new EventStreamResolver <Message>(Subscribe)
});
AddField(new EventStreamFieldType
{
Name = "contentAdded",
Type = typeof(MessageType),
Resolver = new FuncFieldResolver <Message>(ResolveMessage),
Subscriber = new EventStreamResolver <Message>(Subscribe)
});
AddField(new EventStreamFieldType
{
Name = "messageAddedByUser",
Arguments = new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> > {
Name = "id"
}
),
Type = typeof(MessageType),
Resolver = new FuncFieldResolver <Message>(ResolveMessage),
Subscriber = new EventStreamResolver <Message>(SubscribeById)
});
AddField(new EventStreamFieldType
{
Name = "userJoined",
Type = typeof(MessageFromType),
Resolver = new FuncFieldResolver <MessageFrom>(context => context.Source as MessageFrom),
Subscriber = new EventStreamResolver <MessageFrom>(context => _chat.UserJoined())
});
AddField(new EventStreamFieldType
{
Name = "failImmediately",
Type = typeof(MessageType),
Resolver = new FuncFieldResolver <Message>(ResolveMessage),
Subscriber = new EventStreamResolver <Message>(context => throw new NotSupportedException("this is supposed to fail"))
});
public ContentDataGraphType(Schema schema, IGraphQLContext context)
{
var schemaName = schema.Properties.Label.WithFallback(schema.Name);
Name = $"{schema.Name.ToPascalCase()}DataDto";
foreach (var field in schema.Fields.Where(x => !x.IsHidden))
{
var fieldInfo = context.GetGraphType(field);
if (fieldInfo.ResolveType != null)
{
var fieldName = field.RawProperties.Label.WithFallback(field.Name);
var fieldGraphType = new ObjectGraphType
{
Name = $"{schema.Name.ToPascalCase()}Data{field.Name.ToPascalCase()}Dto"
};
var partition = context.ResolvePartition(field.Paritioning);
foreach (var partitionItem in partition)
{
fieldGraphType.AddField(new FieldType
{
Name = partitionItem.Key,
Resolver = fieldInfo.Resolver,
ResolvedType = fieldInfo.ResolveType,
Description = field.RawProperties.Hints
});
}
fieldGraphType.Description = $"The structure of the {fieldName} of a {schemaName} content type.";
var fieldResolver = new FuncFieldResolver <NamedContentData, ContentFieldData>(c => c.Source.GetOrDefault(field.Name));
AddField(new FieldType
{
Name = field.Name.ToCamelCase(),
Resolver = fieldResolver,
ResolvedType = fieldGraphType
});
}
}
Description = $"The structure of a {schemaName} content type.";
}
public ProfileLocationSubscriptions(IEntityObjectEventService eventService)
{
_eventService = eventService;
_eventService.EntityObjectEvent += EventService_OnEntityObjectEvent;
#region Group
AddField(new EventStreamFieldType
{
Name = "group_OnInsert",
Description = "Raises when a new Group has been inserted",
Type = typeof(GroupType),
Resolver = new FuncFieldResolver <Group>(context => context.Source as Group),
Subscriber = new EventStreamResolver <Group>(context => _groupInsertObservable)
});
AddField(new EventStreamFieldType
{
Name = "group_OnChange",
Description = "Raises when a any update/change to an existing Group",
Type = typeof(GroupType),
Resolver = new FuncFieldResolver <Group>(context => context.Source as Group),
Subscriber = new EventStreamResolver <Group>(context => _groupChangeObservable)
});
AddField(new EventStreamFieldType
{
Name = "group_OnUpdate",
Description = "Raises when specified ID Group has been updated",
Arguments = new QueryArguments(new QueryArgument <NonNullGraphType <IntGraphType> >()
{
Name = "Id", Description = "Key of object to receive updates from"
}),
Type = typeof(GroupType),
Resolver = new FuncFieldResolver <Group>(context => context.Source as Group),
Subscriber = new EventStreamResolver <Group>(context =>
{
var id = context.GetArgument <int>("id");
if (_groupUpdateObservables.TryGetValue(id, out var observable))
{
return(observable);
}
observable = new EntityObservable <Group>(() => _groupUpdateObservables.Remove(id));
_groupUpdateObservables[id] = observable;
return(observable);
})
});
public TypeNameMetaFieldType()
{
Name = "__typename";
Type = typeof(NonNullGraphType <StringGraphType>);
Description = "The name of the current Object type at runtime.";
Resolver = new FuncFieldResolver <object>(context => context.ParentType.Name);
// TODO: kapiris additions - need PR!
/*
* Resolver = new FuncFieldResolver<object>((context) =>
* {
* if (context.ParentType.IsCompositeType()
* && context.ParentType.GetType().GetGenericTypeDefinition() == typeof(ObjectGraphType<>))
* {
* return $"ObjectGraphType<{context.ParentType.GetType().GetGenericArguments()[0]?.Name}>";
* }
*
* return context.ParentType.Name;
* });
*/
}
public void Does_Not_Share_Incomplete_Tasks_Typed()
{
IResolveFieldContext <int?> rfc1 = null;
IResolveFieldContext <int?> rfc2 = null;
var ffr1 = new FuncFieldResolver <int?, Task <string> >(async context => {
rfc1 = context;
await Task.Delay(100);
return("ok");
});
var ffr2 = new FuncFieldResolver <int?, Task <string> >(async context => {
rfc2 = context;
await Task.Delay(100);
return("ok");
});
ffr1.Resolve(_context);
ffr2.Resolve(_context);
rfc1.ShouldNotBeNull();
rfc1.ShouldNotBeSameAs(_context);
rfc2.ShouldNotBeNull();
rfc2.ShouldNotBeSameAs(_context);
rfc1.ShouldNotBe(rfc2);
}
public void Shares_Complete_Untyped()
{
IResolveFieldContext <int?> rfc1 = null;
IResolveFieldContext <int?> rfc2 = null;
var ffr1 = new FuncFieldResolver <int?, object>(context =>
{
rfc1 = context;
return("ok");
});
var ffr2 = new FuncFieldResolver <int?, object>(context =>
{
rfc2 = context;
return("ok");
});
ffr1.Resolve(_context);
ffr2.Resolve(_context);
rfc1.ShouldNotBeNull();
rfc1.ShouldNotBeSameAs(_context);
rfc2.ShouldNotBeNull();
rfc2.ShouldNotBeSameAs(_context);
rfc1.ShouldBe(rfc2);
}
public void Does_Not_Share_Dataloader_Typed()
{
IResolveFieldContext <int?> rfc1 = null;
IResolveFieldContext <int?> rfc2 = null;
var ffr1 = new FuncFieldResolver <int?, IDataLoaderResult>(context =>
{
rfc1 = context;
return(_okDataLoader);
});
var ffr2 = new FuncFieldResolver <int?, IDataLoaderResult>(context =>
{
rfc2 = context;
return(_okDataLoader);
});
ffr1.Resolve(_context);
ffr2.Resolve(_context);
rfc1.ShouldNotBeNull();
rfc1.ShouldNotBeSameAs(_context);
rfc2.ShouldNotBeNull();
rfc2.ShouldNotBeSameAs(_context);
rfc1.ShouldNotBe(rfc2);
}
public void Does_Not_Share_Dataloader_Tasks_Untyped_Derived()
{
IResolveFieldContext <int?> rfc1 = null;
IResolveFieldContext <int?> rfc2 = null;
var ffr1 = new FuncFieldResolver <int?, object>(context =>
{
rfc1 = context;
return(Task.FromResult(_okDataLoader));
});
var ffr2 = new FuncFieldResolver <int?, object>(context =>
{
rfc2 = context;
return(Task.FromResult(_okDataLoader));
});
ffr1.Resolve(_context);
ffr2.Resolve(_context);
rfc1.ShouldNotBeNull();
rfc1.ShouldNotBeSameAs(_context);
rfc2.ShouldNotBeNull();
rfc2.ShouldNotBeSameAs(_context);
rfc1.ShouldNotBe(rfc2);
}
public void Shares_Complete_Tasks_Typed()
{
IResolveFieldContext <int?> rfc1 = null;
IResolveFieldContext <int?> rfc2 = null;
var ffr1 = new FuncFieldResolver <int?, Task <string> >(context =>
{
rfc1 = context;
return(Task.FromResult("ok"));
});
var ffr2 = new FuncFieldResolver <int?, Task <string> >(context =>
{
rfc2 = context;
return(Task.FromResult("ok"));
});
ffr1.Resolve(_context);
ffr2.Resolve(_context);
rfc1.ShouldNotBeNull();
rfc1.ShouldNotBeSameAs(_context);
rfc2.ShouldNotBeNull();
rfc2.ShouldNotBeSameAs(_context);
rfc1.ShouldBe(rfc2);
}
public void Does_Not_Share_Failed_Tasks_Untyped_1()
{
IResolveFieldContext <int?> rfc1 = null;
IResolveFieldContext <int?> rfc2 = null;
var ffr1 = new FuncFieldResolver <int?, object>(context =>
{
rfc1 = context;
return(Task.FromException <string>(new Exception()));
});
var ffr2 = new FuncFieldResolver <int?, object>(context =>
{
rfc2 = context;
return(Task.FromResult("ok"));
});
ffr1.Resolve(_context);
ffr2.Resolve(_context);
rfc1.ShouldNotBeNull();
rfc1.ShouldNotBeSameAs(_context);
rfc2.ShouldNotBeNull();
rfc2.ShouldNotBeSameAs(_context);
rfc1.ShouldNotBe(rfc2);
}
public void Does_Not_Share_Enumerable_Tasks_Untyped()
{
IResolveFieldContext <int?> rfc1 = null;
IResolveFieldContext <int?> rfc2 = null;
var ffr1 = new FuncFieldResolver <int?, object>(context =>
{
rfc1 = context;
return(Task.FromResult <IEnumerable <int> >(new[] { 1, 2 }));
});
var ffr2 = new FuncFieldResolver <int?, object>(context =>
{
rfc2 = context;
return(Task.FromResult <IEnumerable <int> >(new[] { 1, 2 }));
});
ffr1.Resolve(_context);
ffr2.Resolve(_context);
rfc1.ShouldNotBeNull();
rfc1.ShouldNotBeSameAs(_context);
rfc2.ShouldNotBeNull();
rfc2.ShouldNotBeSameAs(_context);
rfc1.ShouldNotBe(rfc2);
}
public async Task Does_Not_Share_Dataloader_Typed()
{
IResolveFieldContext <int?> rfc1 = null;
IResolveFieldContext <int?> rfc2 = null;
var ffr1 = new FuncFieldResolver <int?, IDataLoaderResult>(context =>
{
rfc1 = context;
return(_okDataLoader);
});
var ffr2 = new FuncFieldResolver <int?, IDataLoaderResult>(context =>
{
rfc2 = context;
return(_okDataLoader);
});
await ffr1.ResolveAsync(_context).ConfigureAwait(false);
await ffr2.ResolveAsync(_context).ConfigureAwait(false);
rfc1.ShouldNotBeNull();
rfc1.ShouldNotBeSameAs(_context);
rfc2.ShouldNotBeNull();
rfc2.ShouldNotBeSameAs(_context);
rfc1.ShouldNotBe(rfc2);
}
public async Task Does_Not_Share_Enumerable_Untyped()
{
IResolveFieldContext <int?> rfc1 = null;
IResolveFieldContext <int?> rfc2 = null;
var ffr1 = new FuncFieldResolver <int?, object>(context =>
{
rfc1 = context;
return(new[] { 1, 2 });
});
var ffr2 = new FuncFieldResolver <int?, object>(context =>
{
rfc2 = context;
return(new[] { 1, 2 });
});
await ffr1.ResolveAsync(_context).ConfigureAwait(false);
await ffr2.ResolveAsync(_context).ConfigureAwait(false);
rfc1.ShouldNotBeNull();
rfc1.ShouldNotBeSameAs(_context);
rfc2.ShouldNotBeNull();
rfc2.ShouldNotBeSameAs(_context);
rfc1.ShouldNotBe(rfc2);
}
public async Task Shares_Complete_Untyped()
{
IResolveFieldContext <int?> rfc1 = null;
IResolveFieldContext <int?> rfc2 = null;
var ffr1 = new FuncFieldResolver <int?, object>(context =>
{
rfc1 = context;
return("ok");
});
var ffr2 = new FuncFieldResolver <int?, object>(context =>
{
rfc2 = context;
return("ok");
});
await ffr1.ResolveAsync(_context).ConfigureAwait(false);
await ffr2.ResolveAsync(_context).ConfigureAwait(false);
rfc1.ShouldNotBeNull();
rfc1.ShouldNotBeSameAs(_context);
rfc2.ShouldNotBeNull();
rfc2.ShouldNotBeSameAs(_context);
rfc1.ShouldBe(rfc2);
}
public void Initialize(IGraphModel model, ISchemaEntity schema)
{
var schemaType = schema.TypeName();
var schemaName = schema.DisplayName();
Name = $"{schemaType}DataDto";
foreach (var field in schema.SchemaDef.Fields.ForApi())
{
var(resolvedType, valueResolver) = model.GetGraphType(schema, field);
if (valueResolver != null)
{
var fieldType = field.TypeName();
var fieldName = field.DisplayName();
var fieldGraphType = new ObjectGraphType
{
Name = $"{schemaType}Data{fieldType}Dto"
};
var partition = model.ResolvePartition(field.Partitioning);
foreach (var partitionItem in partition)
{
var key = partitionItem.Key;
var partitionResolver = new FuncFieldResolver <object>(c =>
{
if (((ContentFieldData)c.Source).TryGetValue(key, out var value))
{
return(valueResolver(value, c));
}
else
{
return(null);
}
});
fieldGraphType.AddField(new FieldType
{
Name = key.EscapePartition(),
Resolver = partitionResolver,
ResolvedType = resolvedType,
Description = field.RawProperties.Hints
});
}
fieldGraphType.Description = $"The structure of the {fieldName} field of the {schemaName} content type.";
var fieldResolver = new FuncFieldResolver <NamedContentData, IReadOnlyDictionary <string, IJsonValue> >(c =>
{
return(c.Source.GetOrDefault(field.Name));
});
AddField(new FieldType
{
Name = field.Name.ToCamelCase(),
Resolver = fieldResolver,
ResolvedType = fieldGraphType,
Description = $"The {fieldName} field."
});
}
}
Description = $"The structure of the {schemaName} content type.";
}
public DynamicMutationType(IGraphQlTypePool graphTypePool, IEnumerable <Type> types)
{
Name = "Mutations";
Description = "Contains the mutation of the graphql api";
foreach (var type in types)
{
if (!type.IsClass || type.IsInterface)
{
throw new ArgumentException("Invalid subscription type");
}
// work with the methods
var methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly)
.Where(x => x.GetAttribute <IgnoreAttribute>() == null);
foreach (var method in methods)
{
if (method.Name == nameof(GraphNodeType <object> .OnCreateAsync) ||
method.IsSpecialName)
{
continue;
}
var descriptionAttr = method.GetAttribute <DescriptionAttribute>();
var fieldNameAttr = method.GetAttribute <NameAttribute>();
IGraphType graphType;
IFieldResolver resolver;
if (method.ReturnType.IsGenericType && method.ReturnType.GetGenericTypeDefinition() == typeof(Task <>))
{
var awaitableReturnType = method.ReturnType.GetGenericArguments()[0];
graphType = graphTypePool.GetGraphType(awaitableReturnType);
resolver = new AsyncFieldResolver <object>(async c =>
{
var task = GraphQlHelpers.ExecuteResolverFunction(method, c, type, true);
await((Task)task);
var resultProp = task.GetType().GetProperty(nameof(Task <object> .Result));
var result = resultProp.GetValue(task);
return(result);
});
}
else
{
graphType = graphTypePool.GetGraphType(method.ReturnType);
resolver = new FuncFieldResolver <object>(c => GraphQlHelpers.ExecuteResolverFunction(method, c, type, true));
}
var isNonNull = method.GetAttribute <NonNullAttribute>() != null;
// create field
var field = new FieldType()
{
Arguments = GraphQlHelpers.GetArguments(graphTypePool, method),
Name = fieldNameAttr == null ? method.Name : fieldNameAttr.Name,
Description = descriptionAttr?.Description ?? DocXmlHelper.DocReader.GetMemberComments(method).Summary,
ResolvedType = isNonNull ? new NonNullGraphType(graphType) : graphType,
Resolver = resolver
};
// add the .net type of this field in the metadata
field.Metadata["type"] = method;
var metadatas = Attribute.GetCustomAttributes(type, typeof(MetadataAttribute));
foreach (MetadataAttribute metadata in metadatas)
{
Metadata[metadata.Key] = metadata.Value;
}
AddField(field);
}
}
}
public DynamicGraphType(IGraphQlTypePool graphTypePool, Type type, bool isRoot = false)
{
if (!type.IsClass || type.IsInterface)
{
throw new ArgumentException("Invalid object type");
}
// get the name
var nameAttr = type.GetAttribute <NameAttribute>();
var descAttr = type.GetAttribute <DescriptionAttribute>();
// set type name and description
Name = nameAttr?.Name ?? type.Name;
Description = descAttr?.Description ?? DocXmlHelper.DocReader.GetTypeComments(type).Summary;
// set the type metadata
Metadata["type"] = type;
{
// sets the custom metadatas
var metadatas = Attribute.GetCustomAttributes(type, typeof(MetadataAttribute));
foreach (MetadataAttribute metadata in metadatas)
{
Metadata[metadata.Key] = metadata.Value;
}
}
// Check for interfaces
var interfaces = type.GetNotDerivedInterfaces();
// Add all the interface that this implement
foreach (var intrfce in interfaces)
{
AddResolvedInterface(graphTypePool.GetGraphType(intrfce) as IInterfaceGraphType);
}
// Implementing isTypeOf in the case this type implement an interface
IsTypeOf = obj => obj.GetType() == type;
// Generate fields -----------------------------------------------
// start with the properties
var properties = type
// Get all properties with getters
.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty | BindingFlags.GetProperty)
// ignore the ones that have the ignore attribute
.Where(x => x.GetAttribute <IgnoreAttribute>() == null);
foreach (var property in properties)
{
var graphType = graphTypePool.GetGraphType(property.PropertyType);
var descriptionAttr = property.GetAttribute <DescriptionAttribute>();
var fieldNameAttr = property.GetAttribute <NameAttribute>();
var isNonNull = property.GetAttribute <NonNullAttribute>() != null;
// create field
var field = new FieldType()
{
Name = fieldNameAttr == null ? property.Name : fieldNameAttr.Name,
Description = descriptionAttr?.Description ?? DocXmlHelper.DocReader.GetMemberComments(property).Summary,
ResolvedType = isNonNull ? new NonNullGraphType(graphType) : graphType,
Resolver = new FuncFieldResolver <object>(c => GraphQlHelpers.GetFinalValue(property.GetValue(GraphQlHelpers.GetSourceInstance(c, type, isRoot)))),
};
// add the .net type of this field in the metadata
field.Metadata["type"] = property;
var metadatas = Attribute.GetCustomAttributes(type, typeof(MetadataAttribute));
foreach (MetadataAttribute metadata in metadatas)
{
Metadata[metadata.Key] = metadata.Value;
}
AddField(field);
}
// work with the methods
var methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly)
.Where(x => x.GetAttribute <IgnoreAttribute>() == null);
// for each method public
foreach (var method in methods)
{
if (method.Name == nameof(GraphNodeType <object> .OnCreateAsync) ||
method.IsSpecialName)
{
continue;
}
var descriptionAttr = method.GetAttribute <DescriptionAttribute>();
var fieldNameAttr = method.GetAttribute <NameAttribute>();
IGraphType graphType;
IFieldResolver resolver;
if (method.ReturnType.IsGenericType && method.ReturnType.GetGenericTypeDefinition() == typeof(Task <>))
{
var awaitableReturnType = method.ReturnType.GetGenericArguments()[0];
graphType = graphTypePool.GetGraphType(awaitableReturnType);
resolver = new AsyncFieldResolver <object>(async c =>
{
var task = GraphQlHelpers.ExecuteResolverFunction(method, c, type, isRoot);
await((Task)task);
var resultProp = task.GetType().GetProperty(nameof(Task <object> .Result));
var result = resultProp.GetValue(task);
return(result);
});
}
else
{
graphType = graphTypePool.GetGraphType(method.ReturnType);
resolver = new FuncFieldResolver <object>(c => GraphQlHelpers.ExecuteResolverFunction(method, c, type, isRoot));
}
var isNonNull = method.GetAttribute <NonNullAttribute>() != null;
// create field
var field = new FieldType()
{
Arguments = GraphQlHelpers.GetArguments(graphTypePool, method),
Name = fieldNameAttr == null ? method.Name : fieldNameAttr.Name,
Description = descriptionAttr?.Description ?? DocXmlHelper.DocReader.GetMemberComments(method).Summary,
ResolvedType = isNonNull ? new NonNullGraphType(graphType) : graphType,
Resolver = resolver
};
// add the .net type of this field in the metadata
field.Metadata["type"] = method;
var metadatas = Attribute.GetCustomAttributes(type, typeof(MetadataAttribute));
foreach (MetadataAttribute metadata in metadatas)
{
Metadata[metadata.Key] = metadata.Value;
}
AddField(field);
}
}
public DynamicGraphType(IGraphQlTypePool graphTypePool, Type type)
{
//if (!typeof(GraphNodeType<>).IsAssignableFrom(type))
//{
// throw new ArgumentException("The type is not of type GraphNodeType<>");
//}
// get the name
var nameArgument = type.GetAttribute <TypeNameAttribute>();
var name = nameArgument == null ? type.Name : nameArgument.Name;
// set type name
Name = name;
// Generate fields -----------------------------------------------
// start with the properties
var properties = type
// Get all properties with getters
.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty | BindingFlags.GetProperty)
// ignore the ones that have the ignore attribute
.Where(x => x.GetAttribute <IgnoreFieldAttribute>() == null);
foreach (var property in properties)
{
var graphType = graphTypePool.GetGraphType(property.PropertyType);
var descriptionAttr = property.GetAttribute <FieldDescriptionAttribute>();
var fieldNameAttr = property.GetAttribute <FieldNameAttribute>();
var isNonNull = property.GetAttribute <NonNullFieldAttribute>() != null;
// create field
var field = new FieldType()
{
Name = fieldNameAttr == null ? property.Name : fieldNameAttr.Name,
Description = descriptionAttr?.Description,
ResolvedType = isNonNull ? new NonNullGraphType(graphType) : graphType,
Resolver = new FuncFieldResolver <object>(c => property.GetValue(c.Source))
};
AddField(field);
}
// work with the methods
var methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly)
.Where(x => x.GetAttribute <IgnoreFieldAttribute>() == null);
foreach (var method in methods)
{
if (method.Name == nameof(GraphNodeType <object> .OnCreateAsync) ||
method.IsSpecialName)
{
continue;
}
var descriptionAttr = method.GetAttribute <FieldDescriptionAttribute>();
var fieldNameAttr = method.GetAttribute <FieldNameAttribute>();
IGraphType graphType;
IFieldResolver resolver;
if (method.IsGenericMethod && method.ReturnType.GetGenericTypeDefinition() == typeof(Task <>))
{
var awaitableReturnType = method.ReturnType.GetGenericArguments()[0];
graphType = graphTypePool.GetGraphType(awaitableReturnType);
resolver = new AsyncFieldResolver <object>(c =>
{
var task = ExecuteResolverFunction(method, c);
return(task as Task <object>);
});
}
else
{
graphType = graphTypePool.GetGraphType(method.ReturnType);
resolver = new FuncFieldResolver <object>(c => ExecuteResolverFunction(method, c));
}
var isNonNull = method.GetAttribute <NonNullFieldAttribute>() != null;
// create field
var field = new FieldType()
{
Arguments = GetArguments(graphTypePool, method),
Name = fieldNameAttr == null ? method.Name : fieldNameAttr.Name,
Description = descriptionAttr?.Description,
ResolvedType = isNonNull ? new NonNullGraphType(graphType) : graphType,
Resolver = resolver
};
}
}
