How to use apollo-angular-link-http-common - 9 common examples

const pick = (
          key: K,
          init?: Context[K] | Options[K],
        ): Context[K] | Options[K] => {
          return prioritize(context[key], this.options[key], init);
        };

return Math.random()
        .toString(36)
        .substr(2, 9);
    }

    const headers =
      context.headers &&
      context.headers.keys().map((k: string) => context.headers.get(k));

    const opts = JSON.stringify({
      includeQuery: context.includeQuery,
      includeExtensions: context.includeExtensions,
      headers,
    });

    return prioritize(context.uri, this.options.uri) + opts;
  }

return operations.map(operation => {
      const includeExtensions = prioritize(
        operation.getContext().includeExtensions,
        this.options.includeExtensions,
        false,
      );
      const includeQuery = prioritize(
        operation.getContext().includeQuery,
        this.options.includeQuery,
        true,
      );

      const body: Body = {
        operationName: operation.operationName,
        variables: operation.variables,
      };

      if (includeExtensions) {
        body.extensions = operation.extensions;
      }

      if (includeQuery) {
        body.query = print(operation.query);

private createOptions(operations: Operation[]): Options {
    const context: Context = operations[0].getContext();

    return {
      method: prioritize(context.method, this.options.method, defaults.method),
      uri: prioritize(context.uri, this.options.uri, defaults.uri),
      withCredentials: prioritize(
        context.withCredentials,
        this.options.withCredentials,
      ),
    };
  }

private createOptions(operations: Operation[]): Options {
    const context: Context = operations[0].getContext();

    return {
      method: prioritize(context.method, this.options.method, defaults.method),
      uri: prioritize(context.uri, this.options.uri, defaults.uri),
      withCredentials: prioritize(
        context.withCredentials,
        this.options.withCredentials,
      ),
    };
  }

if (includeExtensions) {
          (req.body as Body).extensions = operation.extensions;
        }

        if (includeQuery) {
          (req.body as Body).query = print(operation.query);
        }

        if (context.headers) {
          req.options.headers = mergeHeaders(
            req.options.headers,
            context.headers,
          );
        }

        const sub = fetch(req, this.httpClient, extractFiles).subscribe({
          next: response => {
            operation.setContext({response});
            observer.next(response.body);
          },
          error: err => observer.error(err),
          complete: () => observer.complete(),
        });

        return () => {
          if (!sub.closed) {
            sub.unsubscribe();
          }
        };
      });
  }

if (typeof uri === 'function') {
          throw new Error(`Option 'uri' is a function, should be a string`);
        }

        const req: Request = {
          method,
          url: uri,
          body: body,
          options: {
            withCredentials,
            headers,
          },
        };

        const sub = fetch(req, this.httpClient, () => {
          throw new Error(
            'File upload is not available when combined with Batching',
          );
        }).subscribe({
          next: result => observer.next(result.body),
          error: err => observer.error(err),
          complete: () => observer.complete(),
        });

        return () => {
          if (!sub.closed) {
            sub.unsubscribe();
          }
        };
      });
    };

return operations.reduce((headers: HttpHeaders, operation: Operation) => {
      return mergeHeaders(headers, operation.getContext().headers);
    }, this.options.headers);
  }

withCredentials,
            useMultipart,
            headers: this.options.headers,
          },
        };

        if (includeExtensions) {
          (req.body as Body).extensions = operation.extensions;
        }

        if (includeQuery) {
          (req.body as Body).query = print(operation.query);
        }

        if (context.headers) {
          req.options.headers = mergeHeaders(
            req.options.headers,
            context.headers,
          );
        }

        const sub = fetch(req, this.httpClient, extractFiles).subscribe({
          next: response => {
            operation.setContext({response});
            observer.next(response.body);
          },
          error: err => observer.error(err),
          complete: () => observer.complete(),
        });

        return () => {
          if (!sub.closed) {