graphql-jit 0.5.1 → 0.7.1

package/dist/execution.js

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPromiseInliner = exports.isPromise = exports.createBoundQuery = exports.isCompiledQuery = exports.compileQuery = exports.GLOBAL_VARIABLES_NAME = void 0;
+exports.isAsyncIterable = exports.isPromiseInliner = exports.isPromise = exports.createBoundQuery = exports.isCompiledQuery = exports.compileQuery = exports.GLOBAL_VARIABLES_NAME = void 0;
 const fast_json_stringify_1 = __importDefault(require("fast-json-stringify"));
 const generate_function_1 = __importDefault(require("generate-function"));
 const graphql_1 = require("graphql");
+const Path_1 = require("graphql/jsutils/Path");
 const ast_1 = require("./ast");
 const error_1 = require("./error");
 const inspect_1 = __importDefault(require("./inspect"));
@@ -14,7 +15,7 @@ const json_1 = require("./json");
 const non_null_1 = require("./non-null");
 const resolve_info_1 = require("./resolve-info");
 const variables_1 = require("./variables");
-const inspect = inspect_1.default();
+const inspect = (0, inspect_1.default)();
 // prefix for the variable used ot cache validation results
 const SAFETY_CHECK_PREFIX = "__validNode";
 const GLOBAL_DATA_NAME = "__context.data";
@@ -44,7 +45,7 @@ function compileQuery(schema, document, operationName, partialOptions) {
         throw new Error(`Expected ${schema} to be a GraphQL schema.`);
     }
     if (!document) {
-        throw new Error("Must provide document");
+        throw new Error("Must provide document.");
     }
     if (partialOptions &&
         partialOptions.resolverInfoEnricher &&
@@ -58,24 +59,34 @@ function compileQuery(schema, document, operationName, partialOptions) {
         const context = buildCompilationContext(schema, document, options, operationName);
         let stringify;
         if (options.customJSONSerializer) {
-            const jsonSchema = json_1.queryToJSONSchema(context);
-            stringify = fast_json_stringify_1.default(jsonSchema);
+            const jsonSchema = (0, json_1.queryToJSONSchema)(context);
+            stringify = (0, fast_json_stringify_1.default)(jsonSchema);
         }
         else {
             stringify = JSON.stringify;
         }
-        const getVariables = variables_1.compileVariableParsing(schema, context.operation.variableDefinitions || []);
-        const functionBody = compileOperation(context);
+        const getVariables = (0, variables_1.compileVariableParsing)(schema, context.operation.variableDefinitions || []);
+        const type = (0, graphql_1.getOperationRootType)(context.schema, context.operation);
+        const fieldMap = (0, ast_1.collectFields)(context, type, context.operation.selectionSet, Object.create(null), Object.create(null));
+        const functionBody = compileOperation(context, type, fieldMap);
         const compiledQuery = {
-            query: createBoundQuery(context, document, new Function("return " + functionBody)(), getVariables, context.operation.name != null
+            query: createBoundQuery(context, document, 
+            // eslint-disable-next-line no-new-func
+            new Function("return " + functionBody)(), getVariables, context.operation.name != null
                 ? context.operation.name.value
                 : undefined),
             stringify
         };
+        if (context.operation.operation === "subscription") {
+            compiledQuery.subscribe = createBoundSubscribe(context, document, compileSubscriptionOperation(context, type, fieldMap, compiledQuery.query), getVariables, context.operation.name != null
+                ? context.operation.name.value
+                : undefined);
+        }
         if (options.debug) {
             // result of the compilation useful for debugging issues
             // and visualization tools like try-jit.
-            compiledQuery.__DO_NOT_USE_THIS_OR_YOU_WILL_BE_FIRED_compilation = functionBody;
+            compiledQuery.__DO_NOT_USE_THIS_OR_YOU_WILL_BE_FIRED_compilation =
+                functionBody;
         }
         return compiledQuery;
     }
@@ -93,9 +104,9 @@ exports.isCompiledQuery = isCompiledQuery;
 // Exported only for an error test
 function createBoundQuery(compilationContext, document, func, getVariableValues, operationName) {
     const { resolvers, typeResolvers, isTypeOfs, serializers, resolveInfos } = compilationContext;
-    const trimmer = non_null_1.createNullTrimmer(compilationContext);
-    const fnName = operationName ? operationName : "query";
-    /* tslint:disable */
+    const trimmer = (0, non_null_1.createNullTrimmer)(compilationContext);
+    const fnName = operationName || "query";
+    /* eslint-disable */
     /**
      * In-order to assign a debuggable name to the bound query function,
      * we create an intermediate object with a method named as the
@@ -106,13 +117,13 @@ function createBoundQuery(compilationContext, document, func, getVariableValues,
      *
      * section: 14.3.9.3 - calls SetFunctionName
      */
-    /* tslint:enable */
+    /* eslint-enable */
     const ret = {
         [fnName](rootValue, context, variables) {
             // this can be shared across in a batch request
             const parsedVariables = getVariableValues(variables || {});
             // Return early errors if variable coercing failed.
-            if (variables_1.failToParseVariables(parsedVariables)) {
+            if ((0, variables_1.failToParseVariables)(parsedVariables)) {
                 return { errors: parsedVariables.errors };
             }
             const executionContext = {
@@ -133,6 +144,7 @@ function createBoundQuery(compilationContext, document, func, getVariableValues,
                 nullErrors: [],
                 errors: []
             };
+            // eslint-disable-next-line no-useless-call
             const result = func.call(null, executionContext);
             if (isPromise(result)) {
                 return result.then(postProcessResult);
@@ -170,10 +182,8 @@ function postProcessResult({ data, nullErrors, errors, trimmer }) {
  * @param {CompilationContext} context compilation context with the execution context
  * @returns {string} a function body to be instantiated together with the header, footer
  */
-function compileOperation(context) {
-    const type = graphql_1.getOperationRootType(context.schema, context.operation);
+function compileOperation(context, type, fieldMap) {
     const serialExecution = context.operation.operation === "mutation";
-    const fieldMap = ast_1.collectFields(context, type, context.operation.selectionSet, Object.create(null), Object.create(null));
     const topLevel = compileObjectType(context, type, [], [GLOBAL_ROOT_NAME], [GLOBAL_DATA_NAME], undefined, GLOBAL_ERRORS_NAME, fieldMap, true);
     let body = `function query (${GLOBAL_EXECUTION_CONTEXT}) {
   "use strict";
@@ -289,14 +299,14 @@ function compileDeferredField(context, deferredField, appendix) {
       ${generateUniqueDeclarations(subContext)}
       ${GLOBAL_PARENT_NAME}.${name} = ${nodeBody};
       ${compileDeferredFields(subContext)}
-      ${appendix ? appendix : ""}
+      ${appendix || ""}
     }
   `);
     return body;
 }
 function compileDeferredFieldsSerially(context) {
     let body = "";
-    context.deferred.forEach(deferredField => {
+    context.deferred.forEach((deferredField) => {
         const { name, fieldName, parentType } = deferredField;
         const resolverName = getResolverName(parentType.name, fieldName);
         const mutationHandler = getHoistedFunctionName(context, `${name}${resolverName}Mutation`);
@@ -331,7 +341,7 @@ function compileType(context, parentType, type, fieldNodes, originPaths, destina
     const sourcePath = originPaths.join(".");
     let body = `${sourcePath} == null ? `;
     let errorDestination;
-    if (graphql_1.isNonNullType(type)) {
+    if ((0, graphql_1.isNonNullType)(type)) {
         type = type.ofType;
         const nullErrorStr = `"Cannot return null for non-nullable field ${parentType.name}.${getFieldNodesName(fieldNodes)}."`;
         body += `(${GLOBAL_NULL_ERRORS_NAME}.push(${createErrorObject(context, fieldNodes, previousPath, nullErrorStr)}), null) :`;
@@ -345,17 +355,17 @@ function compileType(context, parentType, type, fieldNodes, originPaths, destina
     // value can be an error obj
     const errorPath = `${sourcePath}.message != null ? ${sourcePath}.message : ${sourcePath}`;
     body += `${sourcePath} instanceof Error ? (${errorDestination}.push(${createErrorObject(context, fieldNodes, previousPath, errorPath, sourcePath)}), null) : `;
-    if (graphql_1.isLeafType(type)) {
+    if ((0, graphql_1.isLeafType)(type)) {
         body += compileLeafType(context, type, originPaths, fieldNodes, previousPath, errorDestination);
     }
-    else if (graphql_1.isObjectType(type)) {
-        const fieldMap = ast_1.collectSubfields(context, type, fieldNodes);
+    else if ((0, graphql_1.isObjectType)(type)) {
+        const fieldMap = (0, ast_1.collectSubfields)(context, type, fieldNodes);
         body += compileObjectType(context, type, fieldNodes, originPaths, destinationPaths, previousPath, errorDestination, fieldMap, false);
     }
-    else if (graphql_1.isAbstractType(type)) {
+    else if ((0, graphql_1.isAbstractType)(type)) {
         body += compileAbstractType(context, parentType, type, fieldNodes, originPaths, previousPath, errorDestination);
     }
-    else if (graphql_1.isListType(type)) {
+    else if ((0, graphql_1.isListType)(type)) {
         body += compileListType(context, parentType, type, fieldNodes, originPaths, previousPath, errorDestination);
     }
     else {
@@ -368,7 +378,7 @@ function compileType(context, parentType, type, fieldNodes, originPaths, destina
 function compileLeafType(context, type, originPaths, fieldNodes, previousPath, errorDestination) {
     let body = "";
     if (context.options.disableLeafSerialization &&
-        (type instanceof graphql_1.GraphQLEnumType || graphql_1.isSpecifiedScalarType(type))) {
+        (type instanceof graphql_1.GraphQLEnumType || (0, graphql_1.isSpecifiedScalarType)(type))) {
         body += `${originPaths.join(".")}`;
     }
     else {
@@ -398,7 +408,7 @@ function compileLeafType(context, type, originPaths, fieldNodes, previousPath, e
  * @returns {string}
  */
 function compileObjectType(context, type, fieldNodes, originPaths, destinationPaths, responsePath, errorDestination, fieldMap, alwaysDefer) {
-    const body = generate_function_1.default();
+    const body = (0, generate_function_1.default)();
     // Begin object compilation paren
     body("(");
     if (typeof type.isTypeOf === "function" && !alwaysDefer) {
@@ -409,7 +419,7 @@ function compileObjectType(context, type, fieldNodes, originPaths, destinationPa
     body("{");
     for (const name of Object.keys(fieldMap)) {
         const fieldNodes = fieldMap[name];
-        const field = ast_1.resolveFieldDef(context, type, fieldNodes);
+        const field = (0, ast_1.resolveFieldDef)(context, type, fieldNodes);
         if (!field) {
             // Field is invalid, should have been caught in validation
             // but the error is swallowed for compatibility reasons.
@@ -444,8 +454,8 @@ function compileObjectType(context, type, fieldNodes, originPaths, destinationPa
         body(`
       (
         ${fieldNodes
-            .map(it => it.__internalShouldInclude)
-            .filter(it => it)
+            .map((it) => it.__internalShouldInclude)
+            .filter((it) => it)
             .join(" || ") || /* if(true) - default */ "true"}
       )
     `);
@@ -460,12 +470,12 @@ function compileObjectType(context, type, fieldNodes, originPaths, destinationPa
         let resolver = field.resolve;
         if (!resolver && alwaysDefer) {
             const fieldName = field.name;
-            resolver = parent => parent && parent[fieldName];
+            resolver = (parent) => parent && parent[fieldName];
         }
         if (resolver) {
             context.deferred.push({
                 name,
-                responsePath: ast_1.addPath(responsePath, name),
+                responsePath: (0, ast_1.addPath)(responsePath, name),
                 originPaths,
                 destinationPaths,
                 parentType: type,
@@ -473,7 +483,7 @@ function compileObjectType(context, type, fieldNodes, originPaths, destinationPa
                 jsFieldName: getJsFieldName(field.name),
                 fieldType: field.type,
                 fieldNodes,
-                args: ast_1.getArgumentDefs(field, fieldNodes[0])
+                args: (0, ast_1.getArgumentDefs)(field, fieldNodes[0])
             });
             context.resolvers[getResolverName(type.name, field.name)] = resolver;
             body(`
@@ -490,7 +500,7 @@ function compileObjectType(context, type, fieldNodes, originPaths, destinationPa
         else {
             // if included
             body("?");
-            body(compileType(context, type, field.type, fieldNodes, originPaths.concat(field.name), destinationPaths.concat(name), ast_1.addPath(responsePath, name)));
+            body(compileType(context, type, field.type, fieldNodes, originPaths.concat(field.name), destinationPaths.concat(name), (0, ast_1.addPath)(responsePath, name)));
             // if not included
             body(": undefined");
         }
@@ -515,9 +525,9 @@ function compileAbstractType(context, parentType, type, fieldNodes, originPaths,
     context.typeResolvers[typeResolverName] = resolveType;
     const collectedTypes = context.schema
         .getPossibleTypes(type)
-        .map(objectType => {
+        .map((objectType) => {
         const subContext = createSubCompilationContext(context);
-        const object = compileType(subContext, parentType, objectType, fieldNodes, originPaths, ["__concrete"], ast_1.addPath(previousPath, objectType.name, "meta"));
+        const object = compileType(subContext, parentType, objectType, fieldNodes, originPaths, ["__concrete"], (0, ast_1.addPath)(previousPath, objectType.name, "meta"));
         return `case "${objectType.name}": {
                   ${generateUniqueDeclarations(subContext)}
                   const __concrete = ${object};
@@ -528,12 +538,14 @@ function compileAbstractType(context, parentType, type, fieldNodes, originPaths,
         .join("\n");
     const finalTypeName = "finalType";
     const nullTypeError = `"Runtime Object type is not a possible type for \\"${type.name}\\"."`;
-    // tslint:disable:max-line-length
-    const notPossibleTypeError = '`Runtime Object type "${nodeType}" is not a possible type for "' +
+    /* eslint-disable max-len */
+    const notPossibleTypeError = 
+    // eslint-disable-next-line no-template-curly-in-string
+    '`Runtime Object type "${nodeType}" is not a possible type for "' +
         type.name +
         '".`';
     const noTypeError = `${finalTypeName} ? ${notPossibleTypeError} : "Abstract type ${type.name} must resolve to an Object type at runtime for field ${parentType.name}.${getFieldNodesName(fieldNodes)}. Either the ${type.name} type should provide a \\"resolveType\\" function or each possible types should provide an \\"isTypeOf\\" function."`;
-    // tslint:enable:max-line-length
+    /* eslint-enable max-len */
     return `((nodeType, err) =>
   {
     if (err != null) {
@@ -574,10 +586,10 @@ function compileListType(context, parentType, type, fieldNodes, originalObjectPa
     // context depth will be mutated, so we cache the current value.
     const newDepth = ++listContext.depth;
     const fieldType = type.ofType;
-    const dataBody = compileType(listContext, parentType, fieldType, fieldNodes, ["__currentItem"], [`${GLOBAL_PARENT_NAME}[idx${newDepth}]`], ast_1.addPath(responsePath, "idx" + newDepth, "variable"));
+    const dataBody = compileType(listContext, parentType, fieldType, fieldNodes, ["__currentItem"], [`${GLOBAL_PARENT_NAME}[idx${newDepth}]`], (0, ast_1.addPath)(responsePath, "idx" + newDepth, "variable"));
     const errorMessage = `"Expected Iterable, but did not find one for field ${parentType.name}.${getFieldNodesName(fieldNodes)}."`;
     const errorCase = `(${errorDestination}.push(${createErrorObject(context, fieldNodes, responsePath, errorMessage)}), null)`;
-    const executionError = createErrorObject(context, fieldNodes, ast_1.addPath(responsePath, "idx" + newDepth, "variable"), "err.message != null ? err.message : err", "err");
+    const executionError = createErrorObject(context, fieldNodes, (0, ast_1.addPath)(responsePath, "idx" + newDepth, "variable"), "err.message != null ? err.message : err", "err");
     const emptyError = createErrorObject(context, fieldNodes, responsePath, '""');
     const uniqueDeclarations = generateUniqueDeclarations(listContext);
     const deferredFields = compileDeferredFields(listContext);
@@ -671,7 +683,7 @@ function objectStringify(val) {
 function getExecutionInfo(context, parentType, fieldType, fieldName, fieldNodes, responsePath) {
     const resolveInfoName = createResolveInfoName(responsePath);
     const { schema, fragments, operation } = context;
-    context.resolveInfos[resolveInfoName] = resolve_info_1.createResolveInfoThunk({
+    context.resolveInfos[resolveInfoName] = (0, resolve_info_1.createResolveInfoThunk)({
         schema,
         fragments,
         operation,
@@ -693,7 +705,7 @@ function objectPath(topLevel, path) {
         return topLevel;
     }
     let objectPath = topLevel;
-    const flattened = ast_1.flattenPath(path);
+    const flattened = (0, ast_1.flattenPath)(path);
     for (const section of flattened) {
         if (section.type === "literal") {
             objectPath += `["${section.key}"]`;
@@ -725,8 +737,8 @@ function compileArguments(context, args, topLevelArg, validArgs, returnType, pat
     for (const variable of args.missing) {
         const varName = variable.valueNode.name.value;
         body += `if (Object.prototype.hasOwnProperty.call(${exports.GLOBAL_VARIABLES_NAME}, "${varName}")) {`;
-        if (variable.argument && graphql_1.isNonNullType(variable.argument.definition.type)) {
-            const message = `'Argument "${variable.argument.definition.name}" of non-null type "${inspect(variable.argument.definition.type)}" must not be null.'`;
+        if (variable.argument && (0, graphql_1.isNonNullType)(variable.argument.definition.type)) {
+            const message = `'Argument "${variable.argument.definition.name}" of non-null type "${variable.argument.definition.type.toString()}" must not be null.'`;
             body += `if (${exports.GLOBAL_VARIABLES_NAME}['${variable.valueNode.name.value}'] == null) {
       ${errorDestination}.push(${createErrorObject(context, [variable.argument.node.value], path, message)});
       ${validArgs} = false;
@@ -738,9 +750,9 @@ function compileArguments(context, args, topLevelArg, validArgs, returnType, pat
         // If there is no default value and no variable input
         // throw a field error
         if (variable.argument &&
-            graphql_1.isNonNullType(variable.argument.definition.type) &&
+            (0, graphql_1.isNonNullType)(variable.argument.definition.type) &&
             variable.argument.definition.defaultValue === undefined) {
-            const message = `'Argument "${variable.argument.definition.name}" of required type "${inspect(variable.argument.definition.type)}" was provided the variable "$${varName}" which was not provided a runtime value.'`;
+            const message = `'Argument "${variable.argument.definition.name}" of required type "${variable.argument.definition.type.toString()}" was provided the variable "$${varName}" which was not provided a runtime value.'`;
             body += ` else {
       ${errorDestination}.push(${createErrorObject(context, [variable.argument.node.value], path, message)});
       ${validArgs} = false;
@@ -786,7 +798,7 @@ exports.isPromiseInliner = isPromiseInliner;
  * @returns {string} filtered serialization of the response path
  */
 function serializeResponsePathAsArray(path) {
-    const flattened = ast_1.flattenPath(path);
+    const flattened = (0, ast_1.flattenPath)(path);
     let src = "[";
     for (let i = flattened.length - 1; i >= 0; i--) {
         // meta is only used for the function name
@@ -801,11 +813,11 @@ function serializeResponsePathAsArray(path) {
     return src + "]";
 }
 function getErrorDestination(type) {
-    return graphql_1.isNonNullType(type) ? GLOBAL_NULL_ERRORS_NAME : GLOBAL_ERRORS_NAME;
+    return (0, graphql_1.isNonNullType)(type) ? GLOBAL_NULL_ERRORS_NAME : GLOBAL_ERRORS_NAME;
 }
 function createResolveInfoName(path) {
-    return (ast_1.flattenPath(path)
-        .map(p => p.key)
+    return ((0, ast_1.flattenPath)(path)
+        .map((p) => p.key)
         .join("_") + "Info");
 }
 /**
@@ -835,9 +847,7 @@ function serializeResponsePath(path) {
  */
 function getSerializer(scalar, customSerializer) {
     const { name } = scalar;
-    const serialize = customSerializer
-        ? customSerializer
-        : (val) => scalar.serialize(val);
+    const serialize = customSerializer || ((val) => scalar.serialize(val));
     return function leafSerializer(context, v, onError, ...idx) {
         try {
             const value = serialize(v);
@@ -862,7 +872,7 @@ function getSerializer(scalar, customSerializer) {
  * @param contextValue
  * @param {GraphQLResolveInfo} info
  * @param {GraphQLAbstractType} abstractType
- * @returns {string | GraphQLObjectType}
+ * @returns {string}
  */
 function defaultResolveTypeFn(value, contextValue, info, abstractType) {
     // First, look for `__typename`.
@@ -880,7 +890,7 @@ function defaultResolveTypeFn(value, contextValue, info, abstractType) {
                 throw new Error(`Promises are not supported for resolving type of ${value}`);
             }
             else if (isTypeOfResult) {
-                return type;
+                return type.name;
             }
         }
     }
@@ -941,8 +951,7 @@ function buildCompilationContext(schema, document, options, operationName) {
         deferred: [],
         depth: -1,
         variableValues: {},
-        fieldResolver: undefined,
-        errors: errors
+        errors
     };
 }
 function getFieldNodesName(nodes) {
@@ -961,9 +970,9 @@ function getHoistedFunctionName(context, name) {
 }
 function createErrorObject(context, nodes, path, message, originalError) {
     return `new ${GRAPHQL_ERROR}(${message},
-    ${JSON.stringify(ast_1.computeLocations(nodes))},
+    ${JSON.stringify((0, ast_1.computeLocations)(nodes))},
       ${serializeResponsePathAsArray(path)},
-      ${originalError ? originalError : "undefined"},
+      ${originalError || "undefined"},
       ${context.options.disablingCapturingStackErrors ? "true" : "false"})`;
 }
 function getResolverName(parentName, name) {
@@ -991,7 +1000,7 @@ function promiseDone() {
 }
 function normalizeErrors(err) {
     if (Array.isArray(err)) {
-        return err.map(e => normalizeError(e));
+        return err.map((e) => normalizeError(e));
     }
     return [normalizeError(err)];
 }
@@ -1004,6 +1013,7 @@ function normalizeError(err) {
  * Returns true if a value is undefined, or NaN.
  */
 function isInvalid(value) {
+    // eslint-disable-next-line no-self-compare
     return value === undefined || value !== value;
 }
 function getParentArgIndexes(context) {
@@ -1019,4 +1029,147 @@ function getParentArgIndexes(context) {
 function getJsFieldName(fieldName) {
     return `${LOCAL_JS_FIELD_NAME_PREFIX}${fieldName}`;
 }
+function isAsyncIterable(val) {
+    return typeof Object(val)[Symbol.asyncIterator] === "function";
+}
+exports.isAsyncIterable = isAsyncIterable;
+function compileSubscriptionOperation(context, type, fieldMap, queryFn) {
+    const fieldNodes = Object.values(fieldMap)[0];
+    const fieldNode = fieldNodes[0];
+    const fieldName = fieldNode.name.value;
+    const field = (0, ast_1.resolveFieldDef)(context, type, fieldNodes);
+    if (!field) {
+        throw new graphql_1.GraphQLError(`The subscription field "${fieldName}" is not defined.`, fieldNodes);
+    }
+    const responsePath = (0, ast_1.addPath)(undefined, fieldName);
+    const resolveInfoName = createResolveInfoName(responsePath);
+    const subscriber = field.subscribe;
+    async function executeSubscription(executionContext) {
+        const resolveInfo = executionContext.resolveInfos[resolveInfoName](executionContext.rootValue, executionContext.variables, responsePath);
+        try {
+            const eventStream = await (subscriber === null || subscriber === void 0 ? void 0 : subscriber(executionContext.rootValue, executionContext.variables, executionContext.context, resolveInfo));
+            if (eventStream instanceof Error) {
+                throw eventStream;
+            }
+            return eventStream;
+        }
+        catch (error) {
+            throw (0, graphql_1.locatedError)(error, resolveInfo.fieldNodes, (0, Path_1.pathToArray)(resolveInfo.path));
+        }
+    }
+    async function createSourceEventStream(executionContext) {
+        try {
+            const eventStream = await executeSubscription(executionContext);
+            // Assert field returned an event stream, otherwise yield an error.
+            if (!isAsyncIterable(eventStream)) {
+                throw new Error("Subscription field must return Async Iterable. " +
+                    `Received: ${inspect(eventStream)}.`);
+            }
+            return eventStream;
+        }
+        catch (error) {
+            // If it is a GraphQLError, report it as an ExecutionResult, containing only errors and no data.
+            // Otherwise treat the error as a system-class error and re-throw it.
+            if (error instanceof graphql_1.GraphQLError) {
+                return { errors: [error] };
+            }
+            throw error;
+        }
+    }
+    return async function subscribe(executionContext) {
+        const resultOrStream = await createSourceEventStream(executionContext);
+        if (!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. The `execute` function provides the
+        // "ExecuteSubscriptionEvent" algorithm, as it is nearly identical to the
+        // "ExecuteQuery" algorithm, for which `execute` is also used.
+        // We use our `query` function in place of `execute`
+        const mapSourceToResponse = (payload) => queryFn(payload, executionContext.context, executionContext.variables);
+        return mapAsyncIterator(resultOrStream, mapSourceToResponse);
+    };
+}
+function createBoundSubscribe(compilationContext, document, func, getVariableValues, operationName) {
+    const { resolvers, typeResolvers, isTypeOfs, serializers, resolveInfos } = compilationContext;
+    const trimmer = (0, non_null_1.createNullTrimmer)(compilationContext);
+    const fnName = operationName || "subscribe";
+    const ret = {
+        async [fnName](rootValue, context, variables) {
+            // this can be shared across in a batch request
+            const parsedVariables = getVariableValues(variables || {});
+            // Return early errors if variable coercing failed.
+            if ((0, variables_1.failToParseVariables)(parsedVariables)) {
+                return { errors: parsedVariables.errors };
+            }
+            const executionContext = {
+                rootValue,
+                context,
+                variables: parsedVariables.coerced,
+                safeMap,
+                inspect,
+                GraphQLError: error_1.GraphQLError,
+                resolvers,
+                typeResolvers,
+                isTypeOfs,
+                serializers,
+                resolveInfos,
+                trimmer,
+                promiseCounter: 0,
+                nullErrors: [],
+                errors: [],
+                data: {}
+            };
+            // eslint-disable-next-line no-useless-call
+            return func.call(null, executionContext);
+        }
+    };
+    return ret[fnName];
+}
+/**
+ * Given an AsyncIterable and a callback function, return an AsyncIterator
+ * which produces values mapped via calling the callback function.
+ */
+function mapAsyncIterator(iterable, callback) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    async function mapResult(result) {
+        if (result.done) {
+            return result;
+        }
+        try {
+            return { value: await callback(result.value), done: false };
+        }
+        catch (error) {
+            if (typeof iterator.return === "function") {
+                try {
+                    await iterator.return();
+                }
+                catch (e) {
+                    /* ignore error */
+                }
+            }
+            throw error;
+        }
+    }
+    return {
+        async next() {
+            return mapResult(await iterator.next());
+        },
+        async return() {
+            return typeof iterator.return === "function"
+                ? mapResult(await iterator.return())
+                : { value: undefined, done: true };
+        },
+        async throw(error) {
+            return typeof iterator.throw === "function"
+                ? mapResult(await iterator.throw(error))
+                : Promise.reject(error);
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        }
+    };
+}
 //# sourceMappingURL=execution.js.map