Add an HttpClient interface and NodeHttpClient implementation.

lib/net/HttpClient.js

@@ -0,0 +1,60 @@
+'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.
+ */
+class HttpClient {
+  makeRequest(
+    host,
+    port,
+    path,
+    method,
+    headers,
+    requestData,
+    protocol,
+    timeout
+  ) {
+    throw new Error('makeRequest not implemented.');
+  }
+
+  /** Helper to make a consistent timeout error across implementations. */
+  static makeTimeoutError() {
+    const timeoutErr = new TypeError(HttpClient.TIMEOUT_ERROR_CODE);
+    timeoutErr.code = HttpClient.TIMEOUT_ERROR_CODE;
+    return timeoutErr;
+  }
+}
+
+HttpClient.TIMEOUT_ERROR_CODE = 'ETIMEDOUT';
+
+class HttpClientResponse {
+  constructor(statusCode, headers) {
+    this._statusCode = statusCode;
+    this._headers = headers;
+  }
+
+  getStatusCode() {
+    return this._statusCode;
+  }
+
+  getHeaders() {
+    return this._headers;
+  }
+
+  getRawResponse() {
+    throw new Error('getRawResponse not implemented.');
+  }
+
+  toStream(streamCompleteCallback) {
+    throw new Error('toStream not implemented.');
+  }
+
+  toJSON() {
+    throw new Error('toJSON not implemented.');
+  }
+}
+
+module.exports = {HttpClient, HttpClientResponse};

lib/net/NodeHttpClient.js

@@ -0,0 +1,120 @@
+'use strict';
+
+const http = require('http');
+const https = require('https');
+
+const {HttpClient, HttpClientResponse} = require('./HttpClient');
+
+const defaultHttpAgent = new http.Agent({keepAlive: true});
+const defaultHttpsAgent = new https.Agent({keepAlive: true});
+
+/**
+ * HTTP client which uses the Node `http` and `https` packages to issue
+ * requests.`
+ */
+class NodeHttpClient extends HttpClient {
+  constructor(agent) {
+    super();
+    this._agent = agent;
+  }
+
+  makeRequest(
+    host,
+    port,
+    path,
+    method,
+    headers,
+    requestData,
+    protocol,
+    timeout
+  ) {
+    const isInsecureConnection = protocol === 'http';
+
+    let agent = this._agent;
+    if (!agent) {
+      agent = isInsecureConnection ? defaultHttpAgent : defaultHttpsAgent;
+    }
+
+    const requestPromise = new Promise((resolve, reject) => {
+      const req = (isInsecureConnection ? http : https).request({
+        host: host,
+        port: port,
+        path,
+        method,
+        agent,
+        headers,
+        ciphers: 'DEFAULT:!aNULL:!eNULL:!LOW:!EXPORT:!SSLv2:!MD5',
+      });
+
+      req.setTimeout(timeout, () => {
+        req.destroy(HttpClient.makeTimeoutError());
+      });
+
+      req.on('response', (res) => {
+        resolve(new NodeHttpClientResponse(res));
+      });
+
+      req.on('error', (error) => {
+        reject(error);
+      });
+
+      req.once('socket', (socket) => {
+        if (socket.connecting) {
+          socket.once(
+            isInsecureConnection ? 'connect' : 'secureConnect',
+            () => {
+              // Send payload; we're safe:
+              req.write(requestData);
+              req.end();
+            }
+          );
+        } else {
+          // we're already connected
+          req.write(requestData);
+          req.end();
+        }
+      });
+    });
+
+    return requestPromise;
+  }
+}
+
+class NodeHttpClientResponse extends HttpClientResponse {
+  constructor(res) {
+    super(res.statusCode, res.headers || {});
+    this._res = res;
+  }
+
+  getRawResponse() {
+    return this._res;
+  }
+
+  toStream(streamCompleteCallback) {
+    // The raw response is itself the stream, so we just return that. To be
+    // backwards comaptible, we should invoke the streamCompleteCallback only
+    // once the stream has been fully consumed.
+    this._res.once('end', () => streamCompleteCallback());
+    return this._res;
+  }
+
+  toJSON() {
+    return new Promise((resolve, reject) => {
+      let response = '';
+
+      this._res.setEncoding('utf8');
+      this._res.on('data', (chunk) => {
+        response += chunk;
+      });
+      this._res.once('end', () => {
+        try {
+          resolve(JSON.parse(response));
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+  }
+}
+
+module.exports = {NodeHttpClient, NodeHttpClientResponse};

lib/stripe.js

@@ -33,6 +33,7 @@ const ALLOWED_CONFIG_PROPERTIES = [
   'typescript',
   'maxNetworkRetries',
   'httpAgent',
+  'httpClient',
   'timeout',
   'host',
   'port',
@@ -49,6 +50,10 @@ const {emitWarning} = utils;
 Stripe.StripeResource = require('./StripeResource');
 Stripe.resources = resources;
 
+const {HttpClient, HttpClientResponse} = require('./net/HttpClient');
+Stripe.HttpClient = HttpClient;
+Stripe.HttpClientResponse = HttpClientResponse;
+
 function Stripe(key, config = {}) {
   if (!(this instanceof Stripe)) {
     return new Stripe(key, config);
@@ -79,6 +84,8 @@ function Stripe(key, config = {}) {
     );
   }
 
+  const agent = props.httpAgent || null;
+
   this._api = {
     auth: null,
     host: props.host || DEFAULT_HOST,
@@ -92,7 +99,8 @@ function Stripe(key, config = {}) {
       props.maxNetworkRetries,
       0
     ),
-    agent: props.httpAgent || null,
+    agent: agent,
+    httpClient: props.httpClient || Stripe.createNodeHttpClient(agent),
     dev: false,
     stripeAccount: props.stripeAccount || null,
   };
@@ -126,6 +134,11 @@ function Stripe(key, config = {}) {
 Stripe.errors = require('./Error');
 Stripe.webhooks = require('./Webhooks');
 
+Stripe.createNodeHttpClient = (agent) => {
+  const {NodeHttpClient} = require('./net/NodeHttpClient');
+  return new NodeHttpClient(agent);
+};
+
 Stripe.prototype = {
   /**
    * @deprecated will be removed in a future major version. Use the config object instead: