it('provides a user input error', () => {
      const error = new UserInputError(message, {
        field1: 'property1',
        field2: 'property2',
      });
      verifyError(error, {
        code: 'BAD_USER_INPUT',
        errorClass: UserInputError,
        name: 'UserInputError',
      });

      const formattedError = formatApolloErrors([
        new GraphQLError(
          error.message,
          undefined,
          undefined,
          undefined,
          undefined,
          error,
        ),
      ])[0];

      expect(formattedError.extensions.exception.field1).toEqual('property1');
      expect(formattedError.extensions.exception.field2).toEqual('property2');
    });

const createFormatResponse = (formatter: (e: any) => any) => (response: any) => {
  const {errors = null} = response || {}

  return {
    ...response,
    errors: Array.isArray(errors) ? formatApolloErrors(errors, {formatter}) : undefined,
  }
}

 requests.map(async request => {
   try {
     const requestContext = buildRequestContext(request);
     return await processGraphQLRequest(options, requestContext);
   } catch (error) {
     // A batch can contain another query that returns data,
     // so we don't error out the entire request with an HttpError
     return {
       errors: formatApolloErrors([error], options),
     };
   }
 }),

 const createFormattedError: CreateFormatError = (
   options?: Record<string, any>,
   errors?: Error[],
 ) => {
   if (errors === undefined) {
     const error = new ApolloError(message, code, { key });
     return formatApolloErrors(
       [
         new GraphQLError(
           error.message,
           undefined,
           undefined,
           undefined,
           undefined,
           error,
         ),
       ],
       options,
     )[0];
   } else {
     return formatApolloErrors(errors, options);
   }
 };

 public willSendResponse(o: {
   graphqlResponse: GraphQLResponse;
 }): void | { graphqlResponse: GraphQLResponse } {
   if (o.graphqlResponse.errors) {
     return {
       graphqlResponse: {
         ...o.graphqlResponse,
         errors: formatApolloErrors(o.graphqlResponse.errors, {
           formatter: this.formatError,
           debug: this.debug,
         }),
       },
     };
   }
 }

/**
 * If options is specified, then the errors array will be formatted
 */
function throwHttpGraphQLError<E extends Error>(
  statusCode: number,
  errors: Array<E>,
  options?: Pick<GraphQLOptions, 'debug' | 'formatError'>,
): never {
  throw new HttpQueryError(
    statusCode,
    prettyJSONStringify({
      errors: options
        ? formatApolloErrors(errors, {
            debug: options.debug,
            formatter: options.formatError,
          })
        : errors,
    }),
    true,
    {
      'Content-Type': 'application/json',
    },
  );
}

          .then(result => {
            let response: GraphQLResponse = {
              data: result.data,
            };

            if (result.errors) {
              response.errors = formatApolloErrors([...result.errors], {
                debug,
              });
            }

            executionDidEnd(...(result.errors || []));

            const formattedExtensions = extensionStack.format();
            if (Object.keys(formattedExtensions).length > 0) {
              response.extensions = formattedExtensions;
            }

            if (options.formatResponse) {
              response = options.formatResponse(response, options);
            }

            return response;
          });

      (): Promise<GraphQLResponse> => {
        // Parse the document.
        let documentAST: DocumentNode;
        if (options.parsedQuery) {
          documentAST = options.parsedQuery;
        } else if (!options.queryString) {
          throw new Error('Must supply one of queryString and parsedQuery');
        } else {
          const parsingDidEnd = extensionStack.parsingDidStart({
            queryString: options.queryString,
          });
          let graphqlParseErrors: SyntaxError[] | undefined;
          try {
            documentAST = parse(options.queryString);
          } catch (syntaxError) {
            graphqlParseErrors = formatApolloErrors(
              [
                fromGraphQLError(syntaxError, {
                  errorClass: SyntaxError,
                }),
              ],
              {
                debug,
              },
            );
            return Promise.resolve({ errors: graphqlParseErrors });
          } finally {
            parsingDidEnd(...(graphqlParseErrors || []));
          }
        }

        if (
          options.nonQueryError &&
          !isQueryOperation(documentAST, options.operationName)
        ) {
          // XXX this goes to requestDidEnd, is that correct or should it be
          // validation?
          throw options.nonQueryError;
        }

        let rules = specifiedRules;
        if (options.validationRules) {
          rules = rules.concat(options.validationRules);
        }
        const validationDidEnd = extensionStack.validationDidStart();
        let validationErrors: GraphQLError[] | undefined;
        try {
          validationErrors = validate(
            options.schema,
            documentAST,
            rules,
          ) as GraphQLError[]; // Return type of validate is ReadonlyArray<GraphQLError>
        } catch (validationThrewError) {
          // Catch errors thrown by validate, not just those returned by it.
          validationErrors = [validationThrewError];
        } finally {
          try {
            if (validationErrors) {
              validationErrors = formatApolloErrors(
                validationErrors.map(err =>
                  fromGraphQLError(err, { errorClass: ValidationError }),
                ),
                {
                  debug,
                },
              );
            }
          } finally {
            validationDidEnd(...(validationErrors || []));

            if (validationErrors && validationErrors.length) {
              return Promise.resolve({
                errors: validationErrors,
              });
            }
          }
        }

        const executionArgs: ExecutionArgs = {
          schema: options.schema,
          document: documentAST,
          rootValue: options.rootValue,
          contextValue: context,
          variableValues: options.variables,
          operationName: options.operationName,
          fieldResolver: options.fieldResolver,
        };
        const executionDidEnd = extensionStack.executionDidStart({
          executionArgs,
        });
        return Promise.resolve()
          .then(() => execute(executionArgs))
          .catch(executionError => {
            return {
              // These errors will get passed through formatApolloErrors in the
              // `then` below.
              // TODO accurate code for this error, which describes this error, which
              // can occur when:
              // * variables incorrectly typed/null when nonnullable
              // * unknown operation/operation name invalid
//.........这里部分代码省略.........