Add the ability to return a GraphQLTypeReference from ResolveType (graphql-dotnet#775)

Author: joemcbride

src/GraphQL.Tests/Execution/AbstractTypeTests.cs

@@ -12,7 +12,7 @@ public void throws_when_unable_to_determine_object_type()
         {
             var result = AssertQueryWithErrors("{ pets { name } }", "{ 'pets': null }", expectedErrorCount: 1);
             var error = result.Errors.First();
-            error.Message.ShouldBe("Abstract type Pet must resolve to an Object type at runtime for field Query.pets with value { name = Eli }, received 'null'.");
+            error.Message.ShouldBe("Abstract type Pet must resolve to an Object type at runtime for field Query.pets with value '{ name = Eli }', received 'null'.");
         }
     }
 

src/GraphQL.Tests/Utilities/CustomGraphQLAttributeTests.cs

@@ -85,7 +85,7 @@ type Query
                 }
             ";
 
-            Builder.Types.Include<ABlog>();
+            Builder.Types.Include<ABlog, ABlog>();
 
             var schema = Builder.Build(defs);
             schema.Initialize();

src/GraphQL.Tests/Utilities/SchemaBuilderNestedTypesTests.cs

@@ -1,5 +1,6 @@
 using System;
 using GraphQL;
+using GraphQL.Types;
 using Xunit;
 
 namespace GraphQL.Tests.Utilities
@@ -26,7 +27,40 @@ type Query {
             ";
 
             Builder.Types.Include<DroidType>();
-            Builder.Types.For("Droid").IsTypeOf<Droid>();
+            Builder.Types.Include<Query>();
+
+            var query = @"{ hero { id name friend { name } } }";
+            var expected = @"{ 'hero': { 'id' : '1', 'name': 'R2-D2', 'friend': { 'name': 'C3-PO' } } }";
+
+            AssertQuery(_ =>
+            {
+                _.Query = query;
+                _.Definitions = defs;
+                _.ExpectedResult = expected;
+            });
+        }
+
+        [Fact]
+        public void supports_type_references_in_resolve_type()
+        {
+            var defs = @"
+              type Droid {
+                  id: String
+                  name: String
+                  friend: Character
+              }
+
+              type Character {
+                  name: String
+              }
+
+              type Query {
+                  hero: Droid
+              }
+            ";
+
+            Builder.Types.Include<DroidType>();
+            Builder.Types.For("Droid").ResolveType = obj => new GraphQLTypeReference("Droid");
             Builder.Types.Include<Query>();
 
             var query = @"{ hero { id name friend { name } } }";
@@ -55,7 +89,7 @@ public class MyUserContext
         {
         }
 
-        [GraphQLMetadata("Droid")]
+        [GraphQLMetadata("Droid", IsTypeOf = typeof(Droid))]
         public class DroidType
         {
             public string Id(Droid droid) => droid.Id;

src/GraphQL.Tests/Utilities/SchemaBuilderTestBase.cs

@@ -63,15 +63,7 @@ public ExecutionResult CreateQueryResult(string result)
             object expected = null;
             if (!string.IsNullOrWhiteSpace(result))
             {
-                expected = JObject.Parse(result); /*/JsonConvert.SerializeObject(
-                    result,
-                    new JsonSerializerSettings
-                    {
-                        // ContractResolver = new CamelCasePropertyNamesContractResolver(),
-                        Formatting = Formatting.Indented,
-                        DateFormatHandling = DateFormatHandling.IsoDateFormat,
-                        DateFormatString = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFF'Z'",
-                    });*/
+                expected = JObject.Parse(result);
             }
             return new ExecutionResult { Data = expected };
         }

src/GraphQL/Execution/ExecutionNode.cs

@@ -46,15 +46,15 @@ protected ExecutionNode(ExecutionNode parent, IGraphType graphType, Field field,
 
         public abstract object ToValue();
 
-        public IObjectGraphType GetParentType()
+        public IObjectGraphType GetParentType(ISchema schema)
         {
             IGraphType parentType = Parent?.GraphType;
 
             if (parentType is IObjectGraphType objectType)
                 return objectType;
 
             if (parentType is IAbstractGraphType abstractType && Parent.IsResultSet)
-                return abstractType.GetObjectType(Parent.Result);
+                return abstractType.GetObjectType(Parent.Result, schema);
 
             return null;
         }
@@ -72,15 +72,14 @@ public class ObjectExecutionNode : ExecutionNode, IParentExecutionNode
         public ObjectExecutionNode(ExecutionNode parent, IGraphType graphType, Field field, FieldType fieldDefinition, string[] path)
             : base(parent, graphType, field, fieldDefinition, path)
         {
-
         }
 
-        public IObjectGraphType GetObjectGraphType()
+        public IObjectGraphType GetObjectGraphType(ISchema schema)
         {
             var objectGraphType = GraphType as IObjectGraphType;
 
             if (GraphType is IAbstractGraphType abstractGraphType && IsResultSet)
-                objectGraphType = abstractGraphType.GetObjectType(Result);
+                objectGraphType = abstractGraphType.GetObjectType(Result, schema);
 
             return objectGraphType;
         }

src/GraphQL/Execution/ExecutionStrategy.cs

@@ -50,15 +50,13 @@ public static RootExecutionNode BuildExecutionRootNode(ExecutionContext context,
 
         public static void SetSubFieldNodes(ExecutionContext context, ObjectExecutionNode parent)
         {
-
-            var fields = CollectFields(context, parent.GetObjectGraphType(), parent.Field?.SelectionSet);
-
+            var fields = CollectFields(context, parent.GetObjectGraphType(context.Schema), parent.Field?.SelectionSet);
             SetSubFieldNodes(context, parent, fields);
         }
 
         public static void SetSubFieldNodes(ExecutionContext context, ObjectExecutionNode parent, Dictionary<string, Field> fields)
         {
-            var parentType = parent.GetObjectGraphType();
+            var parentType = parent.GetObjectGraphType(context.Schema);
 
             var subFields = new Dictionary<string, ExecutionNode>();
 
@@ -172,7 +170,7 @@ protected virtual async Task<ExecutionNode> ExecuteNodeAsync(ExecutionContext co
                     FieldAst = node.Field,
                     FieldDefinition = node.FieldDefinition,
                     ReturnType = node.FieldDefinition.ResolvedType,
-                    ParentType = node.GetParentType(),
+                    ParentType = node.GetParentType(context.Schema),
                     Arguments = arguments,
                     Source = node.Source,
                     Schema = context.Schema,
@@ -260,14 +258,14 @@ protected virtual void ValidateNodeResult(ExecutionContext context, ExecutionNod
 
             if (fieldType is IAbstractGraphType abstractType)
             {
-                objectType = abstractType.GetObjectType(result);
+                objectType = abstractType.GetObjectType(result, context.Schema);
 
                 if (objectType == null)
                 {
                     var error = new ExecutionError(
                         $"Abstract type {abstractType.Name} must resolve to an Object type at " +
                         $"runtime for field {node.Parent.GraphType.Name}.{node.Name} " +
-                        $"with value {result}, received 'null'.");
+                        $"with value '{result}', received 'null'.");
                     throw error;
                 }
 
@@ -280,7 +278,7 @@ protected virtual void ValidateNodeResult(ExecutionContext context, ExecutionNod
 
             if (objectType?.IsTypeOf != null && !objectType.IsTypeOf(result))
             {
-                var error = new ExecutionError($"Expected value of type \"{objectType}\" but got: {result}.");
+                var error = new ExecutionError($"Expected value of type \"{objectType}\" for \"{objectType.Name}\" but got: {result}.");
                 throw error;
             }
         }

src/GraphQL/Types/GraphQLTypeReference.cs

@@ -1,6 +1,9 @@
-namespace GraphQL.Types
+using System;
+using System.Collections.Generic;
+
+namespace GraphQL.Types
 {
-    public class GraphQLTypeReference : InterfaceGraphType
+    public class GraphQLTypeReference : InterfaceGraphType, IObjectGraphType
     {
         public GraphQLTypeReference(string typeName)
         {
@@ -10,6 +13,41 @@ public GraphQLTypeReference(string typeName)
 
         public string TypeName { get; private set; }
 
+        public Func<object, bool> IsTypeOf
+        {
+             get {
+                throw new InvalidOperationException("This is just a reference.  Resolve the real type first.");
+             }
+             set {
+                throw new InvalidOperationException("This is just a reference.  Resolve the real type first.");
+             }
+        }
+
+        public void AddResolvedInterface(IInterfaceGraphType graphType)
+        {
+            throw new InvalidOperationException("This is just a reference.  Resolve the real type first.");
+        }
+
+        public IEnumerable<Type> Interfaces
+        {
+             get {
+                throw new InvalidOperationException("This is just a reference.  Resolve the real type first.");
+             }
+             set {
+                throw new InvalidOperationException("This is just a reference.  Resolve the real type first.");
+             }
+        }
+
+        public IEnumerable<IInterfaceGraphType> ResolvedInterfaces
+        {
+             get {
+                throw new InvalidOperationException("This is just a reference.  Resolve the real type first.");
+             }
+             set {
+                throw new InvalidOperationException("This is just a reference.  Resolve the real type first.");
+             }
+        }
+
         public override bool Equals(object obj)
         {
             if (obj is GraphQLTypeReference other)
@@ -18,5 +56,10 @@ public override bool Equals(object obj)
             }
             return base.Equals(obj);
         }
+
+        public override int GetHashCode()
+        {
+            return TypeName?.GetHashCode() ?? 0;
+        }
     }
 }

src/GraphQL/Types/IAbstractGraphType.cs

@@ -13,18 +13,23 @@ public interface IAbstractGraphType : IGraphType
         void AddPossibleType(IObjectGraphType type);
     }
 
-    public static class AbstractGraphTypeExtensions {
-
+    public static class AbstractGraphTypeExtensions
+    {
         public static bool IsPossibleType(this IAbstractGraphType abstractType, IGraphType type)
         {
             return abstractType.PossibleTypes.Any(x => x.Equals(type));
         }
 
-        public static IObjectGraphType GetObjectType(this IAbstractGraphType abstractType, object value)
+        public static IObjectGraphType GetObjectType(this IAbstractGraphType abstractType, object value, ISchema schema)
         {
-            return abstractType.ResolveType != null
+            var result = abstractType.ResolveType != null
                 ? abstractType.ResolveType(value)
                 : GetTypeOf(abstractType, value);
+
+            if (result is GraphQLTypeReference reference)
+                result = schema.FindType(reference.Name) as IObjectGraphType;
+
+            return result;
         }
 
         public static IObjectGraphType GetTypeOf(this IAbstractGraphType abstractType, object value)

src/GraphQL/Utilities/TypeConfig.cs

@@ -26,9 +26,6 @@ public Type Type
             {
                 _type = value;
                 ApplyMetadata(value);
-
-                if (IsTypeOfFunc == null)
-                    IsTypeOfFunc = obj => obj?.GetType().IsAssignableFrom(_type) ?? false;
             }
         }
 
@@ -40,7 +37,7 @@ public Type Type
 
         public void IsTypeOf<T>()
         {
-            IsTypeOfFunc = obj => obj?.GetType() == typeof(T);
+            IsTypeOfFunc = obj => obj?.GetType().IsAssignableFrom(typeof(T)) ?? false;
         }
 
         public FieldConfig FieldFor(string field, IDependencyResolver dependencyResolver)

src/GraphQL/Utilities/TypeSettings.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Reflection;
 
 namespace GraphQL.Utilities
 {
@@ -17,10 +18,9 @@ public TypeConfig For(string typeName)
             return _typeConfigurations[typeName];
         }
 
-        public void Include<T>()
+        public void Include<TType>()
         {
-            var type = typeof(T);
-            Include(type);
+            Include(typeof(TType));
         }
 
         public void Include(Type type)
@@ -33,5 +33,23 @@ public void Include(string name, Type type)
         {
             _typeConfigurations[name].Type = type;
         }
+
+        public void Include<TType, TTypeOfType>()
+        {
+            Include(typeof(TType), typeof(TTypeOfType));
+        }
+
+        public void Include(Type type, Type typeOfType)
+        {
+            var name = type.GraphQLName();
+            Include(name, type, typeOfType);
+        }
+
+        public void Include(string name, Type type, Type typeOfType)
+        {
+            var config = _typeConfigurations[name];
+            config.Type = type;
+            config.IsTypeOfFunc = obj => obj?.GetType().IsAssignableFrom(typeOfType) ?? false;
+        }
     }
-}
+}

tools/tasks/test.dotnet.js

@@ -4,7 +4,7 @@ import exec from './exec'
 function test(settings, project) {
   return () => {
     const platform = process.platform === 'darwin'
-      ? '-f netcoreapp2.0'
+      ? '-f netcoreapp2.1'
       : ''
     const cmd = `dotnet test ${platform} "${project}" -c ${settings.target} --no-restore`
     return exec(cmd)