@apollo/gateway 0.50.2 → 0.51.0

package/src/__mocks__/apollo-server-env.ts

@@ -1,56 +0,0 @@
-import {
-  fetch,
-  Request,
-  Response,
-  Body,
-  BodyInit,
-  Headers,
-  HeadersInit,
-  URL,
-  URLSearchParams,
-} from 'apollo-server-env';
-interface FetchMock extends jest.MockedFunction<typeof fetch> {
-  mockResponseOnce(data?: any, headers?: HeadersInit, status?: number): this;
-  mockJSONResponseOnce(data?: object, headers?: HeadersInit): this;
-}
-
-const mockFetch = jest.fn(fetch) as unknown as FetchMock;
-
-mockFetch.mockResponseOnce = (
-  data?: BodyInit,
-  headers?: Headers,
-  status: number = 200,
-) => {
-  return mockFetch.mockImplementationOnce(async () => {
-    return new Response(data, {
-      status,
-      headers,
-    });
-  });
-};
-
-mockFetch.mockJSONResponseOnce = (
-  data = {},
-  headers?: Headers,
-  status?: number,
-) => {
-  return mockFetch.mockResponseOnce(
-    JSON.stringify(data),
-    Object.assign({ 'Content-Type': 'application/json' }, headers),
-    status,
-  );
-};
-
-const env = {
-  fetch: mockFetch,
-  Request,
-  Response,
-  Body,
-  Headers,
-  URL,
-  URLSearchParams,
-};
-
-jest.doMock('apollo-server-env', () => env);
-
-export = env;

package/src/__mocks__/make-fetch-happen-fetcher.ts

@@ -1,57 +0,0 @@
-/// <reference path="../make-fetch-happen.d.ts" />
-// This explicit reference shouldn't be needed because the project references
-// the main project, which includes these type declarations. For some reason,
-// VS Code doesn't pick that up though.
-// (This may be related to https://github.com/microsoft/TypeScript/issues/36708.)
-
-import {
-  fetch,
-  Response,
-  BodyInit,
-  Headers,
-  HeadersInit
-} from 'apollo-server-env';
-
-import fetcher from 'make-fetch-happen';
-
-interface MakeFetchHappenMock extends jest.MockedFunction<typeof fetch> {
-  mockResponseOnce(data?: any, headers?: HeadersInit, status?: number): this;
-  mockJSONResponseOnce(data?: object, headers?: HeadersInit): this;
-}
-
-const mockMakeFetchHappen = jest.fn(fetcher) as unknown as MakeFetchHappenMock;
-const defaults = () => mockMakeFetchHappen;
-
-mockMakeFetchHappen.mockResponseOnce = (
-  data?: BodyInit,
-  headers?: Headers,
-  status: number = 200,
-) => {
-  return mockMakeFetchHappen.mockImplementationOnce(async () => {
-    return new Response(data, {
-      status,
-      headers,
-    });
-  });
-};
-
-mockMakeFetchHappen.mockJSONResponseOnce = (
-  data = {},
-  headers?: Headers,
-  status?: number,
-) => {
-  return mockMakeFetchHappen.mockResponseOnce(
-    JSON.stringify(data),
-    Object.assign({ 'Content-Type': 'application/json' }, headers),
-    status,
-  );
-};
-
-const makeFetchMock = {
-  fetch: mockMakeFetchHappen,
-  defaults,
-};
-
-jest.doMock('make-fetch-happen', () => makeFetchMock);
-
-export = makeFetchMock;

package/src/cache.ts

@@ -1,66 +0,0 @@
-import { CacheManager } from 'make-fetch-happen';
-import { Request, Response, Headers } from 'apollo-server-env';
-import { InMemoryLRUCache } from 'apollo-server-caching';
-
-const MAX_SIZE = 5 * 1024 * 1024; // 5MB
-
-function cacheKey(request: Request) {
-  return `gateway:request-cache:${request.method}:${request.url}`;
-}
-
-interface CachedRequest {
-    body: string;
-    status: number;
-    statusText: string;
-    headers: Headers;
-}
-
-export class HttpRequestCache implements CacheManager {
-  constructor(
-    public cache: InMemoryLRUCache<CachedRequest> = new InMemoryLRUCache({
-      maxSize: MAX_SIZE,
-    }),
-  ) {}
-
-  // Return true if entry exists, else false
-  async delete(request: Request) {
-    const key = cacheKey(request);
-    const entry = await this.cache.get(key);
-    await this.cache.delete(key);
-    return Boolean(entry);
-  }
-
-  async put(request: Request, response: Response) {
-    // A `HEAD` request has no body to cache and a 304 response could have
-    // only been negotiated by using a cached body that was still valid.
-    // Therefore, we do NOT write to the cache in either of these cases.
-    // Without avoiding this, we will invalidate the cache, thus causing
-    // subsequent conditional requests (e.g., `If-None-Match: "MD%") to be
-    // lacking content to conditionally request against and necessitating
-    // a full request/response.
-    if (request.method === "HEAD" || response.status === 304) {
-      return response;
-    }
-
-    const body = await response.text();
-
-    this.cache.set(cacheKey(request), {
-      body,
-      status: response.status,
-      statusText: response.statusText,
-      headers: response.headers,
-    });
-
-    return new Response(body, response);
-  }
-
-  async match(request: Request) {
-    return this.cache.get(cacheKey(request)).then(response => {
-      if (response) {
-        const { body, ...requestInit } = response;
-        return new Response(body, requestInit);
-      }
-      return;
-    });
-  }
-}

package/src/make-fetch-happen.d.ts

@@ -1,59 +0,0 @@
-/**
- * We are attempting to get types included natively in this package, but it
- * has not happened, yet!
- *
- * See https://github.com/npm/make-fetch-happen/issues/20
- */
-declare module 'make-fetch-happen' {
-  import {
-    Response,
-    Request,
-    RequestInfo,
-    RequestInit,
-  } from 'apollo-server-env';
-
-  // If adding to these options, they should mirror those from `make-fetch-happen`
-  // @see: https://github.com/npm/make-fetch-happen/#extra-options
-  export interface FetcherOptions {
-    cacheManager?: string | CacheManager;
-    // @see: https://www.npmjs.com/package/retry#retrytimeoutsoptions
-    retry?:
-      | boolean
-      | number
-      | {
-          //  The maximum amount of times to retry the operation. Default is 10. Seting this to 1 means do it once, then retry it once
-          retries?: number;
-          // The exponential factor to use. Default is 2.
-          factor?: number;
-          // The number of milliseconds before starting the first retry. Default is 1000.
-          minTimeout?: number;
-          // The maximum number of milliseconds between two retries. Default is Infinity.
-          maxTimeout?: number;
-          // Randomizes the timeouts by multiplying with a factor between 1 to 2. Default is false.
-          randomize?: boolean;
-        };
-    onRetry?(): void;
-  }
-
-  export interface CacheManager {
-    delete(req: Request): Promise<Boolean>;
-    put(req: Request, res: Response): Promise<Response>;
-    match(req: Request): Promise<Response | undefined>;
-  }
-
-  /**
-   * This is an augmentation of the fetch function types provided by `apollo-server-env`
-   * @see: https://git.io/JvBwX
-   */
-  export interface Fetcher {
-    (input?: RequestInfo, init?: RequestInit & FetcherOptions): Promise<
-      Response
-    >;
-  }
-
-  let fetch: Fetcher & {
-    defaults(opts?: RequestInit & FetcherOptions): typeof fetch;
-  };
-
-  export default fetch;
-}