public static GraphArgumentInfo ShouldHaveArgumentWithName(this GraphFieldInfo field, string argumentName)
{
var arg = field.Arguments.FirstOrDefault(a => a.Name == argumentName);
Assert.IsNotNull(arg);
return(arg);
}
private GraphFieldInfo DeriveField(MemberInfo memberInfo)
{
var field = new GraphFieldInfo(_typeResolver, memberInfo);
var propertyInfo = memberInfo as PropertyInfo;
if (propertyInfo != null)
{
field.Type = GetType(propertyInfo.PropertyType.GetTypeInfo());
}
var fieldInfo = memberInfo as FieldInfo;
if (fieldInfo != null)
{
field.Type = GetType(fieldInfo.FieldType.GetTypeInfo());
}
var methodInfo = memberInfo as MethodInfo;
if (methodInfo != null)
{
field.Type = GetType(methodInfo.ReturnType.GetTypeInfo());
field.Arguments.AddRange(GetArguments(methodInfo));
}
_metaDataHandler.DeriveMetaData(field, memberInfo);
return(field);
}
private object GetValue(GraphFieldInfo fieldInfo, IResolutionContext context)
{
var source = GetSource(fieldInfo, context);
var propertyInfo = fieldInfo.AttributeProvider as PropertyInfo;
return(propertyInfo?.GetValue(source));
}
private FieldType DeriveField(GraphFieldInfo fieldInfo)
{
if (fieldInfo.Type.IsObservable)
{
var resolver = new Resolvers.EventStreamResolver(fieldInfo);
return(new EventStreamFieldType
{
Name = fieldInfo.Name,
Description = fieldInfo.Description,
DeprecationReason = fieldInfo.DeprecationReason,
DefaultValue = fieldInfo.DefaultValue,
Type = GetType(fieldInfo.Type),
Arguments = new QueryArguments(fieldInfo.Arguments.Where(arg => !arg.IsInjected).Select(DeriveArgument)),
Resolver = resolver,
Subscriber = resolver
});
}
return(new FieldType
{
Name = fieldInfo.Name,
Description = fieldInfo.Description,
DeprecationReason = fieldInfo.DeprecationReason,
DefaultValue = fieldInfo.DefaultValue,
Type = GetType(fieldInfo.Type),
Arguments = new QueryArguments(fieldInfo.Arguments.Where(arg => !arg.IsInjected).Select(DeriveArgument)),
Resolver = FieldResolverFactory(fieldInfo),
});
}
public override void MapField(GraphFieldInfo fieldInfo, MemberInfo memberInfo)
{
if (ChaosAttribute.IsEnabled)
{
fieldInfo.ExecutionFilters.Add(new ChaosAttribute());
}
}
private GraphFieldInfo DeriveField(MemberInfo memberInfo)
{
var field = new GraphFieldInfo(_typeResolver, memberInfo);
_metaDataHandler.DeriveMetaData(field, memberInfo);
if (!field.IsIgnored)
{
if (memberInfo is PropertyInfo propertyInfo)
{
field.Type = GetType(propertyInfo.PropertyType.GetTypeInfo());
}
if (memberInfo is FieldInfo fieldInfo)
{
field.Type = GetType(fieldInfo.FieldType.GetTypeInfo());
}
if (memberInfo is MethodInfo methodInfo)
{
field.Type = GetType(methodInfo.ReturnType.GetTypeInfo());
field.Arguments.AddRange(GetArguments(methodInfo));
}
}
return(field);
}
private object CallMethod(GraphFieldInfo fieldInfo, IResolutionContext context)
{
var source = GetSource(fieldInfo, context);
var methodInfo = fieldInfo.AttributeProvider as MethodInfo;
var arguments = fieldInfo
.Arguments
.Select(arg => context.GetArgument(arg.Name, arg.DefaultValue));
return(methodInfo?.Invoke(source, arguments.ToArray()));
}
private FieldType DeriveField(GraphFieldInfo fieldInfo)
{
return(new FieldType
{
Name = fieldInfo.Name,
Description = fieldInfo.Description,
DeprecationReason = fieldInfo.DeprecationReason,
DefaultValue = fieldInfo.DefaultValue,
Type = GetType(fieldInfo.Type),
Arguments = new QueryArguments(fieldInfo.Arguments.Where(arg => !arg.IsInjected).Select(DeriveArgument)),
Resolver = FieldResolverFactory(fieldInfo),
});
}
private object GetSource(GraphFieldInfo fieldInfo, IResolutionContext context)
{
var source = context.Source;
if (source == null ||
source.GetType() == typeof(ImplementViewerAttribute.QueryViewer) ||
source.GetType() == typeof(ImplementViewerAttribute.MutationViewer) ||
source.GetType() == typeof(ImplementViewerAttribute.SubscriptionViewer))
{
var declaringType = fieldInfo.DeclaringType.TypeRepresentation.AsType();
source = context.DependencyInjector?.Resolve(declaringType.GetTypeInfo()) ?? fieldInfo.SchemaInfo.TypeResolutionDelegate(declaringType);
}
source = Unwrapper.Unwrap(source);
return source;
}
private object CallMethod(GraphFieldInfo fieldInfo, IResolutionContext context)
{
var source = GetSource(fieldInfo, context);
var methodInfo = fieldInfo.AttributeProvider as MethodInfo;
var arguments = fieldInfo
.Arguments
.Select(arg => context.GetArgument(arg));
if (fieldInfo.IsExtensionMethod)
{
arguments = new[] { source }.Concat(arguments);
}
return(methodInfo?.Invoke(source, arguments.ToArray()));
}
private FieldType DeriveField(GraphFieldInfo fieldInfo)
{
if (fieldInfo.Type.TypeRepresentation.IsSubclassOfRawGeneric(typeof(IObservable <>)))
{
var wrappedType = fieldInfo.Type.TypeRepresentation.GenericTypeArguments[0];
var argParam = Expression.Parameter(typeof(ResolveFieldContext), "context");
Expression expression = Expression.Property(argParam, nameof(ResolveFieldContext.Source));
expression = Expression.Convert(expression, wrappedType);
var @delegate = Expression.Lambda(expression, argParam).Compile();
var resolver = typeof(FuncFieldResolver <>).MakeGenericType(wrappedType).GetConstructors().First()
?.Invoke(new object[]
{
@delegate
});
var method = fieldInfo.DeclaringType.TypeRepresentation.DeclaredMethods.First(x =>
x.Name.Equals(fieldInfo.Name, StringComparison.OrdinalIgnoreCase));
if (method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType != typeof(ResolveEventStreamContext))
{
throw new ArgumentException("Subscription must only have one param of type ResolveEventStreamContext");
}
var @delegate1 = method.CreateDelegate(typeof(Func <,>).MakeGenericType(typeof(ResolveEventStreamContext), fieldInfo.Type.TypeRepresentation), null);
var subscriber = typeof(EventStreamResolver <>).MakeGenericType(wrappedType).GetConstructors().First()
.Invoke(new object[] { @delegate1 });
return(new EventStreamFieldType
{
Name = fieldInfo.Name,
Type = this._typeDescriptors.GetEntity(wrappedType).GetType(),
Resolver = resolver as IFieldResolver,
Subscriber = subscriber as IEventStreamResolver
});
}
return(new FieldType
{
Name = fieldInfo.Name,
Description = fieldInfo.Description,
DeprecationReason = fieldInfo.DeprecationReason,
DefaultValue = fieldInfo.DefaultValue,
Type = GetType(fieldInfo.Type),
Arguments = new QueryArguments(fieldInfo.Arguments.Where(arg => !arg.IsInjected).Select(DeriveArgument)),
Resolver = FieldResolverFactory(fieldInfo),
});
}
private object CallMethod(GraphFieldInfo fieldInfo, IResolutionContext context)
{
var source = GetSource(fieldInfo, context);
var methodInfo = fieldInfo.AttributeProvider as MethodInfo;
var arguments = fieldInfo
.Arguments
.Select(arg => context.GetArgument(arg));
if (fieldInfo.Type.IsTask)
{
var argumentTypes = methodInfo.GetParameters().Select(p => p.ParameterType).ToList();
var argumentConstants = arguments.Select((arg, i) => Expression.Constant(arg, argumentTypes[i]));
var methodCall = Expression.Call(Expression.Constant(source), methodInfo, argumentConstants);
var resolutionTask = Expression.Lambda(methodCall).Compile();
return(Task.Run(() => AsyncHelpers.RunTask(resolutionTask, fieldInfo.Type.TypeParameter())));
}
return(methodInfo?.Invoke(source, arguments.ToArray()));
}
public virtual void MapField(GraphFieldInfo fieldInfo, MemberInfo memberInfo)
{
}
public WrappedSyncFieldResolver(GraphFieldInfo fieldInfo)
{
_fieldInfo = fieldInfo;
}
public FieldResolver(GraphFieldInfo fieldInfo)
{
_fieldInfo = fieldInfo;
}
public override void MapField(GraphFieldInfo fieldInfo, MemberInfo memberInfo)
{
fieldInfo.DefaultValue = _defaultValue;
}
public EventStreamResolver(GraphFieldInfo fieldInfo) : base(fieldInfo)
{
}
public void MapField(GraphFieldInfo entity, MemberInfo memberInfo)
{
HasMappedField = true;
}
public void MapEnumMember(GraphFieldInfo entity, FieldInfo fieldInfo)
{
HasMappedEnumMember = true;
}
public virtual void MapEnumMember(GraphFieldInfo entity, FieldInfo fieldInfo)
{
}
public override void MapField(GraphFieldInfo entity, MemberInfo memberInfo)
{
entity.DefaultValue = _defaultValue;
}
public static void ShouldNotHaveArgumentWithName(this GraphFieldInfo field, string argumentName)
{
var arg = field.Arguments.FirstOrDefault(a => a.Name == argumentName);
Assert.IsNull(arg);
}
public override void MapField(GraphFieldInfo fieldInfo, MemberInfo memberInfo)
{
fieldInfo.Name = _nameNormalizer.AsFieldName(memberInfo.Name);
}
public virtual void MapField(GraphFieldInfo entity, MemberInfo memberInfo)
{
}
public ResolutionContext(GraphFieldInfo fieldInfo, ResolveFieldContext <object> fieldContext)
{
FieldContext = fieldContext;
FieldInfo = fieldInfo;
}
public override void MapEnumMember(GraphFieldInfo entity, FieldInfo fieldInfo)
{
entity.Name = _nameNormalizer.AsEnumMemberName(fieldInfo.Name);
}
