graphql 17.0.0-beta.0 → 17.0.0-beta.2

package/execution/execute.js

@@ -13,237 +13,118 @@ exports.subscribe = subscribe;
 exports.createSourceEventStream = createSourceEventStream;
 exports.validateExecutionArgs = validateExecutionArgs;
 exports.validateSubscriptionArgs = validateSubscriptionArgs;
-exports.buildResolveInfo = buildResolveInfo;
-const inspect_js_1 = require("../jsutils/inspect.js");
-const isAsyncIterable_js_1 = require("../jsutils/isAsyncIterable.js");
-const isObjectLike_js_1 = require("../jsutils/isObjectLike.js");
-const isPromise_js_1 = require("../jsutils/isPromise.js");
-const Path_js_1 = require("../jsutils/Path.js");
-const ensureGraphQLError_js_1 = require("../error/ensureGraphQLError.js");
-const GraphQLError_js_1 = require("../error/GraphQLError.js");
-const locatedError_js_1 = require("../error/locatedError.js");
-const kinds_js_1 = require("../language/kinds.js");
-const predicates_js_1 = require("../language/predicates.js");
-const directives_js_1 = require("../type/directives.js");
-const index_js_1 = require("../type/index.js");
-const cancellablePromise_js_1 = require("./cancellablePromise.js");
-const collectFields_js_1 = require("./collectFields.js");
-const createSharedExecutionContext_js_1 = require("./createSharedExecutionContext.js");
-const Executor_js_1 = require("./Executor.js");
-const ExecutorThrowingOnIncremental_js_1 = require("./ExecutorThrowingOnIncremental.js");
-const getVariableSignature_js_1 = require("./getVariableSignature.js");
-const IncrementalExecutor_js_1 = require("./incremental/IncrementalExecutor.js");
-const mapAsyncIterable_js_1 = require("./mapAsyncIterable.js");
-const values_js_1 = require("./values.js");
+exports.mapSourceToResponseEvent = mapSourceToResponseEvent;
+const inspect_ts_1 = require("../jsutils/inspect.js");
+const isAsyncIterable_ts_1 = require("../jsutils/isAsyncIterable.js");
+const isObjectLike_ts_1 = require("../jsutils/isObjectLike.js");
+const isPromise_ts_1 = require("../jsutils/isPromise.js");
+const Path_ts_1 = require("../jsutils/Path.js");
+const ensureGraphQLError_ts_1 = require("../error/ensureGraphQLError.js");
+const GraphQLError_ts_1 = require("../error/GraphQLError.js");
+const locatedError_ts_1 = require("../error/locatedError.js");
+const kinds_ts_1 = require("../language/kinds.js");
+const predicates_ts_1 = require("../language/predicates.js");
+const directives_ts_1 = require("../type/directives.js");
+const index_ts_1 = require("../type/index.js");
+const buildResolveInfo_ts_1 = require("./buildResolveInfo.js");
+const cancellablePromise_ts_1 = require("./cancellablePromise.js");
+const collectFields_ts_1 = require("./collectFields.js");
+const createSharedExecutionContext_ts_1 = require("./createSharedExecutionContext.js");
+const Executor_ts_1 = require("./Executor.js");
+const ExecutorThrowingOnIncremental_ts_1 = require("./ExecutorThrowingOnIncremental.js");
+const getVariableSignature_ts_1 = require("./getVariableSignature.js");
+const IncrementalExecutor_ts_1 = require("./incremental/IncrementalExecutor.js");
+const mapAsyncIterable_ts_1 = require("./mapAsyncIterable.js");
+const values_ts_1 = require("./values.js");
 const UNEXPECTED_EXPERIMENTAL_DIRECTIVES = 'The provided schema unexpectedly contains experimental directives (@defer or @stream). These directives may only be utilized if experimental execution features are explicitly enabled.';
-/**
- * Implements the "Executing requests" section of the GraphQL specification.
- *
- * Returns either a synchronous ExecutionResult (if all encountered resolvers
- * are synchronous), or a Promise of an ExecutionResult that will eventually be
- * resolved and never rejected.
- *
- * If the arguments to this function do not result in a legal execution context,
- * a GraphQLError will be thrown immediately explaining the invalid input.
- *
- * This function does not support incremental delivery (`@defer` and `@stream`).
- * If an operation which would defer or stream data is executed with this
- * function, it will throw or return a rejected promise.
- * Use `experimentalExecuteIncrementally` if you want to support incremental
- * delivery.
- */
 function execute(args) {
     if (args.schema.getDirective('defer') || args.schema.getDirective('stream')) {
         throw new Error(UNEXPECTED_EXPERIMENTAL_DIRECTIVES);
     }
     const validatedExecutionArgs = validateExecutionArgs(args);
-    // Return early errors if execution context failed.
     if (!('schema' in validatedExecutionArgs)) {
         return { errors: validatedExecutionArgs };
     }
     return executeRootSelectionSet(validatedExecutionArgs);
 }
-/**
- * Implements the "Executing requests" section of the GraphQL specification,
- * including `@defer` and `@stream` as proposed in
- * https://github.com/graphql/graphql-spec/pull/742
- *
- * This function returns a Promise of an ExperimentalIncrementalExecutionResults
- * object. This object either consists of a single ExecutionResult, or an
- * object containing an `initialResult` and a stream of `subsequentResults`.
- *
- * If the arguments to this function do not result in a legal execution context,
- * a GraphQLError will be thrown immediately explaining the invalid input.
- */
 function experimentalExecuteIncrementally(args) {
-    // If a valid execution context cannot be created due to incorrect arguments,
-    // a "Response" with only errors is returned.
     const validatedExecutionArgs = validateExecutionArgs(args);
-    // Return early errors if execution context failed.
     if (!('schema' in validatedExecutionArgs)) {
         return { errors: validatedExecutionArgs };
     }
     return experimentalExecuteRootSelectionSet(validatedExecutionArgs);
 }
 function executeIgnoringIncremental(args) {
-    // If a valid execution context cannot be created due to incorrect arguments,
-    // a "Response" with only errors is returned.
     const validatedExecutionArgs = validateExecutionArgs(args);
-    // Return early errors if execution context failed.
     if (!('schema' in validatedExecutionArgs)) {
         return { errors: validatedExecutionArgs };
     }
     return executeRootSelectionSetIgnoringIncremental(validatedExecutionArgs);
 }
-/**
- * Implements the "Executing operations" section of the spec.
- *
- * Returns 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
- * field and its descendants will be omitted, and sibling fields will still
- * be executed. An execution which encounters errors will still result in a
- * resolved Promise.
- *
- * Errors from sub-fields of a NonNull type may propagate to the top level,
- * at which point we still log the error and null the parent field, which
- * in this case is the entire response.
- */
 function executeRootSelectionSet(validatedExecutionArgs) {
-    return new ExecutorThrowingOnIncremental_js_1.ExecutorThrowingOnIncremental(validatedExecutionArgs).executeRootSelectionSet();
+    return new ExecutorThrowingOnIncremental_ts_1.ExecutorThrowingOnIncremental(validatedExecutionArgs).executeRootSelectionSet();
 }
 function experimentalExecuteRootSelectionSet(validatedExecutionArgs) {
-    return new IncrementalExecutor_js_1.IncrementalExecutor(validatedExecutionArgs).executeRootSelectionSet();
+    return new IncrementalExecutor_ts_1.IncrementalExecutor(validatedExecutionArgs).executeRootSelectionSet();
 }
 function executeRootSelectionSetIgnoringIncremental(validatedExecutionArgs) {
-    return new Executor_js_1.Executor(validatedExecutionArgs).executeRootSelectionSet();
+    return new Executor_ts_1.Executor(validatedExecutionArgs).executeRootSelectionSet();
 }
-/**
- * Also implements the "Executing requests" section of the GraphQL specification.
- * However, it guarantees to complete synchronously (or throw an error) assuming
- * that all field resolvers are also synchronous.
- */
 function executeSync(args) {
     const result = experimentalExecuteIncrementally(args);
-    // Assert that the execution was synchronous.
-    if ((0, isPromise_js_1.isPromise)(result) || 'initialResult' in result) {
+    if ((0, isPromise_ts_1.isPromise)(result) || 'initialResult' in result) {
         throw new Error('GraphQL execution failed to complete synchronously.');
     }
     return result;
 }
 function executeSubscriptionEvent(validatedExecutionArgs) {
-    return new ExecutorThrowingOnIncremental_js_1.ExecutorThrowingOnIncremental(validatedExecutionArgs).executeRootSelectionSet(false);
+    return new ExecutorThrowingOnIncremental_ts_1.ExecutorThrowingOnIncremental(validatedExecutionArgs).executeRootSelectionSet(false);
 }
-/**
- * Implements the "Subscribe" algorithm described in the GraphQL specification.
- *
- * Returns a Promise which resolves to either an AsyncIterator (if successful)
- * or an ExecutionResult (error). The promise will be rejected if the schema or
- * other arguments to this function are invalid, or if the resolved event stream
- * is not an async iterable.
- *
- * If the client-provided arguments to this function do not result in a
- * compliant subscription, a GraphQL Response (ExecutionResult) with descriptive
- * errors and no data will be returned.
- *
- * If the source stream could not be created due to faulty subscription resolver
- * logic or underlying systems, the promise will resolve to a single
- * ExecutionResult containing `errors` and no `data`.
- *
- * If the operation succeeded, the promise resolves to an AsyncIterator, which
- * yields a stream of ExecutionResults representing the response stream.
- *
- * This function does not support incremental delivery (`@defer` and `@stream`).
- * If an operation which would defer or stream data is executed with this
- * function, a field error will be raised at the location of the `@defer` or
- * `@stream` directive.
- *
- * Accepts an object with named arguments.
- */
 function subscribe(args) {
-    // If a valid execution context cannot be created due to incorrect arguments,
-    // a "Response" with only errors is returned.
     const validatedExecutionArgs = validateSubscriptionArgs(args);
-    // Return early errors if execution context failed.
     if (!('schema' in validatedExecutionArgs)) {
         return { errors: validatedExecutionArgs };
     }
     const resultOrStream = createSourceEventStream(validatedExecutionArgs);
-    if ((0, isPromise_js_1.isPromise)(resultOrStream)) {
-        return resultOrStream.then((resolvedResultOrStream) => mapSourceToResponse(validatedExecutionArgs, resolvedResultOrStream));
+    if ((0, isPromise_ts_1.isPromise)(resultOrStream)) {
+        return resultOrStream.then((resolvedResultOrStream) => (0, isAsyncIterable_ts_1.isAsyncIterable)(resolvedResultOrStream)
+            ? mapSourceToResponseEvent(validatedExecutionArgs, resolvedResultOrStream)
+            : resolvedResultOrStream);
     }
-    return mapSourceToResponse(validatedExecutionArgs, resultOrStream);
+    return (0, isAsyncIterable_ts_1.isAsyncIterable)(resultOrStream)
+        ? mapSourceToResponseEvent(validatedExecutionArgs, resultOrStream)
+        : resultOrStream;
 }
-/**
- * Implements the "CreateSourceEventStream" algorithm described in the
- * GraphQL specification, resolving the subscription source event stream for a
- * previously validated subscription request.
- *
- * Returns a Promise which resolves to either an AsyncIterable (if successful)
- * or an ExecutionResult (error). The promise will be rejected if the validated
- * execution arguments are invalid, or if the resolved event stream is not an
- * async iterable.
- *
- * If the client-provided arguments to this function do not result in a
- * compliant subscription, a GraphQL Response (ExecutionResult) with
- * descriptive errors and no data will be returned.
- *
- * If the the source stream could not be created due to faulty subscription
- * resolver logic or underlying systems, the promise will resolve to a single
- * ExecutionResult containing `errors` and no `data`.
- *
- * If the operation succeeded, the promise resolves to the AsyncIterable for the
- * event stream returned by the resolver.
- *
- * A Source Event Stream represents a sequence of events, each of which triggers
- * a GraphQL execution for that event.
- *
- * This may be useful when hosting the stateful subscription service in a
- * different process or machine than the stateless GraphQL execution engine,
- * or otherwise separating these two steps. For more on this, see the
- * "Supporting Subscriptions at Scale" information in the GraphQL specification.
- */
 function createSourceEventStream(validatedExecutionArgs) {
     if (!('operation' in validatedExecutionArgs)) {
-        throw new GraphQLError_js_1.GraphQLError('Passing ExecutionArgs to createSourceEventStream() was removed in graphql-js@17.0.0; call validateSubscriptionArgs() first and pass the result instead, or use subscribe() for the full subscription pipeline.');
+        throw new GraphQLError_ts_1.GraphQLError('Passing ExecutionArgs to createSourceEventStream() was removed in graphql-js@17.0.0; call validateSubscriptionArgs() first and pass the result instead, or use subscribe() for the full subscription pipeline.');
     }
     try {
         const eventStream = executeSubscription(validatedExecutionArgs);
-        if ((0, isPromise_js_1.isPromise)(eventStream)) {
+        if ((0, isPromise_ts_1.isPromise)(eventStream)) {
             return eventStream.then(undefined, (error) => ({
-                errors: [(0, ensureGraphQLError_js_1.ensureGraphQLError)(error)],
+                errors: [(0, ensureGraphQLError_ts_1.ensureGraphQLError)(error)],
             }));
         }
         return eventStream;
     }
     catch (error) {
-        return { errors: [(0, ensureGraphQLError_js_1.ensureGraphQLError)(error)] };
+        return { errors: [(0, ensureGraphQLError_ts_1.ensureGraphQLError)(error)] };
     }
 }
-/**
- * Constructs a ExecutionContext object from the arguments passed to
- * execute, which we will pass throughout the other execution methods.
- *
- * Throws a GraphQLError if a valid execution context cannot be created.
- *
- * TODO: consider no longer exporting this function
- * @internal
- */
 function validateExecutionArgs(args) {
-    const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, perEventExecutor, abortSignal: externalAbortSignal, enableEarlyExecution, hooks, options, } = args;
-    // If the schema used for execution is invalid, throw an error.
-    (0, index_js_1.assertValidSchema)(schema);
+    const { schema, document, rootValue, contextValue, variableValues: rawVariableValues, operationName, fieldResolver, typeResolver, subscribeFieldResolver, abortSignal: externalAbortSignal, enableEarlyExecution, hooks, options, } = args;
+    (0, index_ts_1.assertValidSchema)(schema);
     let operation;
     const fragmentDefinitions = Object.create(null);
     const fragments = Object.create(null);
     for (const definition of document.definitions) {
         switch (definition.kind) {
-            case kinds_js_1.Kind.OPERATION_DEFINITION:
+            case kinds_ts_1.Kind.OPERATION_DEFINITION:
                 if (operationName == null) {
                     if (operation !== undefined) {
                         return [
-                            new GraphQLError_js_1.GraphQLError('Must provide operation name if query contains multiple operations.'),
+                            new GraphQLError_ts_1.GraphQLError('Must provide operation name if query contains multiple operations.'),
                         ];
                     }
                     operation = definition;
@@ -252,13 +133,13 @@ function validateExecutionArgs(args) {
                     operation = definition;
                 }
                 break;
-            case kinds_js_1.Kind.FRAGMENT_DEFINITION: {
+            case kinds_ts_1.Kind.FRAGMENT_DEFINITION: {
                 fragmentDefinitions[definition.name.value] = definition;
                 let variableSignatures;
                 if (definition.variableDefinitions) {
                     variableSignatures = Object.create(null);
                     for (const varDef of definition.variableDefinitions) {
-                        const signature = (0, getVariableSignature_js_1.getVariableSignature)(schema, varDef);
+                        const signature = (0, getVariableSignature_ts_1.getVariableSignature)(schema, varDef);
                         variableSignatures[signature.name] = signature;
                     }
                 }
@@ -266,25 +147,24 @@ function validateExecutionArgs(args) {
                 break;
             }
             default:
-            // ignore non-executable definitions
         }
     }
     if (!operation) {
         if (operationName != null) {
-            return [new GraphQLError_js_1.GraphQLError(`Unknown operation named "${operationName}".`)];
+            return [new GraphQLError_ts_1.GraphQLError(`Unknown operation named "${operationName}".`)];
         }
-        return [new GraphQLError_js_1.GraphQLError('Must provide an operation.')];
+        return [new GraphQLError_ts_1.GraphQLError('Must provide an operation.')];
     }
     const variableDefinitions = operation.variableDefinitions ?? [];
     const hideSuggestions = args.hideSuggestions ?? false;
-    const variableValuesOrErrors = (0, values_js_1.getVariableValues)(schema, variableDefinitions, rawVariableValues ?? {}, {
+    const variableValuesOrErrors = (0, values_ts_1.getVariableValues)(schema, variableDefinitions, rawVariableValues ?? {}, {
         maxErrors: options?.maxCoercionErrors ?? 50,
         hideSuggestions,
     });
     if (variableValuesOrErrors.errors) {
         return variableValuesOrErrors.errors;
     }
-    const errorPropagation = !operation.directives?.find((directive) => directive.name.value === directives_js_1.GraphQLDisableErrorPropagationDirective.name);
+    const errorPropagation = !operation.directives?.find((directive) => directive.name.value === directives_ts_1.GraphQLDisableErrorPropagationDirective.name);
     return {
         schema,
         fragmentDefinitions,
@@ -296,7 +176,6 @@ function validateExecutionArgs(args) {
         fieldResolver: fieldResolver ?? exports.defaultFieldResolver,
         typeResolver: typeResolver ?? exports.defaultTypeResolver,
         subscribeFieldResolver: subscribeFieldResolver ?? exports.defaultFieldResolver,
-        perEventExecutor: perEventExecutor ?? executeSubscriptionEvent,
         hideSuggestions,
         errorPropagation,
         externalAbortSignal: externalAbortSignal ?? undefined,
@@ -313,26 +192,14 @@ function validateSubscriptionArgs(args) {
     return validatedExecutionArgs;
 }
 function assertSubscriptionExecutionArgs(validatedExecutionArgs) {
-    if (!(0, predicates_js_1.isSubscriptionOperationDefinitionNode)(validatedExecutionArgs.operation)) {
-        throw new GraphQLError_js_1.GraphQLError('Expected subscription operation.');
+    if (!(0, predicates_ts_1.isSubscriptionOperationDefinitionNode)(validatedExecutionArgs.operation)) {
+        throw new GraphQLError_ts_1.GraphQLError('Expected subscription operation.');
     }
 }
-/**
- * If a resolveType function is not given, then a default resolve behavior is
- * used which attempts two strategies:
- *
- * First, See if the provided value has a `__typename` field defined, if so, use
- * that value as name of the resolved type.
- *
- * Otherwise, test each possible type for the abstract type by calling
- * isTypeOf for the object being coerced, returning the first type that matches.
- */
 const defaultTypeResolver = function (value, contextValue, info, abstractType) {
-    // First, look for `__typename`.
-    if ((0, isObjectLike_js_1.isObjectLike)(value) && typeof value.__typename === 'string') {
+    if ((0, isObjectLike_ts_1.isObjectLike)(value) && typeof value.__typename === 'string') {
         return value.__typename;
     }
-    // Otherwise, test each possible type.
     const possibleTypes = info.schema.getPossibleTypes(abstractType);
     const promisedIsTypeOfResults = [];
     try {
@@ -340,7 +207,7 @@ const defaultTypeResolver = function (value, contextValue, info, abstractType) {
             const type = possibleTypes[i];
             if (type.isTypeOf) {
                 const isTypeOfResult = type.isTypeOf(value, contextValue, info);
-                if ((0, isPromise_js_1.isPromiseLike)(isTypeOfResult)) {
+                if ((0, isPromise_ts_1.isPromiseLike)(isTypeOfResult)) {
                     promisedIsTypeOfResults[i] = isTypeOfResult;
                 }
                 else if (isTypeOfResult) {
@@ -372,15 +239,8 @@ const defaultTypeResolver = function (value, contextValue, info, abstractType) {
     }
 };
 exports.defaultTypeResolver = defaultTypeResolver;
-/**
- * If a resolve function is not given, then a default resolve behavior is used
- * which takes the property of the source object of the same name as the field
- * and returns it as the result, or if it's a function, returns the result
- * of calling that function while passing along args and context value.
- */
 const defaultFieldResolver = function (source, args, contextValue, info) {
-    // ensure source is a value for which property access is acceptable.
-    if ((0, isObjectLike_js_1.isObjectLike)(source) || typeof source === 'function') {
+    if ((0, isObjectLike_ts_1.isObjectLike)(source) || typeof source === 'function') {
         const property = source[info.fieldName];
         if (typeof property === 'function') {
             return source[info.fieldName](args, contextValue, info);
@@ -389,38 +249,31 @@ const defaultFieldResolver = function (source, args, contextValue, info) {
     }
 };
 exports.defaultFieldResolver = defaultFieldResolver;
-function mapSourceToResponse(validatedExecutionArgs, resultOrStream) {
-    if (!(0, isAsyncIterable_js_1.isAsyncIterable)(resultOrStream)) {
-        return resultOrStream;
-    }
-    // For each payload yielded from a subscription, map it over the normal
-    // GraphQL `execute` function, with `payload` as the rootValue.
-    // This implements the "MapSourceToResponseEvent" algorithm described in
-    // the GraphQL specification..
+function mapSourceToResponseEvent(validatedExecutionArgs, sourceEventStream, rootSelectionSetExecutor = executeSubscriptionEvent) {
     function mapFn(payload) {
         const perEventExecutionArgs = {
             ...validatedExecutionArgs,
             rootValue: payload,
         };
-        return validatedExecutionArgs.perEventExecutor(perEventExecutionArgs);
+        return rootSelectionSetExecutor(perEventExecutionArgs);
     }
     const externalAbortSignal = validatedExecutionArgs.externalAbortSignal;
     if (externalAbortSignal) {
-        const generator = (0, mapAsyncIterable_js_1.mapAsyncIterable)(resultOrStream, mapFn);
+        const generator = (0, mapAsyncIterable_ts_1.mapAsyncIterable)(sourceEventStream, mapFn);
         return {
             ...generator,
-            next: () => (0, cancellablePromise_js_1.cancellablePromise)(generator.next(), externalAbortSignal),
+            next: () => (0, cancellablePromise_ts_1.cancellablePromise)(generator.next(), externalAbortSignal),
         };
     }
-    return (0, mapAsyncIterable_js_1.mapAsyncIterable)(resultOrStream, mapFn);
+    return (0, mapAsyncIterable_ts_1.mapAsyncIterable)(sourceEventStream, mapFn);
 }
 function executeSubscription(validatedExecutionArgs) {
     const { schema, fragments, rootValue, contextValue, operation, variableValues, hideSuggestions, externalAbortSignal, } = validatedExecutionArgs;
     const rootType = schema.getSubscriptionType();
     if (rootType == null) {
-        throw new GraphQLError_js_1.GraphQLError('Schema is not configured to execute subscription operation.', { nodes: operation });
+        throw new GraphQLError_ts_1.GraphQLError('Schema is not configured to execute subscription operation.', { nodes: operation });
     }
-    const { groupedFieldSet } = (0, collectFields_js_1.collectFields)(schema, fragments, variableValues, rootType, operation.selectionSet, hideSuggestions);
+    const { groupedFieldSet } = (0, collectFields_ts_1.collectFields)(schema, fragments, variableValues, rootType, operation.selectionSet, hideSuggestions);
     const firstRootField = groupedFieldSet.entries().next().value;
     const [responseName, fieldDetailsList] = firstRootField;
     const firstFieldDetails = fieldDetailsList[0];
@@ -429,76 +282,42 @@ function executeSubscription(validatedExecutionArgs) {
     const fieldDef = schema.getField(rootType, fieldName);
     const fieldNodes = fieldDetailsList.map((fieldDetails) => fieldDetails.node);
     if (!fieldDef) {
-        throw new GraphQLError_js_1.GraphQLError(`The subscription field "${fieldName}" is not defined.`, { nodes: fieldNodes });
+        throw new GraphQLError_ts_1.GraphQLError(`The subscription field "${fieldName}" is not defined.`, { nodes: fieldNodes });
     }
-    const sharedExecutionContext = (0, createSharedExecutionContext_js_1.createSharedExecutionContext)(externalAbortSignal);
-    const path = (0, Path_js_1.addPath)(undefined, responseName, rootType.name);
-    const info = buildResolveInfo(validatedExecutionArgs, fieldDef, fieldNodes, rootType, path, sharedExecutionContext.getAbortSignal, sharedExecutionContext.getAsyncHelpers);
+    const sharedExecutionContext = (0, createSharedExecutionContext_ts_1.createSharedExecutionContext)(externalAbortSignal);
+    const path = (0, Path_ts_1.addPath)(undefined, responseName, rootType.name);
+    const info = (0, buildResolveInfo_ts_1.buildResolveInfo)(validatedExecutionArgs, fieldDef, fieldNodes, rootType, path, sharedExecutionContext.getAbortSignal, sharedExecutionContext.getAsyncHelpers);
     try {
-        // Implements the "ResolveFieldEventStream" algorithm from GraphQL specification.
-        // It differs from "ResolveFieldValue" due to providing a different `resolveFn`.
-        // Build a JS object of arguments from the field.arguments AST, using the
-        // variables scope to fulfill any variable references.
-        const args = (0, values_js_1.getArgumentValues)(fieldDef, firstNode, variableValues, firstFieldDetails.fragmentVariableValues, hideSuggestions);
-        // Call the `subscribe()` resolver or the default resolver to produce an
-        // AsyncIterable yielding raw payloads.
+        const args = (0, values_ts_1.getArgumentValues)(fieldDef, firstNode, variableValues, firstFieldDetails.fragmentVariableValues, hideSuggestions);
         const resolveFn = fieldDef.subscribe ?? validatedExecutionArgs.subscribeFieldResolver;
-        // The resolve function's optional third argument is a context value that
-        // is provided to every resolve function within an execution. It is commonly
-        // used to represent an authenticated user, or request-specific caches.
         const result = resolveFn(rootValue, args, contextValue, info);
-        if ((0, isPromise_js_1.isPromiseLike)(result)) {
+        if ((0, isPromise_ts_1.isPromiseLike)(result)) {
             const promisedResult = Promise.resolve(result);
             const promise = externalAbortSignal
-                ? (0, cancellablePromise_js_1.cancellablePromise)(promisedResult, externalAbortSignal)
+                ? (0, cancellablePromise_ts_1.cancellablePromise)(promisedResult, externalAbortSignal)
                 : promisedResult;
             return promise
                 .then(assertEventStream)
                 .then(undefined, (error) => {
-                throw (0, locatedError_js_1.locatedError)(error, toNodes(fieldDetailsList), (0, Path_js_1.pathToArray)(path));
+                throw (0, locatedError_ts_1.locatedError)(error, toNodes(fieldDetailsList), (0, Path_ts_1.pathToArray)(path));
             });
         }
         return assertEventStream(result);
     }
     catch (error) {
-        throw (0, locatedError_js_1.locatedError)(error, fieldNodes, (0, Path_js_1.pathToArray)(path));
+        throw (0, locatedError_ts_1.locatedError)(error, fieldNodes, (0, Path_ts_1.pathToArray)(path));
     }
 }
 function assertEventStream(result) {
     if (result instanceof Error) {
         throw result;
     }
-    // Assert field returned an event stream, otherwise yield an error.
-    if (!(0, isAsyncIterable_js_1.isAsyncIterable)(result)) {
-        throw new GraphQLError_js_1.GraphQLError('Subscription field must return Async Iterable. ' +
-            `Received: ${(0, inspect_js_1.inspect)(result)}.`);
+    if (!(0, isAsyncIterable_ts_1.isAsyncIterable)(result)) {
+        throw new GraphQLError_ts_1.GraphQLError('Subscription field must return Async Iterable. ' +
+            `Received: ${(0, inspect_ts_1.inspect)(result)}.`);
     }
     return result;
 }
-/**
- * TODO: consider no longer exporting this function
- * @internal
- */
-// eslint-disable-next-line max-params
-function buildResolveInfo(validatedExecutionArgs, fieldDef, fieldNodes, parentType, path, getAbortSignal, getAsyncHelpers) {
-    const { schema, fragmentDefinitions, rootValue, operation, variableValues } = validatedExecutionArgs;
-    // The resolve function's optional fourth argument is a collection of
-    // information about the current execution state.
-    return {
-        fieldName: fieldDef.name,
-        fieldNodes,
-        returnType: fieldDef.type,
-        parentType,
-        path,
-        schema,
-        fragments: fragmentDefinitions,
-        rootValue,
-        operation,
-        variableValues,
-        getAbortSignal,
-        getAsyncHelpers,
-    };
-}
 function toNodes(fieldDetailsList) {
     return fieldDetailsList.map((fieldDetails) => fieldDetails.node);
 }