Automatically generate enums for GraphType members based on the AST or Reflection

src/AspNetCore/AspNetCore.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27130.2036
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.29613.14
 MinimumVisualStudioVersion = 15.0.26124.0
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StarWars", "..\StarWars\StarWars.csproj", "{E579287D-EFD6-4803-9B52-23BE9854A9AE}"
 EndProject
@@ -14,6 +14,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		run.sh = run.sh
 	EndProjectSection
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Graphql.Extensions.FieldEnums", "..\Graphql.Extensions.FieldEnums\Graphql.Extensions.FieldEnums.csproj", "{25647A77-01C4-47C4-8409-4BD2616563D7}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -48,6 +50,18 @@ Global
 		{46C914F6-4432-4D1F-8B47-18F0C9AA65DD}.Release|x64.Build.0 = Release|Any CPU
 		{46C914F6-4432-4D1F-8B47-18F0C9AA65DD}.Release|x86.ActiveCfg = Release|Any CPU
 		{46C914F6-4432-4D1F-8B47-18F0C9AA65DD}.Release|x86.Build.0 = Release|Any CPU
+		{25647A77-01C4-47C4-8409-4BD2616563D7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{25647A77-01C4-47C4-8409-4BD2616563D7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{25647A77-01C4-47C4-8409-4BD2616563D7}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{25647A77-01C4-47C4-8409-4BD2616563D7}.Debug|x64.Build.0 = Debug|Any CPU
+		{25647A77-01C4-47C4-8409-4BD2616563D7}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{25647A77-01C4-47C4-8409-4BD2616563D7}.Debug|x86.Build.0 = Debug|Any CPU
+		{25647A77-01C4-47C4-8409-4BD2616563D7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{25647A77-01C4-47C4-8409-4BD2616563D7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{25647A77-01C4-47C4-8409-4BD2616563D7}.Release|x64.ActiveCfg = Release|Any CPU
+		{25647A77-01C4-47C4-8409-4BD2616563D7}.Release|x64.Build.0 = Release|Any CPU
+		{25647A77-01C4-47C4-8409-4BD2616563D7}.Release|x86.ActiveCfg = Release|Any CPU
+		{25647A77-01C4-47C4-8409-4BD2616563D7}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

src/AspNetCore/Example/Startup.cs

@@ -1,3 +1,4 @@
+using Graphql.Extensions.FieldEnums.Types;
 using GraphQL.Server;
 using GraphQL.Types;
 using Microsoft.AspNetCore.Builder;
@@ -23,6 +24,8 @@ public void ConfigureServices(IServiceCollection services)
             services.AddSingleton<EpisodeEnum>();
             services.AddSingleton<ISchema, StarWarsSchema>();
 
+            services.AddSingleton(typeof(TypeFieldEnumerationWithoutLists<>), typeof(TypeFieldEnumerationWithoutLists<>));
+
             services.AddLogging(builder => builder.AddConsole());
             services.AddHttpContextAccessor();
 

src/Graphql.Extensions.FieldEnums/Exceptions/AmbiguousFilterException.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace Graphql.Extensions.FieldEnums.Exceptions
+{
+    [Serializable]
+    public class AmbiguousFilterException : Exception
+    {
+        public AmbiguousFilterException(string message) : base(message)
+        {
+
+        }
+    }
+}

src/Graphql.Extensions.FieldEnums/Extensions/MetaDataExtensions.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using GraphQL.Builders;
+using GraphQL.Types;
+
+namespace Graphql.Extensions.FieldEnums.Types.Extensions
+{
+    public static class MetaDataExtensions
+    {
+        public static FieldBuilder<TSourceType, TProperty> WithOriginalName<TSourceType, TProperty>
+        (
+            this FieldBuilder<TSourceType, TProperty> fieldBuilder,
+            string originalName
+        )
+        {
+            fieldBuilder.FieldType.Metadata[SharedConstants.OriginalPropertyName] = originalName;
+            return fieldBuilder;
+        }
+
+        public static string GetOriginalName(this FieldType field)
+        {
+            if (field.Metadata.TryGetValue(SharedConstants.OriginalPropertyName, out var originalName))
+            {
+                return originalName.ToString();
+            }
+
+            return field.Name;
+        }
+
+
+        public static FieldBuilder<TSourceType, TProperty> WithSourceType<TSourceType, TProperty>
+        (
+            this FieldBuilder<TSourceType, TProperty> fieldBuilder,
+            Type type = null
+        )
+        {
+            fieldBuilder.FieldType.Metadata[SharedConstants.SourceType] = type ?? typeof(TSourceType);
+            return fieldBuilder;
+        }
+
+        public static Type GetSourceType(this FieldType field)
+        {
+            if (field.Metadata.TryGetValue(SharedConstants.SourceType, out var sourceTypeRaw) && sourceTypeRaw is Type sourceType)
+            {
+                return sourceType;
+            }
+
+            return null;
+        }
+    }
+
+    public static class GraphQLExtensions
+    {
+
+        /// <summary>
+        /// Guesses the first type which is not a graphql lib type.
+        /// WARNING! THIS METHOD IS NOT SAFE
+        /// Its just for the lazy boyz
+        /// </summary>
+        /// <param name="type"></param>
+        /// <returns></returns>
+        public static Type EnsureNoGraphQlCoreType(this Type type)
+        {
+            var assembly = typeof(ListGraphType).Assembly;
+            if (type.Assembly == assembly)
+            {
+                return EnsureNoListGraphType(type.GetGenericArguments().First());
+            }
+
+            return type;
+        }
+
+        public static Type EnsureNoListGraphType(this Type type)
+        {
+            if (type.BaseType == typeof(ListGraphType))
+            {
+                return EnsureNoListGraphType(type.GetGenericArguments().First());
+            }
+
+            return type;
+        }
+
+        public static QueryArguments AddRange(this QueryArguments queryArguments, IEnumerable<QueryArgument> arguments)
+        {
+            foreach (var queryArgument in arguments)
+            {
+                queryArguments.Add(queryArgument);
+            }
+
+            return queryArguments;
+        }
+
+        public static FieldBuilder<TSourceType, TReturnType> SkipTakeOrderByArguments<TSourceType, TReturnType>
+        (
+            this FieldBuilder<TSourceType, TReturnType> source
+        )
+        {
+            var guessedGraphType = source.FieldType.Type.EnsureNoGraphQlCoreType();
+            var typedArg = typeof(TypeFieldEnumerationWithoutLists<>).MakeGenericType(guessedGraphType);
+
+            source.FieldType.Arguments.AddRange(new[] {
+                DefaultQueryArguments.Skip,
+                DefaultQueryArguments.Take,
+                DefaultQueryArguments.GetOrderBy(typedArg),
+                DefaultQueryArguments.GetOrderByDesc(typedArg),
+            });
+
+            return source;
+        }
+    }
+}

src/Graphql.Extensions.FieldEnums/Extensions/PropertyInfoExtensions.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Linq;
+using System.Reflection;
+
+namespace Graphql.Extensions.FieldEnums.Types.Extensions
+{
+    public static class PropertyInfoExtensions
+    {
+        private const BindingFlags DefaultLookup = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public;
+
+        public static PropertyInfo GetProperty
+        (
+            this Type type,
+            string name,
+            BindingFlags bindingAttr = DefaultLookup,
+            StringComparison comparisonType = StringComparison.Ordinal
+        )
+        {
+            return type.GetProperties(bindingAttr).SingleOrDefault(x => string.Equals(name, x.Name, comparisonType));
+        }
+
+        public static PropertyInfo EnsureDeclaringPropertyInfo(this PropertyInfo propertyInfo)
+        {
+            if (propertyInfo.DeclaringType == null || propertyInfo.ReflectedType == propertyInfo.DeclaringType)
+            {
+                return propertyInfo;
+            }
+
+            return propertyInfo.DeclaringType.GetProperty(propertyInfo.Name, DefaultLookup);
+        }
+    }
+}

src/Graphql.Extensions.FieldEnums/Extensions/SharedConstants.cs

@@ -0,0 +1,9 @@
+namespace Graphql.Extensions.FieldEnums.Types.Extensions
+{
+    public static class SharedConstants
+    {
+        public const string OriginalPropertyName = "SW_OriginalPropertyName";
+        public const string SourceType = "SW_SourceType";
+        public const string FieldDataRequired = "SW_FieldDataRequired";
+    }
+}

src/Graphql.Extensions.FieldEnums/Extensions/TypeExtensions.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace Graphql.Extensions.FieldEnums.Types.Extensions
+{
+    public static class TypeExtensions
+    {
+        public static bool InheritsFromGenericType(this Type type, Type genericTypeDefinition)
+        {
+            return type.BaseType.IsGenericType && type.BaseType.GetGenericTypeDefinition() == genericTypeDefinition;
+        }
+    }
+}

src/Graphql.Extensions.FieldEnums/Graphql.Extensions.FieldEnums.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="GraphQL" Version="3.0.0-preview-1357" />
+  </ItemGroup>
+
+</Project>

src/Graphql.Extensions.FieldEnums/SkipTakeOrderByArgument.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using System.Text;
+using Graphql.Extensions.FieldEnums.Exceptions;
+using GraphQL.Types;
+
+namespace Graphql.Extensions.FieldEnums
+{
+    public class SkipTakeOrderByArgument
+    {
+        public int? Skip { get; set; }
+        public int? Take { get; set; }
+        public string OrderBy { get; set; }
+        public string OrderByDesc { get; set; }
+
+        public SkipTakeOrderByArgument()
+        {
+        }
+
+        public static SkipTakeOrderByArgument Parse<T>(ResolveFieldContext<T> context)
+        {
+            var result = new SkipTakeOrderByArgument
+            {
+                Skip = context.GetArgument<int?>("skip", null),
+                Take = context.GetArgument<int?>("take", null),
+                OrderBy = context.GetArgument<string>("orderBy", null),
+                OrderByDesc = context.GetArgument<string>("orderByDesc", null),
+            };
+
+            var hasOrderBy = !string.IsNullOrEmpty(result.OrderBy);
+            var hasOrderByDesc = !string.IsNullOrEmpty(result.OrderByDesc);
+
+            if (hasOrderBy == true && hasOrderByDesc == true)
+            {
+                throw new AmbiguousFilterException($"Cannot order by {result.OrderBy} and {result.OrderByDesc} at the same time");
+            }
+
+            return result;
+        }
+    }
+}

src/Graphql.Extensions.FieldEnums/Types/DefaultQueryArguments.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using GraphQL.Types;
+
+namespace Graphql.Extensions.FieldEnums.Types
+{
+    public static class DefaultQueryArguments
+    {
+        public static IEnumerable<QueryArgument> SkipTakeOrderByArguments<TTargetType>()
+            => SkipTakeOrderByArguments(typeof(TTargetType));
+
+        public static IEnumerable<QueryArgument> SkipTakeOrderByArguments(Type targetType)
+        {
+            yield return Skip;
+            yield return Take;
+            yield return GetOrderBy(targetType);
+            yield return GetOrderByDesc(targetType);
+        }
+
+        public static QueryArgument Skip => new QueryArgument(typeof(IntGraphType))
+        {
+            Name = "skip",
+            Description = "skip n entries",
+        };
+
+        public static QueryArgument Take => new QueryArgument(typeof(IntGraphType))
+        {
+            Name = "take",
+            Description = "take n entries",
+        };
+
+        public static QueryArgument GetOrderBy(Type type)
+        {
+            var typedArg = type;
+            if (type.IsGenericType == false || type.GetGenericTypeDefinition() != typeof(TypeFieldEnumerationWithoutLists<>))
+            {
+                typedArg = typeof(TypeFieldEnumerationWithoutLists<>).MakeGenericType(type);
+            }
+
+            return new QueryArgument(typedArg)
+            {
+                Name = "orderBy",
+                Description = "order by",
+            };
+        }
+
+        public static QueryArgument GetOrderByDesc(Type type)
+        {
+            var typedArg = type;
+            if (type.IsGenericType == false || type.GetGenericTypeDefinition() != typeof(TypeFieldEnumerationWithoutLists<>))
+            {
+                typedArg = typeof(TypeFieldEnumerationWithoutLists<>).MakeGenericType(type);
+            }
+
+            return new QueryArgument(typedArg)
+            {
+                Name = "orderByDesc",
+                Description = "order by desc",
+            };
+        }
+    }
+}

src/Graphql.Extensions.FieldEnums/Types/FieldAwareEnumValueDefinition.cs

@@ -0,0 +1,9 @@
+using GraphQL.Types;
+
+namespace Graphql.Extensions.FieldEnums.Types
+{
+    public class FieldAwareEnumValueDefinition : EnumValueDefinition
+    {
+        public FieldType FieldType { get; set; }
+    }
+}

src/Graphql.Extensions.FieldEnums/Types/FieldAwareGraphType.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Linq.Expressions;
+using GraphQL;
+using GraphQL.Builders;
+using Graphql.Extensions.FieldEnums.Types.Extensions;
+using GraphQL.Types;
+
+namespace Graphql.Extensions.FieldEnums.Types
+{
+    public class FieldAwareGraphType<TSourceType> : ObjectGraphType<TSourceType>
+    {
+        public override FieldBuilder<TSourceType, TProperty> Field<TProperty>
+        (
+            string name,
+            Expression<Func<TSourceType, TProperty>> expression,
+            bool nullable = false,
+            Type type = null
+        )
+        {
+            var result = base
+                .Field(name, expression, nullable, type)
+                .WithOriginalName(expression.NameOf())
+                .WithSourceType(typeof(TSourceType));
+
+            if (result.FieldType.Name.Contains("ID"))
+            {
+                result.FieldType.Name = result.FieldType.Name.Replace("ID", "Id");
+            }
+
+            return result;
+        }
+    }
+}