enable defer stream across schema creation

Author: yaacovCR

package.json

@@ -83,6 +83,6 @@
     "./website"
   ],
   "resolutions": {
-    "graphql": "15.3.0"
+    "graphql": "npm:graphql-experimental"
   }
 }

packages/delegate/src/defaultMergedResolver.ts

@@ -33,6 +33,16 @@ 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';
+  }
+
   const subschema = getSubschema(parent, responseKey);
 
   return resolveExternalValue(data, unpathedErrors, subschema, context, info);

packages/delegate/tests/deferStream.test.ts

@@ -0,0 +1,51 @@
+import { graphql } from 'graphql/experimental';
+
+import { makeExecutableSchema } from '@graphql-tools/schema';
+
+describe('defer support', () => {
+  test('should work', async () => {
+    const schema = makeExecutableSchema({
+      typeDefs: `
+        type Query {
+          test(input: String): String
+        }
+      `,
+      resolvers: {
+        Query: {
+          test: (_root, args) => args.input,
+        }
+      },
+    });
+
+    const result = await graphql(
+      schema,
+      `
+        query {
+          ... on Query @defer {
+            test(input: "test")
+          }
+        }
+      `,
+    );
+
+    const results = [];
+    if (result[Symbol.asyncIterator]) {
+      for await (let patch of result) {
+        results.push(patch);
+      }
+    }
+
+    expect(results[0]).toEqual({
+      data: {},
+      hasNext: true,
+    });
+    expect(results[1]).toEqual({
+      data: {
+        test: 'test'
+      },
+      hasNext: false,
+      path: [],
+    });
+
+  });
+});

packages/load/tests/loaders/schema/integration.spec.ts

@@ -53,6 +53,31 @@ describe('loadSchema', () => {
       const schemaStr = printSchema(schema);
 
       expect(schemaStr).toBeSimilarGqlDoc(/* GraphQL */`
+        """
+        Directs the executor to defer this fragment when the \`if\` argument is true or undefined.
+        """
+        directive @defer(
+          """Deferred when true or undefined."""
+          if: Boolean
+
+          """Unique name"""
+          label: String
+        ) on FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+        """
+        Directs the executor to stream plural fields when the \`if\` argument is true or undefined.
+        """
+        directive @stream(
+          """Stream when true or undefined."""
+          if: Boolean
+
+          """Unique name"""
+          label: String
+
+          """Number of items to return immediately"""
+          initialCount: Int!
+        ) on FIELD
+
         type Query {
           a: A
           b: B

packages/schema/src/buildSchemaFromTypeDefinitions.ts

@@ -1,4 +1,4 @@
-import { extendSchema, buildASTSchema, GraphQLSchema, DocumentNode, ASTNode } from 'graphql';
+import { extendSchema, buildASTSchema, GraphQLSchema, DocumentNode, ASTNode, BuildSchemaOptions } from 'graphql';
 
 import { ITypeDefinitions, GraphQLParseOptions, parseGraphQLSDL } from '@graphql-tools/utils';
 
@@ -12,12 +12,16 @@ export function buildSchemaFromTypeDefinitions(
   const document = buildDocumentFromTypeDefinitions(typeDefinitions, parseOptions);
   const typesAst = filterExtensionDefinitions(document);
 
-  const backcompatOptions = { commentDescriptions: true };
-  let schema: GraphQLSchema = buildASTSchema(typesAst, backcompatOptions);
+  const options: BuildSchemaOptions = {
+    commentDescriptions: true,
+    experimentalDefer: true,
+    experimentalStream: true,
+  };
+  let schema: GraphQLSchema = buildASTSchema(typesAst, options);
 
   const extensionsAst = extractExtensionDefinitions(document);
   if (extensionsAst.definitions.length > 0) {
-    schema = extendSchema(schema, extensionsAst, backcompatOptions);
+    schema = extendSchema(schema, extensionsAst, options);
   }
 
   return schema;

packages/schema/src/types.ts

@@ -67,4 +67,12 @@ export interface IExecutableSchemaDefinition<TContext = any> {
    * Additional options for removing unused types from the schema
    */
   pruningOptions?: PruneSchemaOptions;
+  /**
+   * Set to `true` to enable support within queries for the experimental `defer` directive
+   */
+  experimentalDefer?: boolean;
+  /**
+   * Set to `true` to enable support within queries for the experimental `stream` directive
+   */
+  experimentalStream?: boolean;
 }

packages/stitch/src/stitchSchemas.ts

@@ -141,6 +141,8 @@ export function stitchSchemas({
     astNode: schemaDefs.schemaDef,
     extensionASTNodes: schemaDefs.schemaExtensions,
     extensions: null,
+    experimentalDefer: true,
+    experimentalStream: true,
   });
 
   extensions.forEach(extension => {

packages/stitch/src/stitchingInfo.ts

@@ -348,6 +348,8 @@ export function addStitchingInfo(stitchedSchema: GraphQLSchema, stitchingInfo: S
       ...stitchedSchema.extensions,
       stitchingInfo,
     },
+    experimentalDefer: true,
+    experimentalStream: true,
   });
 }
 

packages/utils/src/addTypes.ts

@@ -80,5 +80,7 @@ export function addTypes(
     subscription: subscriptionTypeName != null ? (typeMap[subscriptionTypeName] as GraphQLObjectType) : undefined,
     types: Object.keys(typeMap).map(typeName => typeMap[typeName]),
     directives,
+    experimentalDefer: true,
+    experimentalStream: true,
   });
 }

packages/utils/src/mapSchema.ts

@@ -88,6 +88,8 @@ export function mapSchema(schema: GraphQLSchema, schemaMapper: SchemaMapper = {}
     subscription: newSubscriptionTypeName != null ? (typeMap[newSubscriptionTypeName] as GraphQLObjectType) : undefined,
     types: Object.keys(typeMap).map(typeName => typeMap[typeName]),
     directives,
+    experimentalDefer: true,
+    experimentalStream: true,
   });
 }