refactor(forAwaitEach): in favor of native for await

Author: yaacovCR

packages/schema/tests/forAwaitEach.ts

@@ -11,8 +11,6 @@ import { makeExecutableSchema, addSchemaLevelResolver } from '@graphql-tools/sch
 
 import { ExecutionResult } from '@graphql-tools/utils';
 
-import { forAwaitEach } from './forAwaitEach';
-
 describe('Resolve', () => {
   describe('addSchemaLevelResolver', () => {
     const pubsub = new PubSub();
@@ -79,97 +77,58 @@ describe('Resolve', () => {
       });
     });
 
-    test('should isolate roots from the different operation types', (done) => {
+    test('should isolate roots from the different operation types', async () => {
       schemaLevelResolverCalls = 0;
       const queryRoot = 'queryRoot';
       const mutationRoot = 'mutationRoot';
       const subscriptionRoot = 'subscriptionRoot';
       const subscriptionRoot2 = 'subscriptionRoot2';
 
-      let subsCbkCalls = 0;
-      const firstSubsTriggered = new Promise((resolveFirst) => {
-        subscribe(
-          schema,
-          parse(`
-            subscription TestSubscription {
-              printRoot
-            }
-          `),
-        )
-          .then((results) => {
-            forAwaitEach(
-              results as AsyncIterable<ExecutionResult>,
-              (result: ExecutionResult) => {
-                if (result.errors != null) {
-                  return done(
-                    new Error(
-                      `Unexpected errors in GraphQL result: ${JSON.stringify(
-                        result.errors,
-                      )}`,
-                    ),
-                  );
-                }
-
-                const subsData = result.data;
-                subsCbkCalls++;
-                try {
-                  if (subsCbkCalls === 1) {
-                    expect(schemaLevelResolverCalls).toEqual(1);
-                    expect(subsData).toEqual({ printRoot: subscriptionRoot });
-                    return resolveFirst();
-                  } else if (subsCbkCalls === 2) {
-                    expect(schemaLevelResolverCalls).toEqual(4);
-                    expect(subsData).toEqual({
-                      printRoot: subscriptionRoot2,
-                    });
-                    return done();
-                  }
-                } catch (e) {
-                  return done(e);
-                }
-                done(new Error('Too many subscription fired'));
-              },
-            ).catch(done);
-          })
-          .then(() =>
-            pubsub.publish('printRootChannel', { printRoot: subscriptionRoot }),
-          )
-          .catch(done);
-      });
+      const sub = await subscribe(
+        schema,
+        parse(`
+          subscription TestSubscription {
+            printRoot
+          }
+        `),
+      ) as AsyncIterableIterator<ExecutionResult>;
+
+      const payload1 = sub.next();
+      await pubsub.publish('printRootChannel', { printRoot: subscriptionRoot });
+
+      expect(await payload1).toEqual({ done: false, value: { data: { printRoot: subscriptionRoot } } });
+      expect(schemaLevelResolverCalls).toEqual(1);
+
+      const queryResult = await graphql(
+        schema,
+        `
+          query TestQuery {
+            printRoot
+          }
+        `,
+        queryRoot,
+      );
+
+      expect(queryResult).toEqual({ data: { printRoot: queryRoot } });
+      expect(schemaLevelResolverCalls).toEqual(2);
+
+      const mutationResult = await graphql(
+        schema,
+        `
+          mutation TestMutation {
+            printRoot
+          }
+        `,
+        mutationRoot,
+      );
+
+      expect(mutationResult).toEqual({ data: { printRoot: mutationRoot } });
+      expect(schemaLevelResolverCalls).toEqual(3);
+
+      await pubsub.publish('printRootChannel', { printRoot: subscriptionRoot2 });
 
-      firstSubsTriggered
-        .then(() =>
-          graphql(
-            schema,
-            `
-              query TestQuery {
-                printRoot
-              }
-            `,
-            queryRoot,
-          ),
-        )
-        .then(({ data }) => {
-          expect(schemaLevelResolverCalls).toEqual(2);
-          expect(data).toEqual({ printRoot: queryRoot });
-          return graphql(
-            schema,
-            `
-              mutation TestMutation {
-                printRoot
-              }
-            `,
-            mutationRoot,
-          );
-        })
-        .then(({ data: mutationData }) => {
-          expect(schemaLevelResolverCalls).toEqual(3);
-          expect(mutationData).toEqual({ printRoot: mutationRoot });
-          return pubsub.publish('printRootChannel', {
-            printRoot: subscriptionRoot2,
-          });
-        })
-        .catch(done);
+      expect(await sub.next()).toEqual({ done: false, value: { data: { printRoot: subscriptionRoot2 } } });
+      expect(schemaLevelResolverCalls).toEqual(4);
     });
 
     it('should not force an otherwise synchronous operation to be asynchronous', () => {

packages/schema/tests/resolution.test.ts

@@ -37,8 +37,6 @@ import { filterSchema, ExecutionResult } from '@graphql-tools/utils';
 
 import { stitchSchemas } from '../src/stitchSchemas';
 
-import { forAwaitEach } from './forAwaitEach';
-
 import {
   bookingSchema,
   propertySchema,
@@ -309,7 +307,7 @@ describe('merge schemas through transforms', () => {
     });
   });
 
-  test('local subscriptions should work even if root fields are renamed', (done) => {
+  test('local subscriptions should work even if root fields are renamed', async () => {
     const originalNotification = {
       notifications: {
         text: 'Hello world',
@@ -322,34 +320,23 @@ describe('merge schemas through transforms', () => {
     };
 
     const subscription = parse(`
-        subscription Subscription {
-          Subscriptions_notifications {
-            text
-          }
+      subscription Subscription {
+        Subscriptions_notifications {
+          text
         }
-      `);
-
-    let notificationCnt = 0;
-    subscribe(stitchedSchema, subscription)
-      .then((results) => {
-        forAwaitEach(
-          results as AsyncIterable<ExecutionResult>,
-          (result: ExecutionResult) => {
-            expect(result).toHaveProperty('data');
-            expect(result.data).toEqual(transformedNotification);
-            if (!notificationCnt++) {
-              return done();
-            }
-          },
-        ).catch(done);
-      })
-      .then(() =>
-        subscriptionPubSub.publish(
-          subscriptionPubSubTrigger,
-          originalNotification,
-        ),
-      )
-      .catch(done);
+      }
+    `);
+
+    const sub = await subscribe(stitchedSchema, subscription) as AsyncIterableIterator<ExecutionResult>;
+
+    const payload = sub.next();
+
+    await subscriptionPubSub.publish(
+      subscriptionPubSubTrigger,
+      originalNotification,
+    );
+
+    expect(await payload).toEqual({ done: false, value: { data: transformedNotification } } );
   });
 });
 

packages/stitch/tests/alternateStitchSchemas.test.ts

@@ -21,9 +21,8 @@ import {
   IResolvers,
   ExecutionResult,
 } from '@graphql-tools/utils';
-import { addMocksToSchema } from '@graphql-tools/mock';
 
-import { forAwaitEach } from './forAwaitEach';
+import { addMocksToSchema } from '@graphql-tools/mock';
 
 import {
   propertySchema as localPropertySchema,
@@ -846,7 +845,7 @@ bookingById(id: "b1") {
         expect(stitchedResult).toEqual(bookingResult);
       });
 
-      test('local subscriptions working in merged schema', (done) => {
+      test('local subscriptions working in merged schema', async () => {
         const mockNotification = {
           notifications: {
             text: 'Hello world',
@@ -861,30 +860,19 @@ bookingById(id: "b1") {
           }
         `);
 
-        let notificationCnt = 0;
-        subscribe(stitchedSchema, subscription)
-          .then((results) => {
-            forAwaitEach(
-              results as AsyncIterable<ExecutionResult>,
-              (result: ExecutionResult) => {
-                expect(result).toHaveProperty('data');
-                expect(result.data).toEqual(mockNotification);
-                if (!notificationCnt++) {
-                  done();
-                }
-              },
-            ).catch(done);
-          })
-          .then(() =>
-            subscriptionPubSub.publish(
-              subscriptionPubSubTrigger,
-              mockNotification,
-            ),
-          )
-          .catch(done);
+        const sub = await subscribe(stitchedSchema, subscription) as AsyncIterableIterator<ExecutionResult>;
+
+        const payload = sub.next();
+
+        await subscriptionPubSub.publish(
+          subscriptionPubSubTrigger,
+          mockNotification,
+        );
+
+        expect(await payload).toEqual({ done: false, value: { data: mockNotification } });
       });
 
-      test('subscription errors are working correctly in merged schema', (done) => {
+      test('subscription errors are working correctly in merged schema', async () => {
         const mockNotification = {
           notifications: {
             text: 'Hello world',
@@ -921,30 +909,16 @@ bookingById(id: "b1") {
           }
         `);
 
-        let notificationCnt = 0;
-        subscribe(stitchedSchema, subscription)
-          .then((results) => {
-            forAwaitEach(
-              results as AsyncIterable<ExecutionResult>,
-              (result: ExecutionResult) => {
-                expect(result).toHaveProperty('data');
-                expect(result).toHaveProperty('errors');
-                expect(result.errors).toHaveLength(1);
-                expect(result.errors).toEqual(expectedResult.errors);
-                expect(result.data).toEqual(expectedResult.data);
-                if (!notificationCnt++) {
-                  done();
-                }
-              },
-            ).catch(done);
-          })
-          .then(() =>
-            subscriptionPubSub.publish(
-              subscriptionPubSubTrigger,
-              mockNotification,
-            ),
-          )
-          .catch(done);
+        const sub = await subscribe(stitchedSchema, subscription) as AsyncIterableIterator<ExecutionResult>;
+
+        const payload = sub.next();
+
+        await subscriptionPubSub.publish(
+          subscriptionPubSubTrigger,
+          mockNotification,
+        );
+
+        expect(await payload).toEqual({ done: false, value: expectedResult });
       });
 
       test('links in queries', async () => {