@pome-sh/cli 0.20.0 → 0.21.0

package/node_modules/graphql/execution/execute.js

@@ -1,1295 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true,
-});
-exports.assertValidExecutionArguments = assertValidExecutionArguments;
-exports.buildExecutionContext = buildExecutionContext;
-exports.buildResolveInfo = buildResolveInfo;
-exports.defaultTypeResolver = exports.defaultFieldResolver = void 0;
-exports.execute = execute;
-exports.executeSync = executeSync;
-exports.getFieldDef = getFieldDef;
-
-var _devAssert = require('../jsutils/devAssert.js');
-
-var _inspect = require('../jsutils/inspect.js');
-
-var _invariant = require('../jsutils/invariant.js');
-
-var _isIterableObject = require('../jsutils/isIterableObject.js');
-
-var _isObjectLike = require('../jsutils/isObjectLike.js');
-
-var _isPromise = require('../jsutils/isPromise.js');
-
-var _memoize = require('../jsutils/memoize3.js');
-
-var _Path = require('../jsutils/Path.js');
-
-var _promiseForObject = require('../jsutils/promiseForObject.js');
-
-var _promiseReduce = require('../jsutils/promiseReduce.js');
-
-var _GraphQLError = require('../error/GraphQLError.js');
-
-var _locatedError = require('../error/locatedError.js');
-
-var _ast = require('../language/ast.js');
-
-var _kinds = require('../language/kinds.js');
-
-var _definition = require('../type/definition.js');
-
-var _introspection = require('../type/introspection.js');
-
-var _validate = require('../type/validate.js');
-
-var _collectFields = require('./collectFields.js');
-
-var _values = require('./values.js');
-
-/** @category Execution */
-
-/**
- * A memoized collection of relevant subfields with regard to the return
- * type. Memoizing ensures the subfields are not repeatedly calculated, which
- * saves overhead when resolving lists of values.
- *
- * @internal
- */
-const collectSubfields = (0, _memoize.memoize3)(
-  (exeContext, returnType, fieldNodes) =>
-    (0, _collectFields.collectSubfields)(
-      exeContext.schema,
-      exeContext.fragments,
-      exeContext.variableValues,
-      returnType,
-      fieldNodes,
-    ),
-);
-/**
- * Terminology
- *
- * "Definitions" are the generic name for top-level statements in the document.
- * Examples of this include:
- * 1) Operations (such as a query)
- * 2) Fragments
- *
- * "Operations" are a generic name for requests in the document.
- * Examples of this include:
- * 1) query,
- * 2) mutation
- *
- * "Selections" are the definitions that can appear legally and at
- * single level of the query. These include:
- * 1) field references e.g `a`
- * 2) fragment "spreads" e.g. `...c`
- * 3) inline fragment "spreads" e.g. `...on Type { a }`
- */
-
-/**
- * Data that must be available at all points during query execution.
- *
- * Namely, schema of the type system that is currently executing,
- * and the fragments defined in the query document
- *
- * @internal
- */
-
-class CollectedErrors {
-  constructor() {
-    this._errorPositions = new Set();
-    this._errors = [];
-  }
-
-  get errors() {
-    return this._errors;
-  }
-
-  add(error, path) {
-    // Do not modify errors list if the execution position for this error or
-    // any of its ancestors has already been nulled via error propagation.
-    // This check should be unnecessary for implementations able to implement
-    // actual cancellation.
-    if (this._hasNulledPosition(path)) {
-      return;
-    }
-
-    this._errorPositions.add(path);
-
-    this._errors.push(error);
-  }
-
-  _hasNulledPosition(startPath) {
-    let path = startPath;
-
-    while (path !== undefined) {
-      if (this._errorPositions.has(path)) {
-        return true;
-      }
-
-      path = path.prev;
-    }
-
-    return this._errorPositions.has(undefined);
-  }
-}
-/**
- * Represents the response produced by executing a GraphQL operation.
- * @typeParam TData - Shape of the execution data payload.
- * @typeParam TExtensions - Shape of the extensions payload.
- */
-
-/**
- * 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.
- *
- * Field errors are collected into the response instead of rejecting the
- * returned promise. Only the field that produced the error and its descendants
- * are omitted; sibling fields continue to execute. Errors from fields of
- * non-null type may propagate to the nearest nullable parent, which can be the
- * entire response data.
- * @param args - The arguments used to perform the operation.
- * @returns A completed execution result, or a promise resolving to one when execution is asynchronous.
- * @example
- * ```ts
- * // Execute an asynchronous operation with variables.
- * import { parse } from 'graphql/language';
- * import { buildSchema } from 'graphql/utilities';
- * import { execute } from 'graphql/execution';
- *
- * const schema = buildSchema(`
- *   type Query {
- *     greeting(name: String!): String
- *   }
- * `);
- *
- * const result = await execute({
- *   schema,
- *   document: parse('query ($name: String!) { greeting(name: $name) }'),
- *   rootValue: {
- *     greeting: ({ name }) => `Hello, ${name}!`,
- *   },
- *   variableValues: { name: 'Ada' },
- * });
- *
- * result; // => { data: { greeting: 'Hello, Ada!' } }
- * ```
- * @example
- * ```ts
- * // This variant supplies context plus custom field and type resolvers.
- * import { parse } from 'graphql/language';
- * import { buildSchema } from 'graphql/utilities';
- * import { execute } from 'graphql/execution';
- *
- * const schema = buildSchema(`
- *   interface Named {
- *     name: String!
- *   }
- *
- *   type User implements Named {
- *     name: String!
- *   }
- *
- *   type Query {
- *     viewer: Named
- *   }
- * `);
- *
- * const result = await execute({
- *   schema,
- *   document: parse('query Viewer { viewer { __typename name } }'),
- *   rootValue: { viewer: { kind: 'user', name: 'Ada' } },
- *   contextValue: { locale: 'en' },
- *   operationName: 'Viewer',
- *   fieldResolver: (source, _args, contextValue, info) => {
- *     contextValue.locale; // => 'en'
- *     return source[info.fieldName];
- *   },
- *   typeResolver: (value) => {
- *     return value.kind === 'user' ? 'User' : undefined;
- *   },
- * });
- *
- * result; // => { data: { viewer: { __typename: 'User', name: 'Ada' } } }
- * ```
- * @example
- * ```ts
- * // This variant shows how resolver errors become field errors in the result.
- * import { parse } from 'graphql/language';
- * import { buildSchema } from 'graphql/utilities';
- * import { execute } from 'graphql/execution';
- *
- * const schema = buildSchema(`
- *   type Query {
- *     broken: String
- *   }
- * `);
- * const document = parse('{ broken }');
- *
- * const result = await execute({
- *   schema,
- *   document,
- *   rootValue: {
- *     broken: () => {
- *       throw new Error('Resolver failed.');
- *     },
- *   },
- * });
- *
- * result.data.broken; // => null
- * result.errors[0].message; // => 'Resolver failed.'
- * ```
- * @example
- * ```ts
- * // This variant limits how many variable coercion errors are reported.
- * import { parse } from 'graphql/language';
- * import { buildSchema } from 'graphql/utilities';
- * import { execute } from 'graphql/execution';
- *
- * const schema = buildSchema(`
- *   input ReviewInput {
- *     stars: Int!
- *   }
- *
- *   type Query {
- *     review(input: ReviewInput!): String
- *   }
- * `);
- * const document = parse(`
- *   query ($first: ReviewInput!, $second: ReviewInput!) {
- *     first: review(input: $first)
- *     second: review(input: $second)
- *   }
- * `);
- *
- * const result = await execute({
- *   schema,
- *   document,
- *   variableValues: {
- *     first: { stars: 'bad' },
- *     second: { stars: 'also bad' },
- *   },
- *   options: { maxCoercionErrors: 1 },
- * });
- *
- * result.errors.length; // => 2
- * result.errors[1].message; // matches /error limit reached/
- * ```
- */
-function execute(args) {
-  // Temporary for v15 to v16 migration. Remove in v17
-  arguments.length < 2 ||
-    (0, _devAssert.devAssert)(
-      false,
-      'graphql@16 dropped long-deprecated support for positional arguments, please pass an object instead.',
-    );
-  const { schema, document, variableValues, rootValue } = args; // If arguments are missing or incorrect, throw an 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,
-    };
-  }
-
-  try {
-    const { operation } = exeContext;
-    const result = executeOperation(exeContext, operation, rootValue);
-
-    if ((0, _isPromise.isPromise)(result)) {
-      return result.then(
-        (data) => buildResponse(data, exeContext.collectedErrors.errors),
-        (error) => {
-          exeContext.collectedErrors.add(error, undefined);
-          return buildResponse(null, exeContext.collectedErrors.errors);
-        },
-      );
-    }
-
-    return buildResponse(result, exeContext.collectedErrors.errors);
-  } catch (error) {
-    exeContext.collectedErrors.add(error, undefined);
-    return buildResponse(null, exeContext.collectedErrors.errors);
-  }
-}
-/**
- * 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.
- * @param args - The arguments used to perform the operation.
- * @returns Completed execution output for a synchronous operation.
- * @example
- * ```ts
- * // Execute an operation synchronously when all resolvers are synchronous.
- * import { parse } from 'graphql/language';
- * import { buildSchema } from 'graphql/utilities';
- * import { executeSync } from 'graphql/execution';
- *
- * const schema = buildSchema(`
- *   type Query {
- *     greeting: String
- *   }
- * `);
- * const document = parse('{ greeting }');
- *
- * const result = executeSync({
- *   schema,
- *   document,
- *   rootValue: {
- *     greeting: 'Hello',
- *   },
- * });
- *
- * result; // => { data: { greeting: 'Hello' } }
- * ```
- * @example
- * ```ts
- * // This variant shows executeSync throwing when a resolver returns a promise.
- * import { parse } from 'graphql/language';
- * import { buildSchema } from 'graphql/utilities';
- * import { executeSync } from 'graphql/execution';
- *
- * const schema = buildSchema(`
- *   type Query {
- *     greeting: String
- *   }
- * `);
- *
- * executeSync({
- *   schema,
- *   document: parse('{ greeting }'),
- *   rootValue: {
- *     greeting: async () => 'Hello',
- *   },
- * }); // throws an error
- * ```
- */
-
-function executeSync(args) {
-  const result = execute(args); // Assert that the execution was synchronous.
-
-  if ((0, _isPromise.isPromise)(result)) {
-    throw new Error('GraphQL execution failed to complete synchronously.');
-  }
-
-  return result;
-}
-/**
- * Given a completed execution context and data, build the `{ errors, data }`
- * response defined by the "Response" section of the GraphQL specification.
- *
- * @internal
- */
-
-function buildResponse(data, errors) {
-  return errors.length === 0
-    ? {
-        data,
-      }
-    : {
-        errors,
-        data,
-      };
-}
-/**
- * Essential assertions before executing to provide developer feedback for
- * improper use of the GraphQL library. This deprecated internal helper will be
- * removed in v17; call `assertValidSchema()` and rely on TypeScript checks
- * instead.
- *
- * @deprecated will be removed in v17 in favor of assertValidSchema() and TS checks
- * @internal
- */
-
-function assertValidExecutionArguments(schema, document, rawVariableValues) {
-  document || (0, _devAssert.devAssert)(false, 'Must provide document.'); // If the schema used for execution is invalid, throw an error.
-
-  (0, _validate.assertValidSchema)(schema); // Variables, if provided, must be an object.
-
-  rawVariableValues == null ||
-    (0, _isObjectLike.isObjectLike)(rawVariableValues) ||
-    (0, _devAssert.devAssert)(
-      false,
-      'Variables must be provided as an Object where each property is a variable value. Perhaps look to see if an unparsed JSON string was provided.',
-    );
-}
-/**
- * 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.
- *
- * @internal
- */
-
-function buildExecutionContext(args) {
-  var _definition$name, _operation$variableDe, _options$maxCoercionE;
-
-  const {
-    schema,
-    document,
-    rootValue,
-    contextValue,
-    variableValues: rawVariableValues,
-    operationName,
-    fieldResolver,
-    typeResolver,
-    subscribeFieldResolver,
-    options,
-  } = args;
-  let operation;
-  const fragments = Object.create(null);
-
-  for (const definition of document.definitions) {
-    switch (definition.kind) {
-      case _kinds.Kind.OPERATION_DEFINITION:
-        if (operationName == null) {
-          if (operation !== undefined) {
-            return [
-              new _GraphQLError.GraphQLError(
-                'Must provide operation name if query contains multiple operations.',
-              ),
-            ];
-          }
-
-          operation = definition;
-        } else if (
-          ((_definition$name = definition.name) === null ||
-          _definition$name === void 0
-            ? void 0
-            : _definition$name.value) === operationName
-        ) {
-          operation = definition;
-        }
-
-        break;
-
-      case _kinds.Kind.FRAGMENT_DEFINITION:
-        fragments[definition.name.value] = definition;
-        break;
-
-      default: // ignore non-executable definitions
-    }
-  }
-
-  if (!operation) {
-    if (operationName != null) {
-      return [
-        new _GraphQLError.GraphQLError(
-          `Unknown operation named "${operationName}".`,
-        ),
-      ];
-    }
-
-    return [new _GraphQLError.GraphQLError('Must provide an operation.')];
-  } // FIXME: https://github.com/graphql/graphql-js/issues/2203
-
-  /* c8 ignore next */
-
-  const variableDefinitions =
-    (_operation$variableDe = operation.variableDefinitions) !== null &&
-    _operation$variableDe !== void 0
-      ? _operation$variableDe
-      : [];
-  const coercedVariableValues = (0, _values.getVariableValues)(
-    schema,
-    variableDefinitions,
-    rawVariableValues !== null && rawVariableValues !== void 0
-      ? rawVariableValues
-      : {},
-    {
-      maxErrors:
-        (_options$maxCoercionE =
-          options === null || options === void 0
-            ? void 0
-            : options.maxCoercionErrors) !== null &&
-        _options$maxCoercionE !== void 0
-          ? _options$maxCoercionE
-          : 50,
-    },
-  );
-
-  if (coercedVariableValues.errors) {
-    return coercedVariableValues.errors;
-  }
-
-  return {
-    schema,
-    fragments,
-    rootValue,
-    contextValue,
-    operation,
-    variableValues: coercedVariableValues.coerced,
-    fieldResolver:
-      fieldResolver !== null && fieldResolver !== void 0
-        ? fieldResolver
-        : defaultFieldResolver,
-    typeResolver:
-      typeResolver !== null && typeResolver !== void 0
-        ? typeResolver
-        : defaultTypeResolver,
-    subscribeFieldResolver:
-      subscribeFieldResolver !== null && subscribeFieldResolver !== void 0
-        ? subscribeFieldResolver
-        : defaultFieldResolver,
-    collectedErrors: new CollectedErrors(),
-  };
-}
-/**
- * Implements the "Executing operations" section of the spec.
- *
- * @internal
- */
-
-function executeOperation(exeContext, operation, rootValue) {
-  const rootType = exeContext.schema.getRootType(operation.operation);
-
-  if (rootType == null) {
-    throw new _GraphQLError.GraphQLError(
-      `Schema is not configured to execute ${operation.operation} operation.`,
-      {
-        nodes: operation,
-      },
-    );
-  }
-
-  const rootFields = (0, _collectFields.collectFields)(
-    exeContext.schema,
-    exeContext.fragments,
-    exeContext.variableValues,
-    rootType,
-    operation.selectionSet,
-  );
-  const path = undefined;
-
-  switch (operation.operation) {
-    case _ast.OperationTypeNode.QUERY:
-      return executeFields(exeContext, rootType, rootValue, path, rootFields);
-
-    case _ast.OperationTypeNode.MUTATION:
-      return executeFieldsSerially(
-        exeContext,
-        rootType,
-        rootValue,
-        path,
-        rootFields,
-      );
-
-    case _ast.OperationTypeNode.SUBSCRIPTION:
-      // TODO: deprecate `subscribe` and move all logic here
-      // Temporary solution until we finish merging execute and subscribe together
-      return executeFields(exeContext, rootType, rootValue, path, rootFields);
-  }
-}
-/**
- * Implements the "Executing selection sets" section of the spec
- * for fields that must be executed serially.
- *
- * @internal
- */
-
-function executeFieldsSerially(
-  exeContext,
-  parentType,
-  sourceValue,
-  path,
-  fields,
-) {
-  return (0, _promiseReduce.promiseReduce)(
-    fields.entries(),
-    (results, [responseName, fieldNodes]) => {
-      const fieldPath = (0, _Path.addPath)(path, responseName, parentType.name);
-      const result = executeField(
-        exeContext,
-        parentType,
-        sourceValue,
-        fieldNodes,
-        fieldPath,
-      );
-
-      if (result === undefined) {
-        return results;
-      }
-
-      if ((0, _isPromise.isPromise)(result)) {
-        return result.then((resolvedResult) => {
-          results[responseName] = resolvedResult;
-          return results;
-        });
-      }
-
-      results[responseName] = result;
-      return results;
-    },
-    Object.create(null),
-  );
-}
-/**
- * Implements the "Executing selection sets" section of the spec
- * for fields that may be executed in parallel.
- *
- * @internal
- */
-
-function executeFields(exeContext, parentType, sourceValue, path, fields) {
-  const results = Object.create(null);
-  let containsPromise = false;
-
-  try {
-    for (const [responseName, fieldNodes] of fields.entries()) {
-      const fieldPath = (0, _Path.addPath)(path, responseName, parentType.name);
-      const result = executeField(
-        exeContext,
-        parentType,
-        sourceValue,
-        fieldNodes,
-        fieldPath,
-      );
-
-      if (result !== undefined) {
-        results[responseName] = result;
-
-        if ((0, _isPromise.isPromise)(result)) {
-          containsPromise = true;
-        }
-      }
-    }
-  } catch (error) {
-    if (containsPromise) {
-      // Ensure that any promises returned by other fields are handled, as they may also reject.
-      return (0, _promiseForObject.promiseForObject)(results).finally(() => {
-        throw error;
-      });
-    }
-
-    throw error;
-  } // If there are no promises, we can just return the object
-
-  if (!containsPromise) {
-    return results;
-  } // Otherwise, results is a map from field name to the result of resolving that
-  // field, which is possibly a promise. Return a promise that will return this
-  // same map, but with any promises replaced with the values they resolved to.
-
-  return (0, _promiseForObject.promiseForObject)(results);
-}
-/**
- * Implements the "Executing fields" section of the spec
- * In particular, this function figures out the value that the field returns by
- * calling its resolve function, then calls completeValue to complete promises,
- * serialize scalars, or execute the sub-selection-set for objects.
- *
- * @internal
- */
-
-function executeField(exeContext, parentType, source, fieldNodes, path) {
-  var _fieldDef$resolve;
-
-  const fieldDef = getFieldDef(exeContext.schema, parentType, fieldNodes[0]);
-
-  if (!fieldDef) {
-    return;
-  }
-
-  const returnType = fieldDef.type;
-  const resolveFn =
-    (_fieldDef$resolve = fieldDef.resolve) !== null &&
-    _fieldDef$resolve !== void 0
-      ? _fieldDef$resolve
-      : exeContext.fieldResolver;
-  const info = buildResolveInfo(
-    exeContext,
-    fieldDef,
-    fieldNodes,
-    parentType,
-    path,
-  ); // Get the resolve function, regardless of if its result is normal or abrupt (error).
-
-  try {
-    // Build a JS object of arguments from the field.arguments AST, using the
-    // variables scope to fulfill any variable references.
-    // TODO: find a way to memoize, in case this field is within a List type.
-    const args = (0, _values.getArgumentValues)(
-      fieldDef,
-      fieldNodes[0],
-      exeContext.variableValues,
-    ); // 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 contextValue = exeContext.contextValue;
-    const result = resolveFn(source, args, contextValue, info);
-    let completed;
-
-    if ((0, _isPromise.isPromise)(result)) {
-      completed = result.then((resolved) =>
-        completeValue(exeContext, returnType, fieldNodes, info, path, resolved),
-      );
-    } else {
-      completed = completeValue(
-        exeContext,
-        returnType,
-        fieldNodes,
-        info,
-        path,
-        result,
-      );
-    }
-
-    if ((0, _isPromise.isPromise)(completed)) {
-      // Note: we don't rely on a `catch` method, but we do expect "thenable"
-      // to take a second callback for the error case.
-      return completed.then(undefined, (rawError) => {
-        const error = (0, _locatedError.locatedError)(
-          rawError,
-          fieldNodes,
-          (0, _Path.pathToArray)(path),
-        );
-        return handleFieldError(error, returnType, path, exeContext);
-      });
-    }
-
-    return completed;
-  } catch (rawError) {
-    const error = (0, _locatedError.locatedError)(
-      rawError,
-      fieldNodes,
-      (0, _Path.pathToArray)(path),
-    );
-    return handleFieldError(error, returnType, path, exeContext);
-  }
-}
-/** @internal */
-
-function buildResolveInfo(exeContext, fieldDef, fieldNodes, parentType, path) {
-  // 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: exeContext.schema,
-    fragments: exeContext.fragments,
-    rootValue: exeContext.rootValue,
-    operation: exeContext.operation,
-    variableValues: exeContext.variableValues,
-  };
-}
-
-function handleFieldError(error, returnType, path, exeContext) {
-  // If the field type is non-nullable, then it is resolved without any
-  // protection from errors, however it still properly locates the error.
-  if ((0, _definition.isNonNullType)(returnType)) {
-    throw error;
-  } // Otherwise, error protection is applied, logging the error and resolving
-  // a null value for this field if one is encountered.
-
-  exeContext.collectedErrors.add(error, path);
-  return null;
-}
-/**
- * Implements the instructions for completeValue as defined in the
- * "Value Completion" section of the spec.
- *
- * If the field type is Non-Null, then this recursively completes the value
- * for the inner type. It throws a field error if that completion returns null,
- * as per the "Nullability" section of the spec.
- *
- * If the field type is a List, then this recursively completes the value
- * for the inner type on each item in the list.
- *
- * If the field type is a Scalar or Enum, ensures the completed value is a legal
- * value of the type by calling the `serialize` method of GraphQL type
- * definition.
- *
- * If the field is an abstract type, determine the runtime type of the value
- * and then complete based on that type
- *
- * Otherwise, the field type expects a sub-selection set, and will complete the
- * value by executing all sub-selections.
- *
- * @internal
- */
-
-function completeValue(exeContext, returnType, fieldNodes, info, path, result) {
-  // If result is an Error, throw a located error.
-  if (result instanceof Error) {
-    throw result;
-  } // If field type is NonNull, complete for inner type, and throw field error
-  // if result is null.
-
-  if ((0, _definition.isNonNullType)(returnType)) {
-    const completed = completeValue(
-      exeContext,
-      returnType.ofType,
-      fieldNodes,
-      info,
-      path,
-      result,
-    );
-
-    if (completed === null) {
-      throw new Error(
-        `Cannot return null for non-nullable field ${info.parentType.name}.${info.fieldName}.`,
-      );
-    }
-
-    return completed;
-  } // If result value is null or undefined then return null.
-
-  if (result == null) {
-    return null;
-  } // If field type is List, complete each item in the list with the inner type
-
-  if ((0, _definition.isListType)(returnType)) {
-    return completeListValue(
-      exeContext,
-      returnType,
-      fieldNodes,
-      info,
-      path,
-      result,
-    );
-  } // If field type is a leaf type, Scalar or Enum, serialize to a valid value,
-  // returning null if serialization is not possible.
-
-  if ((0, _definition.isLeafType)(returnType)) {
-    return completeLeafValue(returnType, result);
-  } // If field type is an abstract type, Interface or Union, determine the
-  // runtime Object type and complete for that type.
-
-  if ((0, _definition.isAbstractType)(returnType)) {
-    return completeAbstractValue(
-      exeContext,
-      returnType,
-      fieldNodes,
-      info,
-      path,
-      result,
-    );
-  } // If field type is Object, execute and complete all sub-selections.
-
-  if ((0, _definition.isObjectType)(returnType)) {
-    return completeObjectValue(
-      exeContext,
-      returnType,
-      fieldNodes,
-      info,
-      path,
-      result,
-    );
-  }
-  /* c8 ignore next 6 */
-  // Not reachable, all possible output types have been considered.
-
-  false ||
-    (0, _invariant.invariant)(
-      false,
-      'Cannot complete value of unexpected output type: ' +
-        (0, _inspect.inspect)(returnType),
-    );
-}
-/**
- * Complete a list value by completing each item in the list with the
- * inner type
- *
- * @internal
- */
-
-function completeListValue(
-  exeContext,
-  returnType,
-  fieldNodes,
-  info,
-  path,
-  result,
-) {
-  if (!(0, _isIterableObject.isIterableObject)(result)) {
-    throw new _GraphQLError.GraphQLError(
-      `Expected Iterable, but did not find one for field "${info.parentType.name}.${info.fieldName}".`,
-    );
-  } // This is specified as a simple map, however we're optimizing the path
-  // where the list contains no Promises by avoiding creating another Promise.
-
-  const itemType = returnType.ofType;
-  let containsPromise = false;
-  const completedResults = Array.from(result, (item, index) => {
-    // No need to modify the info object containing the path,
-    // since from here on it is not ever accessed by resolver functions.
-    const itemPath = (0, _Path.addPath)(path, index, undefined);
-
-    try {
-      let completedItem;
-
-      if ((0, _isPromise.isPromise)(item)) {
-        completedItem = item.then((resolved) =>
-          completeValue(
-            exeContext,
-            itemType,
-            fieldNodes,
-            info,
-            itemPath,
-            resolved,
-          ),
-        );
-      } else {
-        completedItem = completeValue(
-          exeContext,
-          itemType,
-          fieldNodes,
-          info,
-          itemPath,
-          item,
-        );
-      }
-
-      if ((0, _isPromise.isPromise)(completedItem)) {
-        containsPromise = true; // Note: we don't rely on a `catch` method, but we do expect "thenable"
-        // to take a second callback for the error case.
-
-        return completedItem.then(undefined, (rawError) => {
-          const error = (0, _locatedError.locatedError)(
-            rawError,
-            fieldNodes,
-            (0, _Path.pathToArray)(itemPath),
-          );
-          return handleFieldError(error, itemType, itemPath, exeContext);
-        });
-      }
-
-      return completedItem;
-    } catch (rawError) {
-      const error = (0, _locatedError.locatedError)(
-        rawError,
-        fieldNodes,
-        (0, _Path.pathToArray)(itemPath),
-      );
-      return handleFieldError(error, itemType, itemPath, exeContext);
-    }
-  });
-  return containsPromise ? Promise.all(completedResults) : completedResults;
-}
-/**
- * Complete a Scalar or Enum by serializing to a valid value, returning
- * null if serialization is not possible.
- *
- * @internal
- */
-
-function completeLeafValue(returnType, result) {
-  const serializedResult = returnType.serialize(result);
-
-  if (serializedResult == null) {
-    throw new Error(
-      `Expected \`${(0, _inspect.inspect)(returnType)}.serialize(${(0,
-      _inspect.inspect)(result)})\` to ` +
-        `return non-nullable value, returned: ${(0, _inspect.inspect)(
-          serializedResult,
-        )}`,
-    );
-  }
-
-  return serializedResult;
-}
-/**
- * Complete a value of an abstract type by determining the runtime object type
- * of that value, then complete the value for that type.
- *
- * @internal
- */
-
-function completeAbstractValue(
-  exeContext,
-  returnType,
-  fieldNodes,
-  info,
-  path,
-  result,
-) {
-  var _returnType$resolveTy;
-
-  const resolveTypeFn =
-    (_returnType$resolveTy = returnType.resolveType) !== null &&
-    _returnType$resolveTy !== void 0
-      ? _returnType$resolveTy
-      : exeContext.typeResolver;
-  const contextValue = exeContext.contextValue;
-  const runtimeType = resolveTypeFn(result, contextValue, info, returnType);
-
-  if ((0, _isPromise.isPromise)(runtimeType)) {
-    return runtimeType.then((resolvedRuntimeType) =>
-      completeObjectValue(
-        exeContext,
-        ensureValidRuntimeType(
-          resolvedRuntimeType,
-          exeContext,
-          returnType,
-          fieldNodes,
-          info,
-          result,
-        ),
-        fieldNodes,
-        info,
-        path,
-        result,
-      ),
-    );
-  }
-
-  return completeObjectValue(
-    exeContext,
-    ensureValidRuntimeType(
-      runtimeType,
-      exeContext,
-      returnType,
-      fieldNodes,
-      info,
-      result,
-    ),
-    fieldNodes,
-    info,
-    path,
-    result,
-  );
-}
-
-function ensureValidRuntimeType(
-  runtimeTypeName,
-  exeContext,
-  returnType,
-  fieldNodes,
-  info,
-  result,
-) {
-  if (runtimeTypeName == null) {
-    throw new _GraphQLError.GraphQLError(
-      `Abstract type "${returnType.name}" must resolve to an Object type at runtime for field "${info.parentType.name}.${info.fieldName}". Either the "${returnType.name}" type should provide a "resolveType" function or each possible type should provide an "isTypeOf" function.`,
-      fieldNodes,
-    );
-  } // releases before 16.0.0 supported returning `GraphQLObjectType` from `resolveType`
-  // TODO: remove in 17.0.0 release
-
-  if ((0, _definition.isObjectType)(runtimeTypeName)) {
-    throw new _GraphQLError.GraphQLError(
-      'Support for returning GraphQLObjectType from resolveType was removed in graphql-js@16.0.0 please return type name instead.',
-    );
-  }
-
-  if (typeof runtimeTypeName !== 'string') {
-    throw new _GraphQLError.GraphQLError(
-      `Abstract type "${returnType.name}" must resolve to an Object type at runtime for field "${info.parentType.name}.${info.fieldName}" with ` +
-        `value ${(0, _inspect.inspect)(result)}, received "${(0,
-        _inspect.inspect)(runtimeTypeName)}".`,
-    );
-  }
-
-  const runtimeType = exeContext.schema.getType(runtimeTypeName);
-
-  if (runtimeType == null) {
-    throw new _GraphQLError.GraphQLError(
-      `Abstract type "${returnType.name}" was resolved to a type "${runtimeTypeName}" that does not exist inside the schema.`,
-      {
-        nodes: fieldNodes,
-      },
-    );
-  }
-
-  if (!(0, _definition.isObjectType)(runtimeType)) {
-    throw new _GraphQLError.GraphQLError(
-      `Abstract type "${returnType.name}" was resolved to a non-object type "${runtimeTypeName}".`,
-      {
-        nodes: fieldNodes,
-      },
-    );
-  }
-
-  if (!exeContext.schema.isSubType(returnType, runtimeType)) {
-    throw new _GraphQLError.GraphQLError(
-      `Runtime Object type "${runtimeType.name}" is not a possible type for "${returnType.name}".`,
-      {
-        nodes: fieldNodes,
-      },
-    );
-  }
-
-  return runtimeType;
-}
-/**
- * Complete an Object value by executing all sub-selections.
- *
- * @internal
- */
-
-function completeObjectValue(
-  exeContext,
-  returnType,
-  fieldNodes,
-  info,
-  path,
-  result,
-) {
-  // Collect sub-fields to execute to complete this value.
-  const subFieldNodes = collectSubfields(exeContext, returnType, fieldNodes); // If there is an isTypeOf predicate function, call it with the
-  // current result. If isTypeOf returns false, then raise an error rather
-  // than continuing execution.
-
-  if (returnType.isTypeOf) {
-    const isTypeOf = returnType.isTypeOf(result, exeContext.contextValue, info);
-
-    if ((0, _isPromise.isPromise)(isTypeOf)) {
-      return isTypeOf.then((resolvedIsTypeOf) => {
-        if (!resolvedIsTypeOf) {
-          throw invalidReturnTypeError(returnType, result, fieldNodes);
-        }
-
-        return executeFields(
-          exeContext,
-          returnType,
-          result,
-          path,
-          subFieldNodes,
-        );
-      });
-    }
-
-    if (!isTypeOf) {
-      throw invalidReturnTypeError(returnType, result, fieldNodes);
-    }
-  }
-
-  return executeFields(exeContext, returnType, result, path, subFieldNodes);
-}
-
-function invalidReturnTypeError(returnType, result, fieldNodes) {
-  return new _GraphQLError.GraphQLError(
-    `Expected value of type "${returnType.name}" but got: ${(0,
-    _inspect.inspect)(result)}.`,
-    {
-      nodes: fieldNodes,
-    },
-  );
-}
-/**
- * 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.isObjectLike)(value) &&
-    typeof value.__typename === 'string'
-  ) {
-    return value.__typename;
-  } // Otherwise, test each possible type.
-
-  const possibleTypes = info.schema.getPossibleTypes(abstractType);
-  const promisedIsTypeOfResults = [];
-
-  for (let i = 0; i < possibleTypes.length; i++) {
-    const type = possibleTypes[i];
-
-    if (type.isTypeOf) {
-      const isTypeOfResult = type.isTypeOf(value, contextValue, info);
-
-      if ((0, _isPromise.isPromise)(isTypeOfResult)) {
-        promisedIsTypeOfResults[i] = isTypeOfResult;
-      } else if (isTypeOfResult) {
-        if (promisedIsTypeOfResults.length) {
-          // Explicitly ignore any promise rejections
-          Promise.allSettled(promisedIsTypeOfResults)
-            /* c8 ignore next 3 */
-            .catch(() => {
-              // Do nothing
-            });
-        }
-
-        return type.name;
-      }
-    }
-  }
-
-  if (promisedIsTypeOfResults.length) {
-    return Promise.all(promisedIsTypeOfResults).then((isTypeOfResults) => {
-      for (let i = 0; i < isTypeOfResults.length; i++) {
-        if (isTypeOfResults[i]) {
-          return possibleTypes[i].name;
-        }
-      }
-    });
-  }
-};
-/**
- * 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.
- */
-
-exports.defaultTypeResolver = defaultTypeResolver;
-
-const defaultFieldResolver = function (source, args, contextValue, info) {
-  // ensure source is a value for which property access is acceptable.
-  if ((0, _isObjectLike.isObjectLike)(source) || typeof source === 'function') {
-    const property = source[info.fieldName];
-
-    if (typeof property === 'function') {
-      return source[info.fieldName](args, contextValue, info);
-    }
-
-    return property;
-  }
-};
-/**
- * This method looks up the field on the given type definition.
- * It has special casing for the three introspection fields,
- * __schema, __type and __typename. __typename is special because
- * it can always be queried as a field, even in situations where no
- * other fields are allowed, like on a Union. __schema and __type
- * could get automatically added to the query type, but that would
- * require mutating type definitions, which would cause issues.
- *
- * @internal
- */
-
-exports.defaultFieldResolver = defaultFieldResolver;
-
-function getFieldDef(schema, parentType, fieldNode) {
-  const fieldName = fieldNode.name.value;
-
-  if (
-    fieldName === _introspection.SchemaMetaFieldDef.name &&
-    schema.getQueryType() === parentType
-  ) {
-    return _introspection.SchemaMetaFieldDef;
-  } else if (
-    fieldName === _introspection.TypeMetaFieldDef.name &&
-    schema.getQueryType() === parentType
-  ) {
-    return _introspection.TypeMetaFieldDef;
-  } else if (fieldName === _introspection.TypeNameMetaFieldDef.name) {
-    return _introspection.TypeNameMetaFieldDef;
-  }
-
-  return parentType.getFields()[fieldName];
-}