it('should correctly batch multiple queries', done => {
    const data = {
      lastName: 'Ever',
      firstName: 'Greatest',
    };
    const data2 = {
      lastName: 'Hauser',
      firstName: 'Evans',
    };
    const batcher = new OperationBatcher({
      batchInterval: 10,
      batchHandler: () =>
        new Observable(observer => {
          observer.next([{ data }, { data: data2 }, { data }]);
          setTimeout(observer.complete.bind(observer));
        }),
    });
    const query = gql`
      query {
        author {
          firstName
          lastName
        }
      }
    `;
    const operation: Operation = createOperation({}, { query });
    const operation2: Operation = createOperation({}, { query });
    const operation3: Operation = createOperation({}, { query });

    batcher.enqueueRequest({ operation }).subscribe({});
    batcher.enqueueRequest({ operation: operation2 }).subscribe({});
    try {
      expect(batcher.queuedRequests.get('').length).toBe(2);
    } catch (e) {
      done.fail(e);
    }

    setTimeout(() => {
      // The batch shouldn't be fired yet, so we can add one more request.
      batcher.enqueueRequest({ operation: operation3 }).subscribe({});
      try {
        expect(batcher.queuedRequests.get('').length).toBe(3);
      } catch (e) {
        done.fail(e);
      }
    }, 5);

    setTimeout(
      terminatingCheck(done, () => {
        // The batch should've been fired by now.
        expect(operation.getContext()).toEqual({ response: { data } });
        expect(operation2.getContext()).toEqual({ response: { data: data2 } });
        expect(operation3.getContext()).toEqual({ response: { data } });
        expect(batcher.queuedRequests.get('')).toBeUndefined();
      }),
      20,
    );
  });

const authMiddleware = new ApolloLink((operation: Operation, forward: any) => {
  operation.setContext({
    headers: {
      "X-JWT": getToken()
    }
  });
  return forward(operation);
});

      ((operation: Operation) => {
        const context = operation.getContext();

        const contextConfig = {
          http: context.http,
          options: context.fetchOptions,
          credentials: context.credentials,
          headers: context.headers,
        };

        //may throw error if config not serializable
        return selectURI(operation, uri) + JSON.stringify(contextConfig);
      });

    public request(
      operation: Operation,
      forward: NextLink = () => Observable.of({ data: {} }),
    ): Observable<FetchResult> {
      if (typeDefs) {
        const directives = 'directive @client on FIELD';

        const definition = normalizeTypeDefs(typeDefs);

        operation.setContext(({ schemas = [] }) => ({
          schemas: schemas.concat([{ definition, directives }]),
        }));
      }

      const isClient = hasDirectives(['client'], operation.query);

      if (!isClient) return forward(operation);

      const resolvers =
        typeof clientStateConfig.resolvers === 'function'
          ? clientStateConfig.resolvers()
          : clientStateConfig.resolvers;
      const server = removeClientSetsFromDocument(operation.query);
      const { query } = operation;
      const type =
        capitalizeFirstLetter(
          (getMainDefinition(query) || ({} as any)).operation,
        ) || 'Query';

      const resolver = (fieldName, rootValue = {}, args, context, info) => {
        const { resultKey } = info;

        // rootValue[fieldName] is where the data is stored in the "canonical model"
        // rootValue[info.resultKey] is where the user wants the data to be.
        // If fieldName != info.resultKey -- then GraphQL Aliases are in play
        // See also:
        // - https://github.com/apollographql/apollo-client/tree/master/packages/graphql-anywhere#resolver-info
        // - https://github.com/apollographql/apollo-link-rest/pull/113

        // Support GraphQL Aliases!
        const aliasedNode = rootValue[resultKey];
        const preAliasingNode = rootValue[fieldName];
        const aliasNeeded = resultKey !== fieldName;

        // If aliasedValue is defined, some other link or server already returned a value
        if (aliasedNode !== undefined || preAliasingNode !== undefined) {
          return aliasedNode || preAliasingNode;
        }

        // Look for the field in the custom resolver map
        const resolverMap = resolvers[(rootValue as any).__typename || type];
        if (resolverMap) {
          const resolve = resolverMap[fieldName];
          if (resolve) return resolve(rootValue, args, context, info);
        }

        // TODO: the proper thing to do here is throw an error saying to
        // add `client.onResetStore(link.writeDefaults);`
        // waiting on https://github.com/apollographql/apollo-client/pull/3010

        return (
          // Support nested fields
          (aliasNeeded ? aliasedNode : preAliasingNode) ||
          (defaults || {})[fieldName]
        );
      };

      if (server) operation.query = server;
      const obs =
        server && forward
          ? forward(operation)
          : Observable.of({
              data: {},
            });

      return new Observable(observer => {
        // Works around race condition between completion and graphql execution
        // finishing. If complete is called during the graphql call, we will
        // miss out on the result, since the observer will have completed
        let complete = false;
        let handlingNext = false;
        obs.subscribe({
          next: ({ data, errors }) => {
            const observerErrorHandler = observer.error.bind(observer);
            const context = operation.getContext();

            handlingNext = true;
            //data is from the server and provides the root value to this GraphQL resolution
            //when there is no resolver, the data is taken from the context
            graphql(resolver, query, data, context, operation.variables, {
              fragmentMatcher,
            })
              .then(nextData => {
                observer.next({
                  data: nextData,
                  errors,
                });
                if (complete) {
                  observer.complete();
                }
//.........这里部分代码省略.........

 terminatingCheck(done, () => {
   // The batch should've been fired by now.
   expect(operation.getContext()).toEqual({ response: { data } });
   expect(operation2.getContext()).toEqual({ response: { data: data2 } });
   expect(operation3.getContext()).toEqual({ response: { data } });
   expect(batcher.queuedRequests.get('')).toBeUndefined();
 }),

            entityObserver.subscribe(entity => {
                const query = queries[entity.fieldName];
                if (!query) {
                    throw new Error(`unknown fieldName: ${entity.fieldName}`);
                }

                let executeQuery = this._executeQuery;
                if (!executeQuery) {
                    const client: ApolloClient<never> = operation.getContext().client;
                    if (client instanceof ApolloClient === false) {
                        console.error(`client can't fine`, operation.getContext());
                        throw new Error(`client can't find`);
                    }

                    executeQuery = ({ query, variables }) => {
                        return client.query({
                            query,
                            variables,
                        });
                    };
                }

                executeQuery({
                    query,
                    variables: { id: entity.id },
                })
                    .then(result => {
                        observer.next(result);
                    })
                    .catch(e => {
                        observer.error(e);
                    });
            });

          next: ({ data, errors }) => {
            const observerErrorHandler = observer.error.bind(observer);
            const context = operation.getContext();

            handlingNext = true;
            //data is from the server and provides the root value to this GraphQL resolution
            //when there is no resolver, the data is taken from the context
            graphql(resolver, query, data, context, operation.variables, {
              fragmentMatcher,
            })
              .then(nextData => {
                observer.next({
                  data: nextData,
                  errors,
                });
                if (complete) {
                  observer.complete();
                }
                handlingNext = false;
              })
              .catch(observerErrorHandler);
          },

 .then(req => setter(req, operation.getContext()))