createSourceEventStream: remove deprecated positional arguments (graphql#3635)

Author: yaacovCR

src/execution/__tests__/subscribe-test.ts

@@ -191,7 +191,7 @@ function subscribeWithBadFn(
 
   return expectEqualPromisesOrValues(
     subscribe({ schema, document }),
-    createSourceEventStream(schema, document),
+    createSourceEventStream({ schema, document }),
   );
 }
 
@@ -421,63 +421,6 @@ describe('Subscription Initialization Phase', () => {
     expect(() => subscribe({ schema })).to.throw('Must provide document.');
   });
 
-  it('Deprecated: allows positional arguments to createSourceEventStream', async () => {
-    async function* fooGenerator() {
-      /* c8 ignore next 2 */
-      yield { foo: 'FooValue' };
-    }
-
-    const schema = new GraphQLSchema({
-      query: DummyQueryType,
-      subscription: new GraphQLObjectType({
-        name: 'Subscription',
-        fields: {
-          foo: { type: GraphQLString, subscribe: fooGenerator },
-        },
-      }),
-    });
-    const document = parse('subscription { foo }');
-
-    const eventStream = await createSourceEventStream(schema, document);
-    assert(isAsyncIterable(eventStream));
-  });
-
-  it('Deprecated: throws an error if document is missing when using positional arguments', async () => {
-    const document = parse('subscription { foo }');
-    const schema = new GraphQLSchema({
-      query: DummyQueryType,
-      subscription: new GraphQLObjectType({
-        name: 'Subscription',
-        fields: {
-          foo: { type: GraphQLString },
-        },
-      }),
-    });
-
-    // @ts-expect-error (schema must not be null)
-    expect(() => createSourceEventStream(null, document)).to.throw(
-      'Expected null to be a GraphQL schema.',
-    );
-
-    expect(() =>
-      createSourceEventStream(
-        // @ts-expect-error
-        undefined,
-        document,
-      ),
-    ).to.throw('Expected undefined to be a GraphQL schema.');
-
-    // @ts-expect-error (document must not be null)
-    expect(() => createSourceEventStream(schema, null)).to.throw(
-      'Must provide document.',
-    );
-
-    // @ts-expect-error
-    expect(() => createSourceEventStream(schema)).to.throw(
-      'Must provide document.',
-    );
-  });
-
   it('resolves to an error if schema does not support subscriptions', async () => {
     const schema = new GraphQLSchema({ query: DummyQueryType });
     const document = parse('subscription { unknownField }');

src/execution/subscribe.ts

@@ -1,18 +1,12 @@
 import { inspect } from '../jsutils/inspect';
 import { isAsyncIterable } from '../jsutils/isAsyncIterable';
 import { isPromise } from '../jsutils/isPromise';
-import type { Maybe } from '../jsutils/Maybe';
 import { addPath, pathToArray } from '../jsutils/Path';
 import type { PromiseOrValue } from '../jsutils/PromiseOrValue';
 
 import { GraphQLError } from '../error/GraphQLError';
 import { locatedError } from '../error/locatedError';
 
-import type { DocumentNode } from '../language/ast';
-
-import type { GraphQLFieldResolver } from '../type/definition';
-import type { GraphQLSchema } from '../type/schema';
-
 import { collectFields } from './collectFields';
 import type {
   ExecutionArgs,
@@ -89,36 +83,6 @@ function mapSourceToResponse(
   );
 }
 
-type BackwardsCompatibleArgs =
-  | [options: ExecutionArgs]
-  | [
-      schema: ExecutionArgs['schema'],
-      document: ExecutionArgs['document'],
-      rootValue?: ExecutionArgs['rootValue'],
-      contextValue?: ExecutionArgs['contextValue'],
-      variableValues?: ExecutionArgs['variableValues'],
-      operationName?: ExecutionArgs['operationName'],
-      subscribeFieldResolver?: ExecutionArgs['subscribeFieldResolver'],
-    ];
-
-function toNormalizedArgs(args: BackwardsCompatibleArgs): ExecutionArgs {
-  const firstArg = args[0];
-  if (firstArg && 'document' in firstArg) {
-    return firstArg;
-  }
-
-  return {
-    schema: firstArg,
-    // FIXME: when underlying TS bug fixed, see https://github.com/microsoft/TypeScript/issues/31613
-    document: args[1] as DocumentNode,
-    rootValue: args[2],
-    contextValue: args[3],
-    variableValues: args[4],
-    operationName: args[5],
-    subscribeFieldResolver: args[6],
-  };
-}
-
 /**
  * Implements the "CreateSourceEventStream" algorithm described in the
  * GraphQL specification, resolving the subscription source event stream.
@@ -149,22 +113,7 @@ function toNormalizedArgs(args: BackwardsCompatibleArgs): ExecutionArgs {
  */
 export function createSourceEventStream(
   args: ExecutionArgs,
-): PromiseOrValue<AsyncIterable<unknown> | ExecutionResult>;
-/** @deprecated will be removed in next major version in favor of named arguments */
-export function createSourceEventStream(
-  schema: GraphQLSchema,
-  document: DocumentNode,
-  rootValue?: unknown,
-  contextValue?: unknown,
-  variableValues?: Maybe<{ readonly [variable: string]: unknown }>,
-  operationName?: Maybe<string>,
-  subscribeFieldResolver?: Maybe<GraphQLFieldResolver<any, any>>,
-): PromiseOrValue<AsyncIterable<unknown> | ExecutionResult>;
-export function createSourceEventStream(
-  ...rawArgs: BackwardsCompatibleArgs
 ): PromiseOrValue<AsyncIterable<unknown> | ExecutionResult> {
-  const args = toNormalizedArgs(rawArgs);
-
   const { schema, document, variableValues } = args;
 
   // If arguments are missing or incorrectly typed, this is an internal