private static Func <object, ObjectGraphType> CreateResolveType(Type type)
{
var expressions = new List <Expression>();
var knownTypes = TypeHelper.GetGraphKnownTypes(type);
var instanceParam = Expression.Parameter(typeof(object), "instance");
var returnLabel = Expression.Label(typeof(ObjectGraphType));
foreach (var knownType in knownTypes)
{
var graphType = GraphTypeConverter.ConvertTypeToGraphType(knownType.SchemaType);
var lookup = Expression.IfThen(
Expression.TypeIs(instanceParam, knownType.DomainType),
Expression.Return(returnLabel, Expression.Convert(Expression.New(graphType), typeof(ObjectGraphType)))
);
expressions.Add(lookup);
}
var result = Expression.Convert(Expression.Constant(null), typeof(ObjectGraphType));
expressions.Add(Expression.Label(returnLabel, result));
var body = Expression.Block(expressions);
return(Expression.Lambda <Func <object, ObjectGraphType> >(
body,
instanceParam).Compile());
}
private static void ProcessProperties(GraphType graphType, IEnumerable <PropertyInfo> properties, bool isInputType = false)
{
foreach (var property in properties.OrderBy(p => p.Name))
{
bool isNotNull = TypeHelper.IsNotNull(property);
var propertyGraphType = TypeHelper.GetGraphType(property);
if (propertyGraphType != null)
{
propertyGraphType = GraphTypeConverter.ConvertTypeToGraphType(propertyGraphType, isNotNull, isInputType);
propertyGraphType = EnsureList(property.PropertyType, propertyGraphType);
}
else
{
propertyGraphType = GraphTypeConverter.ConvertTypeToGraphType(property.PropertyType, isNotNull, isInputType);
}
var name = StringHelper.GraphName(property.Name);
var field = graphType.Field(
propertyGraphType,
name,
TypeHelper.GetDescription(property));
field.DefaultValue = TypeHelper.GetDefaultValue(property);
field.DeprecationReason = TypeHelper.GetDeprecationReason(property);
}
}
private static Type GetRequestArgumentType(Type parameterType)
{
var requestType = GraphTypeConverter.ConvertTypeToGraphType(parameterType, false, true);
var requestArgumentType = typeof(QueryArgument <>).MakeGenericType(requestType);
return(requestArgumentType);
}
private static void ProcessFields(IComplexGraphType graphType, IEnumerable <FieldInfo> fields, bool isInputType = false)
{
foreach (var field in fields.OrderBy(f => f.Name))
{
bool isNotNull = TypeHelper.IsNotNull(field);
var fieldGraphType = TypeHelper.GetGraphType(field);
if (fieldGraphType != null)
{
fieldGraphType = GraphTypeConverter.ConvertTypeToGraphType(fieldGraphType, isNotNull, isInputType);
fieldGraphType = EnsureList(field.FieldType, fieldGraphType);
}
else
{
fieldGraphType = GraphTypeConverter.ConvertTypeToGraphType(field.FieldType, isNotNull, isInputType);
}
var addedField = graphType.AddField(new FieldType {
Type = fieldGraphType,
Name = StringHelper.GraphName(field.Name)
});
addedField.DeprecationReason = TypeHelper.GetDeprecationReason(field);
}
}
/// <summary>
/// Resolve a type into a graph type.
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public GraphType ResolveType(Type type)
{
if (type.IsInterface || type.IsAbstract)
{
return(null);
}
if (type.IsGenericType)
{
if (type.GetGenericTypeDefinition() == typeof(InterfaceGraphTypeWrapper <>))
{
return(Activator.CreateInstance(type) as GraphType);
}
if (type.GetGenericTypeDefinition() == typeof(InputObjectGraphTypeWrapper <>))
{
return(Activator.CreateInstance(type) as GraphType);
}
if (type.GetGenericTypeDefinition() == typeof(KeyValuePairGraphType <,>))
{
return(Activator.CreateInstance(type) as GraphType);
}
if (type.GetGenericTypeDefinition() == typeof(EnumerationGraphTypeWrapper <>))
{
return(Activator.CreateInstance(type) as GraphType);
}
if (type.GetGenericTypeDefinition() == typeof(ObjectGraphTypeWrapper <>))
{
return(Activator.CreateInstance(type) as GraphType);
}
}
if (type.IsAssignableFrom(typeof(GraphType)) || type.IsSubclassOf(typeof(GraphType)))
{
return(Activator.CreateInstance(type) as GraphType);
}
var graphType = GraphTypeConverter.ConvertTypeToGraphType(type);
if (graphType == null)
{
return(null);
}
var generic = typeof(ObjectGraphTypeWrapper <>).MakeGenericType(graphType);
return(Activator.CreateInstance(generic) as GraphType);
}
private static void ProcessObjectType(ObjectGraphType objectGraphType, Type type)
{
var interfaces = new List <Type>();
foreach (var @interface in type.GetInterfaces())
{
if (!IsGraphType(@interface))
{
continue;
}
interfaces.Add(GraphTypeConverter.ConvertTypeToGraphType(type));
}
objectGraphType.Interfaces = interfaces;
}
private static void ProcessMethods(IComplexGraphType graphType, Type type, IEnumerable <MethodInfo> methods)
{
if (!typeof(GraphType).IsAssignableFrom(type) &&
!type.IsDefined(typeof(GraphTypeAttribute)))
{
return;
}
foreach (var method in methods.OrderBy(m => m.Name))
{
if (IsSpecialMethod(method))
{
continue;
}
bool isNotNull = TypeHelper.IsNotNull(method);
var returnGraphType = TypeHelper.GetGraphType(method);
var methodGraphType = returnGraphType;
if (methodGraphType != null)
{
methodGraphType = GraphTypeConverter.ConvertTypeToGraphType(methodGraphType, isNotNull);
methodGraphType = EnsureList(method.ReturnType, methodGraphType);
}
else
{
methodGraphType = GraphTypeConverter.ConvertTypeToGraphType(method.ReturnType, isNotNull);
}
var arguments =
new QueryArguments(
method.GetParameters()
.Where(p => p.ParameterType != typeof(ResolveFieldContext))
.Select(CreateArgument));
// todo: need to fix method execution - not called currently so lower priority
graphType.AddField(new FieldType {
Type = methodGraphType,
Name = StringHelper.GraphName(method.Name),
Arguments = arguments,
DeprecationReason = TypeHelper.GetDeprecationReason(method),
//Resolver = new AsyncFuncFieldResolver(()=>ResolveField(context, field))
});
}
}
/// <summary>
/// Ensure graph type. Can return null if the type can't be used.
/// </summary>
/// <param name="parameterType"></param>
/// <returns></returns>
public static Type EnsureGraphType(Type parameterType)
{
if (parameterType == null || parameterType == typeof(void))
{
return(typeof(StringGraphType));
}
if (typeof(GraphType).IsAssignableFrom(parameterType))
{
return(parameterType);
}
var type = GraphTypeConverter.ConvertTypeToGraphType(parameterType);
if (type == null)
{
type = typeof(ScalarGraphType);
}
return(type);
}
private static QueryArgument CreateArgument(ParameterInfo parameter)
{
var isNotNull = TypeHelper.IsNotNull(parameter);
var parameterGraphType = TypeHelper.GetGraphType(parameter);
if (parameterGraphType != null)
{
parameterGraphType = GraphTypeConverter.ConvertTypeToGraphType(parameterGraphType, isNotNull);
parameterGraphType = EnsureList(parameter.ParameterType, parameterGraphType);
}
else
{
parameterGraphType = GraphTypeConverter.ConvertTypeToGraphType(parameter.ParameterType, isNotNull);
}
return(new QueryArgument(parameterGraphType)
{
Name = parameter.Name,
DefaultValue = TypeHelper.GetDefaultValue(parameter),
Description = TypeHelper.GetDescription(parameter),
});
}
private static void ProcessFields(GraphType graphType, IEnumerable <FieldInfo> fields)
{
foreach (var field in fields.OrderBy(f => f.Name))
{
bool isNotNull = TypeHelper.IsNotNull(field);
var fieldGraphType = TypeHelper.GetGraphType(field);
if (fieldGraphType != null)
{
fieldGraphType = GraphTypeConverter.ConvertTypeToGraphType(fieldGraphType, isNotNull);
fieldGraphType = EnsureList(field.FieldType, fieldGraphType);
}
else
{
fieldGraphType = GraphTypeConverter.ConvertTypeToGraphType(field.FieldType, isNotNull);
}
graphType.Field(
fieldGraphType,
StringHelper.GraphName(field.Name));
}
}
private static void ProcessMethods(GraphType graphType, Type type, IEnumerable <MethodInfo> methods)
{
if (!typeof(GraphType).IsAssignableFrom(type) &&
!type.IsDefined(typeof(GraphTypeAttribute)))
{
return;
}
foreach (var method in methods.OrderBy(m => m.Name))
{
if (IsSpecialMethod(method))
{
continue;
}
bool isNotNull = TypeHelper.IsNotNull(method);
var returnGraphType = TypeHelper.GetGraphType(method);
var methodGraphType = returnGraphType;
if (methodGraphType != null)
{
methodGraphType = GraphTypeConverter.ConvertTypeToGraphType(methodGraphType, isNotNull);
methodGraphType = EnsureList(method.ReturnType, methodGraphType);
}
else
{
methodGraphType = GraphTypeConverter.ConvertTypeToGraphType(method.ReturnType, isNotNull);
}
graphType.Field(
methodGraphType,
StringHelper.GraphName(method.Name),
null,
new QueryArguments(method.GetParameters().Where(p => p.ParameterType != typeof(ResolveFieldContext)).Select(p => CreateArgument(p))),
// todo: need to fix method execution - not called currently so lower priority
c => method.Invoke(Activator.CreateInstance(type), GetArguments(method, c))
);
}
}
