add query abstraction

src/HotChocolate/Core/src/Abstractions/IQuery.cs

@@ -0,0 +1,12 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace HotChocolate
+{
+    public interface IQuery
+    {
+        ValueTask<object> ExecuteAsync(CancellationToken cancellationToken);
+
+        string Print();
+    }
+}

src/HotChocolate/Core/src/Abstractions/IQuery~1.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace HotChocolate
+{
+    public interface IQuery<T> : IQuery
+    {
+        new ValueTask<IReadOnlyList<T>> ExecuteAsync(CancellationToken cancellationToken);
+    }
+}

src/HotChocolate/Core/src/Execution/Processing/ResolverTask.cs

@@ -66,6 +66,10 @@ private async ValueTask ExecuteResolverPipelineAsync()
 
             switch (_context.Result)
             {
+                case HotChocolate.IQuery query:
+                    _context.Result = await query.ExecuteAsync(_context);
+                    break;
+
                 case IQueryable queryable:
                     _context.Result = await Task.Run(() =>
                     {

src/HotChocolate/Core/src/Types/Internal/ExtendedType.Helper.cs

@@ -166,7 +166,8 @@ public static bool IsSupportedCollectionInterface(Type type)
                         || typeDefinition == typeof(ImmutableList<>)
                         || typeDefinition == typeof(ImmutableQueue<>)
                         || typeDefinition == typeof(ImmutableStack<>)
-                        || typeDefinition == typeof(ImmutableHashSet<>))
+                        || typeDefinition == typeof(ImmutableHashSet<>)
+                        || typeDefinition == typeof(IQuery<>))
                     {
                         return true;
                     }

src/HotChocolate/Core/src/Types/Internal/ExtendedType.Members.cs

@@ -40,7 +40,8 @@ public static ExtendedMethodInfo FromMethod(MethodInfo method, TypeCache cache)
                     method,
                     () => Rewrite(
                         CreateExtendedType(context, helper.GetFlags(method), method.ReturnType),
-                        method, cache));
+                        method,
+                        cache));
 
                 ParameterInfo[] parameters = method.GetParameters();
                 var parameterTypes = new Dictionary<ParameterInfo, IExtendedType>();
@@ -203,6 +204,7 @@ public static ExtendedMethodInfo FromMethod(MethodInfo method, TypeCache cache)
                             state = flags[0];
                         }
                     }
+
                     return state;
                 }
             }

src/HotChocolate/Core/src/Types/Internal/ExtendedType.SystemType.cs

@@ -20,7 +20,7 @@ private static ExtendedType FromTypeInternal(Type type, TypeCache cache)
                     && type.GetGenericTypeDefinition() == typeof(Nullable<>))
                 {
                     Type inner = type.GetGenericArguments()[0];
-                    
+
                     return new ExtendedType(
                         inner,
                         ExtendedTypeKind.Runtime,
@@ -50,7 +50,7 @@ private static ExtendedType FromTypeInternal(Type type, TypeCache cache)
             }
 
             public static IReadOnlyList<ExtendedType> GetGenericArguments(
-                Type type, 
+                Type type,
                 TypeCache cache)
             {
                 if (type.IsGenericType)

src/HotChocolate/Core/test/Execution.Tests/CodeFirstTests.cs

@@ -1,4 +1,6 @@
 using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using HotChocolate.Execution;
 using HotChocolate.Resolvers;
@@ -43,6 +45,22 @@ public async Task ExecuteOneFieldQueryWithMethod()
             result.MatchSnapshot();
         }
 
+        [Fact]
+        public async Task ExecuteOneFieldQueryWithQuery()
+        {
+            // arrange
+            var schema = Schema.Create(
+                c => c.RegisterType<QueryTypeWithMethod>());
+
+            // act
+            IExecutionResult result =
+                await schema.MakeExecutable().ExecuteAsync("{ query }");
+
+            // assert
+            Assert.Null(result.Errors);
+            result.MatchSnapshot();
+        }
+
         [Fact]
         public async Task ExecuteWithUnionType()
         {
@@ -51,13 +69,16 @@ public async Task ExecuteWithUnionType()
 
             // act
             IExecutionResult result =
-                await schema.MakeExecutable().ExecuteAsync(
-                    @"{
-                        fooOrBar {
-                            ... on Bar { nameBar }
-                            ... on Foo { nameFoo }
+                await schema.MakeExecutable()
+                    .ExecuteAsync(
+                        @"
+                        {
+                            fooOrBar {
+                                ... on Bar { nameBar }
+                                ... on Foo { nameFoo }
+                            }
                         }
-                    }");
+                        ");
 
             // assert
             Assert.Null(result.Errors);
@@ -263,6 +284,11 @@ public string GetTest()
                 return "Hello World!";
             }
 
+            public IQuery<string> GetQuery()
+            {
+                return MockQuery<string>.From("foo", "bar");
+            }
+
             public string TestProp => "Hello World!";
         }
 
@@ -285,6 +311,7 @@ public class QueryTypeWithMethod
             {
                 descriptor.Name("Query");
                 descriptor.Field(t => t.GetTest()).Name("test");
+                descriptor.Field(t => t.GetQuery()).Name("query");
             }
         }
 
@@ -434,5 +461,32 @@ public class DogType
                     .Type<ListType<StringType>>();
             }
         }
+
+        public class MockQuery<T> : IQuery<T>
+        {
+            private readonly IReadOnlyList<T> _list;
+
+            private MockQuery(IEnumerable<T> list)
+            {
+                _list = list.ToArray();
+            }
+
+            async ValueTask<object> IQuery.ExecuteAsync(CancellationToken cancellationToken)
+            {
+                return await ExecuteAsync(cancellationToken);
+            }
+
+            public ValueTask<IReadOnlyList<T>> ExecuteAsync(CancellationToken cancellationToken)
+            {
+                return new ValueTask<IReadOnlyList<T>>(_list);
+            }
+
+            public string Print()
+            {
+                return _list.ToString();
+            }
+
+            public static MockQuery<T> From(params T[] items) => new MockQuery<T>(items);
+        }
     }
 }