protected virtual FieldType ToSubscriptionFieldType(string parentTypeName, GraphQLFieldDefinition fieldDef)
{
var typeConfig = Types.For(parentTypeName);
var fieldConfig = typeConfig.SubscriptionFieldFor(fieldDef.Name.Value, ServiceProvider);
var field = new EventStreamFieldType
{
Name = fieldDef.Name.Value,
Description = fieldConfig.Description ?? fieldDef.Comment?.Text,
ResolvedType = ToGraphType(fieldDef.Type),
Resolver = fieldConfig.Resolver,
Subscriber = fieldConfig.Subscriber,
AsyncSubscriber = fieldConfig.AsyncSubscriber,
DeprecationReason = fieldConfig.DeprecationReason
};
CopyMetadata(field, fieldConfig);
field.Arguments = ToQueryArguments(fieldDef.Arguments);
field.SetAstType(fieldDef);
VisitNode(field, v => v.VisitFieldDefinition(field));
return(field);
}
protected virtual FieldType ToSubscriptionFieldType(string parentTypeName, GraphQLFieldDefinition fieldDef)
{
var typeConfig = Types.For(parentTypeName);
AssertKnownType(typeConfig);
var fieldConfig = typeConfig.FieldFor((string)fieldDef.Name.Value);
InitializeSubscriptionField(fieldConfig, typeConfig.Type);
AssertKnownField(fieldConfig, typeConfig);
var field = new EventStreamFieldType
{
Name = fieldConfig.Name,
Description = fieldConfig.Description ?? fieldDef.Description?.Value.ToString() ?? fieldDef.Comment?.Text.ToString(),
ResolvedType = ToGraphType(fieldDef.Type),
Resolver = fieldConfig.Resolver,
Subscriber = fieldConfig.Subscriber,
AsyncSubscriber = fieldConfig.AsyncSubscriber,
};
fieldConfig.CopyMetadataTo(field);
field.Arguments = ToQueryArguments(fieldConfig, fieldDef.Arguments);
field.SetAstType(fieldDef);
OverrideDeprecationReason(field, fieldConfig.DeprecationReason);
return(field);
}
protected virtual FieldType ToSubscriptionFieldType(string parentTypeName, GraphQLFieldDefinition fieldDef)
{
var typeConfig = Types.For(parentTypeName);
var fieldConfig = typeConfig.SubscriptionFieldFor(fieldDef.Name.Value, DependencyResolver);
var field = new EventStreamFieldType();
field.Name = fieldDef.Name.Value;
field.Description = fieldConfig.Description;
field.ResolvedType = ToGraphType(fieldDef.Type);
field.Resolver = fieldConfig.Resolver;
field.Subscriber = fieldConfig.Subscriber;
field.AsyncSubscriber = fieldConfig.AsyncSubscriber;
CopyMetadata(field, fieldConfig);
var args = fieldDef.Arguments.Select(ToArguments);
field.Arguments = new QueryArguments(args);
ApplyDeprecatedDirective(fieldDef.Directives, reason =>
{
field.DeprecationReason = fieldConfig.DeprecationReason ?? reason;
});
return(field);
}
public CatalogDiscountType(IMediator mediator, IDataLoaderContextAccessor dataLoader)
{
var promotion = new EventStreamFieldType
{
Name = "promotion",
Type = GraphTypeExtenstionHelper.GetActualType <PromotionType>(),
Arguments = new QueryArguments(),
Resolver = new FuncFieldResolver <Discount, IDataLoaderResult <Promotion> >(context =>
{
var loader = dataLoader.Context.GetOrAddBatchLoader <string, Promotion>("promotionsLoader", (ids) => LoadPromotionsAsync(mediator, ids));
return(loader.LoadAsync(context.Source.PromotionId));
})
};
AddField(promotion);
}
public DynamicSubscriptionType(IGraphQlTypePool graphTypePool, IEnumerable <Type> types)
{
Name = "Subscriptions";
Description = "Contains the subscriptions of the graphql api";
foreach (var type in types)
{
if (!type.IsClass || type.IsInterface)
{
throw new ArgumentException("Invalid subscription 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 observableType = property.PropertyType.GetInterfacesIncludingType()
.FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition().Equals(typeof(IObservable <>)));
if (observableType == null)
{
throw new InvalidOperationException("Subscription property can only return or have type IObservable<>, derive from it or have the IgnoreAttribute");
}
var graphType = graphTypePool.GetGraphType(observableType.GetGenericArguments()[0]);
var descriptionAttr = property.GetAttribute <DescriptionAttribute>();
var fieldNameAttr = property.GetAttribute <NameAttribute>();
var isNonNull = property.GetAttribute <NonNullAttribute>() != null;
var field = new EventStreamFieldType()
{
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>(ResolveObject),
Subscriber = new EventStreamResolver <object>(c => Subscribe(c, property, type))
};
// 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);
foreach (var method in methods)
{
if (method.IsSpecialName)
{
continue;
}
var descriptionAttr = method.GetAttribute <DescriptionAttribute>();
var fieldNameAttr = method.GetAttribute <NameAttribute>();
IGraphType graphType;
IEventStreamResolver subscriber = null;
IAsyncEventStreamResolver subscriberAsync = null;
if (method.ReturnType.IsGenericType && method.ReturnType.GetGenericTypeDefinition() == typeof(Task <>))
{
var observable = method.ReturnType.GetGenericArguments()[0];
var observableInterface = observable.GetInterfacesIncludingType()
.FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition().Equals(typeof(IObservable <>)));
if (observableInterface == null)
{
throw new InvalidOperationException("Subscription property can only return or have type IObservable<>, derive from it or have the IgnoreAttribute");
}
var observableType = observableInterface.GetGenericArguments()[0];
graphType = graphTypePool.GetGraphType(observableType);
subscriberAsync = new AsyncEventStreamResolver <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 as IObservable <object>);
});
}
else
{
var observable = method.ReturnType;
var observableInterface = observable.GetInterfacesIncludingType()
.FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition().Equals(typeof(IObservable <>)));
var observableType = observableInterface.GetGenericArguments()[0];
graphType = graphTypePool.GetGraphType(observableType);
subscriber = new EventStreamResolver <object>(c => GraphQlHelpers.ExecuteResolverFunction(method, c, type, true) as IObservable <object>);
}
var isNonNull = method.GetAttribute <NonNullAttribute>() != null;
// create field
var field = new EventStreamFieldType()
{
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 = new FuncFieldResolver <object>(ResolveObject),
Subscriber = subscriber,
AsyncSubscriber = subscriberAsync
};
// 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 GraphFieldBuilder()
{
_instance = new EventStreamFieldType();
}
