proof of concept

Author: yaacovCR

packages/delegate/src/defaultMergedResolver.ts

@@ -1,6 +1,6 @@
 import { defaultFieldResolver, GraphQLResolveInfo } from 'graphql';
 
-import { getResponseKeyFromInfo } from '@graphql-tools/utils';
+import { getResponseKeyFromInfo, ExecutionResult } from '@graphql-tools/utils';
 
 import { resolveExternalValue } from './resolveExternalValue';
 import { getSubschema } from './Subschema';
@@ -18,7 +18,7 @@ export function defaultMergedResolver(
   args: Record<string, any>,
   context: Record<string, any>,
   info: GraphQLResolveInfo
-) {
+): any {
   if (!parent) {
     return null;
   }
@@ -34,16 +34,26 @@ export function defaultMergedResolver(
   const data = parent[responseKey];
   const unpathedErrors = getUnpathedErrors(parent);
 
-  // To Do: extract this section to separate function.
-  // If proxied result with defer or stream, result may be initially undefined
-  // so must call out to a to-be-created Receiver abstraction
-  // (as opposed to Dispatcher within graphql-js) that will notify of data arrival
-
-  if (data === undefined) {
-    return 'test';
+  // To Do:
+  // add support for transforms
+  // call out to Receiver abstraction that will publish all patches with channel based on path
+  // edit code below to subscribe to appropriate channel based on path
+  // so as to handle multiple defer patches and discriminate between them without need for labels
+
+  if (data === undefined && 'ASYNC_ITERABLE' in parent) {
+    const asyncIterable = parent['ASYNC_ITERABLE'];
+    return asyncIterableToResult(asyncIterable).then(patch => {
+      return defaultMergedResolver(patch.data, args, context, info);
+    });
   }
 
   const subschema = getSubschema(parent, responseKey);
 
   return resolveExternalValue(data, unpathedErrors, subschema, context, info);
 }
+
+async function asyncIterableToResult(asyncIterable: AsyncIterable<ExecutionResult>): Promise<any> {
+  const asyncIterator = asyncIterable[Symbol.asyncIterator]();
+  const payload = await asyncIterator.next();
+  return payload.value;
+}

packages/delegate/src/delegateToSchema.ts

@@ -1,6 +1,5 @@
 import {
   subscribe,
-  execute,
   validate,
   GraphQLSchema,
   isSchema,
@@ -13,9 +12,11 @@ import {
   GraphQLObjectType,
 } from 'graphql';
 
+import { execute } from 'graphql/experimental';
+
 import isPromise from 'is-promise';
 
-import { mapAsyncIterator, ExecutionResult } from '@graphql-tools/utils';
+import { mapAsyncIterator, ExecutionResult, isAsyncIterable } from '@graphql-tools/utils';
 
 import {
   IDelegateToSchemaOptions,
@@ -175,8 +176,16 @@ export function delegateRequest({
       info,
     });
 
-    if (isPromise(executionResult)) {
-      return executionResult.then(originalResult => transformer.transformResult(originalResult));
+    if (isAsyncIterable(executionResult)) {
+      return asyncIterableToResult(executionResult).then(originalResult => {
+        const transformedResult = transformer.transformResult(originalResult);
+        transformedResult['ASYNC_ITERABLE'] = executionResult;
+        return transformedResult;
+      });
+    } else if (isPromise(executionResult)) {
+      return (executionResult as Promise<ExecutionResult>).then(originalResult =>
+        transformer.transformResult(originalResult)
+      );
     }
     return transformer.transformResult(executionResult);
   }
@@ -190,7 +199,7 @@ export function delegateRequest({
     context,
     info,
   }).then((subscriptionResult: AsyncIterableIterator<ExecutionResult> | ExecutionResult) => {
-    if (Symbol.asyncIterator in subscriptionResult) {
+    if (isAsyncIterable(subscriptionResult)) {
       // "subscribe" to the subscription result and map the result through the transforms
       return mapAsyncIterator<ExecutionResult, any>(
         subscriptionResult as AsyncIterableIterator<ExecutionResult>,
@@ -237,3 +246,9 @@ function createDefaultSubscriber(schema: GraphQLSchema, rootValue: Record<string
       rootValue: rootValue ?? info?.rootValue,
     }) as any;
 }
+
+async function asyncIterableToResult(asyncIterable: AsyncIterable<ExecutionResult>): Promise<any> {
+  const asyncIterator = asyncIterable[Symbol.asyncIterator]();
+  const payload = await asyncIterator.next();
+  return payload.value;
+}

packages/delegate/tests/deferStream.test.ts

@@ -1,35 +1,41 @@
 import { graphql } from 'graphql/experimental';
 
 import { makeExecutableSchema } from '@graphql-tools/schema';
+import { stitchSchemas } from '@graphql-tools/stitch';
+import { isAsyncIterable } from '@graphql-tools/utils';
 
 describe('defer support', () => {
-  test('should work', async () => {
+  test('should work for root fields', async () => {
     const schema = makeExecutableSchema({
       typeDefs: `
         type Query {
-          test(input: String): String
+          test: String
         }
       `,
       resolvers: {
         Query: {
-          test: (_root, args) => args.input,
+          test: () => 'test',
         }
       },
     });
 
+    const stitchedSchema = stitchSchemas({
+      subschemas: [schema]
+    });
+
     const result = await graphql(
-      schema,
+      stitchedSchema,
       `
         query {
           ... on Query @defer {
-            test(input: "test")
+            test
           }
         }
       `,
     );
 
     const results = [];
-    if (result[Symbol.asyncIterator]) {
+    if (isAsyncIterable(result)) {
       for await (let patch of result) {
         results.push(patch);
       }
@@ -46,6 +52,63 @@ describe('defer support', () => {
       hasNext: false,
       path: [],
     });
+  });
 
+  test('should work for nested fields', async () => {
+    const schema = makeExecutableSchema({
+      typeDefs: `
+        type Object {
+          test: String
+        }
+        type Query {
+          object: Object
+        }
+      `,
+      resolvers: {
+        Object: {
+          test: () => 'test',
+        },
+        Query: {
+          object: () => ({}),
+        }
+      },
+    });
+
+    const stitchedSchema = stitchSchemas({
+      subschemas: [schema]
+    });
+
+    const result = await graphql(
+      stitchedSchema,
+      `
+        query {
+          object {
+            ... on Object @defer {
+              test
+            }
+          }
+        }
+      `,
+    );
+
+    const results = [];
+    if (isAsyncIterable(result)) {
+      for await (let patch of result) {
+        results.push(patch);
+      }
+    }
+
+    expect(results[0]).toEqual({
+      data: { object: {} },
+      hasNext: true,
+    });
+    expect(results[1]).toEqual({
+      data: {
+        test: 'test'
+      },
+      hasNext: false,
+      path: ['object'],
+    });
   });
 });
+