Add an HTTP client which uses fetch. (#1236)

.eslintrc.js

@@ -25,7 +25,7 @@ module.exports = {
       },
     ],
     'capitalized-comments': 'off',
-    'class-methods-use-this': 'error',
+    'class-methods-use-this': 'off',
     'comma-dangle': 'off',
     'comma-spacing': 'off',
     'comma-style': ['error', 'last'],

lib/net/FetchHttpClient.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const {HttpClient, HttpClientResponse} = require('./HttpClient');
+
+/**
+ * HTTP client which uses a `fetch` function to issue requests. This fetch
+ * function is expected to be the Web Fetch API function or an equivalent, such
+ * as the function provided by the node-fetch package (https://github.com/node-fetch/node-fetch).
+ */
+class FetchHttpClient extends HttpClient {
+  constructor(fetchFn) {
+    super();
+    this._fetchFn = fetchFn;
+  }
+
+  /** @override. */
+  getClientName() {
+    return 'fetch';
+  }
+
+  makeRequest(
+    host,
+    port,
+    path,
+    method,
+    headers,
+    requestData,
+    protocol,
+    timeout
+  ) {
+    const isInsecureConnection = protocol === 'http';
+
+    const url = new URL(
+      path,
+      `${isInsecureConnection ? 'http' : 'https'}://${host}`
+    );
+    url.port = port;
+
+    const fetchPromise = this._fetchFn(url.toString(), {
+      method,
+      headers,
+      body: requestData || undefined,
+    });
+
+    // The Fetch API does not support passing in a timeout natively, so a
+    // timeout promise is constructed to race against the fetch and preempt the
+    // request, simulating a timeout.
+    //
+    // This timeout behavior differs from Node:
+    // - Fetch uses a single timeout for the entire length of the request.
+    // - Node is more fine-grained and resets the timeout after each stage of
+    //   the request.
+    //
+    // As an example, if the timeout is set to 30s and the connection takes 20s
+    // to be established followed by 20s for the body, Fetch would timeout but
+    // Node would not. The more fine-grained timeout cannot be implemented with
+    // fetch.
+    let pendingTimeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+      pendingTimeoutId = setTimeout(() => {
+        pendingTimeoutId = null;
+        reject(HttpClient.makeTimeoutError());
+      }, timeout);
+    });
+
+    return Promise.race([fetchPromise, timeoutPromise])
+      .then((res) => {
+        return new FetchHttpClientResponse(res);
+      })
+      .finally(() => {
+        if (pendingTimeoutId) {
+          clearTimeout(pendingTimeoutId);
+        }
+      });
+  }
+}
+
+class FetchHttpClientResponse extends HttpClientResponse {
+  constructor(res) {
+    super(
+      res.status,
+      FetchHttpClientResponse._transformHeadersToObject(res.headers)
+    );
+    this._res = res;
+  }
+
+  getRawResponse() {
+    return this._res;
+  }
+
+  toStream(streamCompleteCallback) {
+    // Unfortunately `fetch` does not have event handlers for when the stream is
+    // completely read. We therefore invoke the streamCompleteCallback right
+    // away. This callback emits a response event with metadata and completes
+    // metrics, so it's ok to do this without waiting for the stream to be
+    // completely read.
+    streamCompleteCallback();
+
+    // Fetch's `body` property is expected to be a readable stream of the body.
+    return this._res.body;
+  }
+
+  toJSON() {
+    return this._res.json();
+  }
+
+  static _transformHeadersToObject(headers) {
+    // Fetch uses a Headers instance so this must be converted to a barebones
+    // JS object to meet the HttpClient interface.
+    const headersObj = {};
+
+    for (const entry of headers) {
+      if (!Array.isArray(entry) || entry.length != 2) {
+        throw new Error(
+          'Response objects produced by the fetch function given to FetchHttpClient do not have an iterable headers map. Response#headers should be an iterable object.'
+        );
+      }
+
+      headersObj[entry[0]] = entry[1];
+    }
+
+    return headersObj;
+  }
+}
+
+module.exports = {FetchHttpClient, FetchHttpClientResponse};

lib/net/HttpClient.js

@@ -1,7 +1,5 @@
 'use strict';
 
-/* eslint-disable class-methods-use-this */
-
 /**
  * Encapsulates the logic for issuing a request to the Stripe API. This is an
  * experimental interface and is not yet stable.

lib/net/NodeHttpClient.js

@@ -1,7 +1,5 @@
 'use strict';
 
-/* eslint-disable class-methods-use-this */
-
 const http = require('http');
 const https = require('https');
 

package.json

@@ -39,6 +39,7 @@
     "mocha": "^8.3.2",
     "mocha-junit-reporter": "^1.23.1",
     "nock": "^13.1.1",
+    "node-fetch": "^2.6.2",
     "nyc": "^15.1.0",
     "prettier": "^1.16.4",
     "typescript": "^3.7.2"

test/net/FetchHttpClient.spec.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const expect = require('chai').expect;
+const fetch = require('node-fetch');
+const {Readable} = require('stream');
+const {FetchHttpClient} = require('../../lib/net/FetchHttpClient');
+
+const createFetchHttpClient = () => {
+  return new FetchHttpClient(fetch);
+};
+
+const {createHttpClientTestSuite, ArrayReadable} = require('./helpers');
+
+createHttpClientTestSuite(
+  'FetchHttpClient',
+  createFetchHttpClient,
+  (setupNock, sendRequest) => {
+    describe('raw stream', () => {
+      it('getRawResponse()', async () => {
+        setupNock().reply(200);
+        const response = await sendRequest();
+        expect(response.getRawResponse()).to.be.an.instanceOf(fetch.Response);
+      });
+
+      it('toStream returns the body as a stream', async () => {
+        setupNock().reply(200, () => new ArrayReadable(['hello, world!']));
+
+        const response = await sendRequest();
+
+        return new Promise((resolve) => {
+          const stream = response.toStream(() => true);
+
+          // node-fetch returns a Node Readable here. In a Web API context, this
+          // would be a Web ReadableStream.
+          expect(stream).to.be.an.instanceOf(Readable);
+
+          let streamedContent = '';
+          stream.on('data', (chunk) => {
+            streamedContent += chunk;
+          });
+          stream.on('end', () => {
+            expect(streamedContent).to.equal('hello, world!');
+            resolve();
+          });
+        });
+      });
+
+      it('toStream invokes the streamCompleteCallback', async () => {
+        setupNock().reply(200, () => new ArrayReadable(['hello, world!']));
+
+        const response = await sendRequest();
+
+        return new Promise((resolve) => {
+          response.toStream(() => {
+            resolve();
+          });
+        });
+      });
+    });
+  }
+);