Fixed issue with enumerations not being stored as singletons

GraphQL-Core.Tests/TestExtensions.cs

@@ -0,0 +1,32 @@
+using GraphQL_Core.Tests.Models.Enum;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace GraphQL_Core.Tests
+{
+    public static class TestExtensions
+    {
+        public static dynamic DefaultUnknownProperty(this Type t)
+        {
+            dynamic defaultValue = null;
+
+            switch (t)
+            {
+                case Type u when t == typeof(string):
+                    defaultValue = "";
+                    break;
+                case Type u when t.IsEnum:
+                    defaultValue = 11;
+                    break;
+                case Type u when t.IsInterface:
+                    break;
+                default:
+                    defaultValue = Activator.CreateInstance(t);
+                    break;
+            }
+
+            return defaultValue;
+        }
+    }
+}

GraphQL-Core.Tests/TypeTests.cs

@@ -5,6 +5,8 @@
 using System;
 using GraphQLCore.Resolvers;
 using GraphQLCore.GraphQL;
+using GraphQL_Core.Tests.Models.Enum;
+using GraphQL.Types;
 
 namespace GraphQL_Core.Tests
 {
@@ -200,14 +202,16 @@ public void Generic_Test_AddType_IsQueryable<T>()
         {
             initializer.Init();
             var builder = initializer.services.AddGraphQL()
+                .Type<EnumerationGraphType<BookType>>()
                 .Type<T>();
 
             foreach (var field in typeof(T).GetProperties())
             {
                 GraphQLQuery defaultQuery = 
                     () => new Query() {
                         Expression = $"get_{field.Name}",
-                        Resolver = (context) => Activator.CreateInstance(field.PropertyType)
+                        Resolver = (context) => 
+                            field.PropertyType.DefaultUnknownProperty()
                     };
 
                 var methodInfo = builder
@@ -234,6 +238,7 @@ public void Generic_Test_AddType_IsQueryable<T>()
             {
                 Assert.IsTrue(userModelInstance.HasField(field.Name));
 
+                //add sub-selection is field is class, use all props
                 (var hasError, var result) = initializer.Ask($@"
                     {{
                         get_{field.Name}

GraphQL-Core/Extensions/GraphQLExtensions.cs

@@ -19,7 +19,10 @@ public static (Type, bool) GetConvertibleBaseCSharpType(this Type cSharpType)
 
 
             if (cSharpType.IsEnum)
+            {
                 returnType = typeof(EnumerationGraphType<>).MakeGenericType(cSharpType);
+                nullable = true;
+            } 
 
             else if (false
                 || cSharpType.IsValueType

GraphQL-Core/GraphQLBuilder.cs

@@ -163,16 +163,30 @@ public GraphQLBuilder(IServiceCollection services)
 
         IGraphQLBuilder IGraphQLBuilder.Type<T>()
         {
-            var userType = GraphQLCoreTypeWrapperGenerator.CreateGraphQLTypeWrapper<T>();
+            if(typeof(T).IsGenericType && typeof(T).GenericTypeArguments[0].IsEnum)
+            {
+                var enumType = typeof(T).GenericTypeArguments[0];
 
-            if (((IGraphQLBuilder)this).GraphQLTypes.ContainsKey(userType))
-                return this;
+                if (((IGraphQLBuilder)this).GraphQLTypes.ContainsKey(typeof(T)))
+                    return this;
 
-            var graphQlTypeInstance = new GenericType<T>(this)
+                var graphQlTypeInstance = Activator.CreateInstance<T>();
+                ((IGraphQLBuilder)this).GraphQLTypes.Add(typeof(T), graphQlTypeInstance);
+            }
+            else
             {
-                Name = typeof(T).Name
-            };
-            ((IGraphQLBuilder)this).GraphQLTypes.Add(userType, graphQlTypeInstance);
+                var userType = GraphQLCoreTypeWrapperGenerator.CreateGraphQLTypeWrapper<T>();
+
+                if (((IGraphQLBuilder)this).GraphQLTypes.ContainsKey(userType))
+                    return this;
+
+                var graphQlTypeInstance = new GenericType<T>(this)
+                {
+                    Name = typeof(T).Name
+                };
+                ((IGraphQLBuilder)this).GraphQLTypes.Add(userType, graphQlTypeInstance);
+            }
+
             return this;
         }
 

GraphQL-Core/Types/Types.cs

@@ -19,6 +19,12 @@ public class GenericType<T> : ObjectGraphType<T>, IGraphQLGenericType
         /// <summary>
         /// Initializes the GraphQL Type, using the provided user-defined model
         /// </summary>
+
+        public GenericType()
+            : this(null)
+        {
+        }
+
         public GenericType(IGraphQLBuilder builder = null)
         {
             var typedClass = typeof(T);
@@ -29,7 +35,7 @@ public GenericType(IGraphQLBuilder builder = null)
 
                 propGraphQLType = prop.PropertyType.TryConvertToGraphQLType();
 
-                if(propGraphQLType is null)
+                if(propGraphQLType is null || propGraphQLType.IsEnum)
                 {
                     builder
                         .GetType()