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