Subscriptions should normalize requests only once

yaacovCR · yaacovCR · commit 10ccfea3dbaf · 2021-10-11T17:31:51.000+03:00
The `subscribe` method calls `createSourceEventStream` and `execute`, each of which normalize the request properties separately. By normalizing requests within the `subscribe` function, we can pass the normalized arguments to the implementation for `createSourceEventStream` and `execute`, i.e. new functions `createSourceEventStreamImpl` and `executeQueryOrMutation`.
diff --git a/src/execution/__tests__/subscribe-test.ts b/src/execution/__tests__/subscribe-test.ts
@@ -502,16 +502,29 @@ describe('Subscription Initialization Phase', () => {
 
     // If we receive variables that cannot be coerced correctly, subscribe() will
     // resolve to an ExecutionResult that contains an informative error description.
-    const result = await subscribe({ schema, document, variableValues });
-    expectJSON(result).to.deep.equal({
+    const expectedResult = {
       errors: [
         {
           message:
             'Variable "$arg" got invalid value "meow"; Int cannot represent non-integer value: "meow"',
           locations: [{ line: 2, column: 21 }],
         },
       ],
-    });
+    };
+
+    expectJSON(
+      await subscribe({ schema, document, variableValues }),
+    ).to.deep.equal(expectedResult);
+
+    expectJSON(
+      await createSourceEventStream(
+        schema,
+        document,
+        undefined,
+        undefined,
+        variableValues,
+      ),
+    ).to.deep.equal(expectedResult);
   });
 });
 
diff --git a/src/execution/execute.ts b/src/execution/execute.ts
@@ -180,7 +180,11 @@ export function execute(args: ExecutionArgs): PromiseOrValue<ExecutionResult> {
     return { errors: exeContext };
   }
 
-  // Return data or a  Promise that will eventually resolve to the data described
+  return executeQueryOrMutation(exeContext);
+}
+
+export function executeQueryOrMutation(exeContext: ExecutionContext) {
+  // Return data or a Promise that will eventually resolve to the data described
   // by the "Response" section of the GraphQL specification.
 
   // If errors are encountered while executing a GraphQL field, only that
diff --git a/src/execution/subscribe.ts b/src/execution/subscribe.ts
@@ -24,7 +24,7 @@ import {
   assertValidExecutionArguments,
   buildExecutionContext,
   buildResolveInfo,
-  execute,
+  executeQueryOrMutation,
   getFieldDef,
 } from './execute';
 import { mapAsyncIterator } from './mapAsyncIterator';
@@ -64,26 +64,28 @@ export interface SubscriptionArgs extends ExecutionArgs {}
 export async function subscribe(
   args: SubscriptionArgs,
 ): Promise<AsyncGenerator<ExecutionResult, void, void> | ExecutionResult> {
-  const {
-    schema,
-    document,
-    rootValue,
-    contextValue,
-    variableValues,
-    operationName,
-    fieldResolver,
-    subscribeFieldResolver,
-  } = args;
+  const { schema, document, variableValues } = args;
 
-  const resultOrStream = await createSourceEventStream(
-    schema,
-    document,
-    rootValue,
-    contextValue,
-    variableValues,
-    operationName,
-    subscribeFieldResolver,
-  );
+  // If arguments are missing or incorrectly typed, this is an internal
+  // developer mistake which should throw an early error.
+  assertValidExecutionArguments(schema, document, variableValues);
+
+  // If a valid execution context cannot be created due to incorrect arguments,
+  // a "Response" with only errors is returned.
+  const exeContext = buildExecutionContext(args);
+
+  // Return early errors if execution context failed.
+  if (!('schema' in exeContext)) {
+    return { errors: exeContext };
+  }
+
+  return executeSubscription(exeContext);
+}
+
+async function executeSubscription(
+  exeContext: ExecutionContext,
+): Promise<AsyncGenerator<ExecutionResult, void, void> | ExecutionResult> {
+  const resultOrStream = await createSourceEventStreamImpl(exeContext);
 
   if (!isAsyncIterable(resultOrStream)) {
     return resultOrStream;
@@ -96,14 +98,10 @@ export async function subscribe(
   // "ExecuteSubscriptionEvent" algorithm, as it is nearly identical to the
   // "ExecuteQuery" algorithm, for which `execute` is also used.
   const mapSourceToResponse = (payload: unknown) =>
-    execute({
-      schema,
-      document,
+    executeQueryOrMutation({
+      ...exeContext,
       rootValue: payload,
-      contextValue,
-      variableValues,
-      operationName,
-      fieldResolver,
+      errors: [],
     });
 
   // Map every source value to a ExecutionResult value as described above.
@@ -168,6 +166,12 @@ export async function createSourceEventStream(
     return { errors: exeContext };
   }
 
+  return createSourceEventStreamImpl(exeContext);
+}
+
+export async function createSourceEventStreamImpl(
+  exeContext: ExecutionContext,
+): Promise<AsyncIterable<unknown> | ExecutionResult> {
   try {
     const eventStream = await executeSubscriptionRootField(exeContext);
 
