@depup/stripe 21.0.0-depup.0

package/cjs/autoPagination.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAutoPaginationMethods = void 0;
+const utils_js_1 = require("./utils.js");
+class V1Iterator {
+    constructor(firstPagePromise, requestArgs, spec, stripeResource) {
+        this.index = 0;
+        this.pagePromise = firstPagePromise;
+        this.promiseCache = { currentPromise: null };
+        this.requestArgs = requestArgs;
+        this.spec = spec;
+        this.stripeResource = stripeResource;
+    }
+    async iterate(pageResult) {
+        if (!(pageResult &&
+            pageResult.data &&
+            typeof pageResult.data.length === 'number')) {
+            throw Error('Unexpected: Stripe API response does not have a well-formed `data` array.');
+        }
+        const reverseIteration = isReverseIteration(this.requestArgs);
+        if (this.index < pageResult.data.length) {
+            const idx = reverseIteration
+                ? pageResult.data.length - 1 - this.index
+                : this.index;
+            const value = pageResult.data[idx];
+            this.index += 1;
+            return { value, done: false };
+        }
+        else if (pageResult.has_more) {
+            // Reset counter, request next page, and recurse.
+            this.index = 0;
+            this.pagePromise = this.getNextPage(pageResult);
+            const nextPageResult = await this.pagePromise;
+            return this.iterate(nextPageResult);
+        }
+        return { done: true, value: undefined };
+    }
+    /** @abstract */
+    getNextPage(_pageResult) {
+        throw new Error('Unimplemented');
+    }
+    async _next() {
+        return this.iterate(await this.pagePromise);
+    }
+    next() {
+        /**
+         * If a user calls `.next()` multiple times in parallel,
+         * return the same result until something has resolved
+         * to prevent page-turning race conditions.
+         */
+        if (this.promiseCache.currentPromise) {
+            return this.promiseCache.currentPromise;
+        }
+        const nextPromise = (async () => {
+            const ret = await this._next();
+            this.promiseCache.currentPromise = null;
+            return ret;
+        })();
+        this.promiseCache.currentPromise = nextPromise;
+        return nextPromise;
+    }
+}
+class V1ListIterator extends V1Iterator {
+    getNextPage(pageResult) {
+        const reverseIteration = isReverseIteration(this.requestArgs);
+        const lastId = getLastId(pageResult, reverseIteration);
+        return this.stripeResource._makeRequest(this.requestArgs, this.spec, {
+            [reverseIteration ? 'ending_before' : 'starting_after']: lastId,
+        });
+    }
+}
+class V1SearchIterator extends V1Iterator {
+    getNextPage(pageResult) {
+        if (!pageResult.next_page) {
+            throw Error('Unexpected: Stripe API response does not have a well-formed `next_page` field, but `has_more` was true.');
+        }
+        return this.stripeResource._makeRequest(this.requestArgs, this.spec, {
+            page: pageResult.next_page,
+        });
+    }
+}
+class V2ListIterator {
+    constructor(firstPagePromise, requestArgs, spec, stripeResource) {
+        this.firstPagePromise = firstPagePromise;
+        this.currentPageIterator = null;
+        this.nextPageUrl = null;
+        this.requestArgs = requestArgs;
+        this.spec = spec;
+        this.stripeResource = stripeResource;
+    }
+    async initFirstPage() {
+        if (this.firstPagePromise) {
+            const page = await this.firstPagePromise;
+            this.firstPagePromise = null;
+            this.currentPageIterator = page.data[Symbol.iterator]();
+            this.nextPageUrl = page.next_page_url || null;
+        }
+    }
+    async turnPage() {
+        if (!this.nextPageUrl)
+            return null;
+        this.spec.fullPath = this.nextPageUrl;
+        const page = await this.stripeResource._makeRequest([], this.spec, {});
+        this.nextPageUrl = page.next_page_url || null;
+        this.currentPageIterator = page.data[Symbol.iterator]();
+        return this.currentPageIterator;
+    }
+    async next() {
+        await this.initFirstPage();
+        if (this.currentPageIterator) {
+            const result = this.currentPageIterator.next();
+            if (!result.done)
+                return { done: false, value: result.value };
+        }
+        const nextPageIterator = await this.turnPage();
+        if (!nextPageIterator) {
+            return { done: true, value: undefined };
+        }
+        const result = nextPageIterator.next();
+        if (!result.done)
+            return { done: false, value: result.value };
+        return { done: true, value: undefined };
+    }
+}
+const makeAutoPaginationMethods = (stripeResource, requestArgs, spec, firstPagePromise) => {
+    const apiMode = (0, utils_js_1.getAPIMode)(spec.fullPath || spec.path);
+    if (apiMode !== 'v2' && spec.methodType === 'search') {
+        return makeAutoPaginationMethodsFromIterator(new V1SearchIterator(firstPagePromise, requestArgs, spec, stripeResource));
+    }
+    if (apiMode !== 'v2' && spec.methodType === 'list') {
+        return makeAutoPaginationMethodsFromIterator(new V1ListIterator(firstPagePromise, requestArgs, spec, stripeResource));
+    }
+    if (apiMode === 'v2' && spec.methodType === 'list') {
+        return makeAutoPaginationMethodsFromIterator(new V2ListIterator(firstPagePromise, requestArgs, spec, stripeResource));
+    }
+    return null;
+};
+exports.makeAutoPaginationMethods = makeAutoPaginationMethods;
+const makeAutoPaginationMethodsFromIterator = (iterator) => {
+    const autoPagingEach = makeAutoPagingEach((...args) => iterator.next(...args));
+    const autoPagingToArray = makeAutoPagingToArray(autoPagingEach);
+    const autoPaginationMethods = {
+        autoPagingEach,
+        autoPagingToArray,
+        // Async iterator functions:
+        next: () => iterator.next(),
+        return: () => {
+            // This is required for `break`.
+            return {};
+        },
+        [getAsyncIteratorSymbol()]: () => {
+            return autoPaginationMethods;
+        },
+    };
+    return autoPaginationMethods;
+};
+/**
+ * ----------------
+ * Private Helpers:
+ * ----------------
+ */
+function getAsyncIteratorSymbol() {
+    if (typeof Symbol !== 'undefined' && Symbol.asyncIterator) {
+        return Symbol.asyncIterator;
+    }
+    // Follow the convention from libraries like iterall: https://github.com/leebyron/iterall#asynciterator-1
+    return '@@asyncIterator';
+}
+function getDoneCallback(args) {
+    if (args.length < 2) {
+        return null;
+    }
+    const onDone = args[1];
+    if (typeof onDone !== 'function') {
+        throw Error(`The second argument to autoPagingEach, if present, must be a callback function; received ${typeof onDone}`);
+    }
+    return onDone;
+}
+/**
+ * We allow four forms of the `onItem` callback (the middle two being equivalent),
+ *
+ *   1. `.autoPagingEach((item) => { doSomething(item); return false; });`
+ *   2. `.autoPagingEach(async (item) => { await doSomething(item); return false; });`
+ *   3. `.autoPagingEach((item) => doSomething(item).then(() => false));`
+ *   4. `.autoPagingEach((item, next) => { doSomething(item); next(false); });`
+ *
+ * In addition to standard validation, this helper
+ * coalesces the former forms into the latter form.
+ */
+function getItemCallback(args) {
+    if (args.length === 0) {
+        return undefined;
+    }
+    const onItem = args[0];
+    if (typeof onItem !== 'function') {
+        throw Error(`The first argument to autoPagingEach, if present, must be a callback function; received ${typeof onItem}`);
+    }
+    // 4. `.autoPagingEach((item, next) => { doSomething(item); next(false); });`
+    if (onItem.length === 2) {
+        return onItem;
+    }
+    if (onItem.length > 2) {
+        throw Error(`The \`onItem\` callback function passed to autoPagingEach must accept at most two arguments; got ${onItem}`);
+    }
+    // This magically handles all three of these usecases (the latter two being functionally identical):
+    // 1. `.autoPagingEach((item) => { doSomething(item); return false; });`
+    // 2. `.autoPagingEach(async (item) => { await doSomething(item); return false; });`
+    // 3. `.autoPagingEach((item) => doSomething(item).then(() => false));`
+    return function _onItem(item, next) {
+        const shouldContinue = onItem(item);
+        next(shouldContinue);
+    };
+}
+function getLastId(listResult, reverseIteration) {
+    const lastIdx = reverseIteration ? 0 : listResult.data.length - 1;
+    const lastItem = listResult.data[lastIdx];
+    const lastId = lastItem && lastItem.id;
+    if (!lastId) {
+        throw Error('Unexpected: No `id` found on the last item while auto-paging a list.');
+    }
+    return lastId;
+}
+function makeAutoPagingEach(asyncIteratorNext) {
+    return function autoPagingEach( /* onItem?, onDone? */) {
+        const args = [].slice.call(arguments);
+        const onItem = getItemCallback(args);
+        const onDone = getDoneCallback(args);
+        if (args.length > 2) {
+            throw Error(`autoPagingEach takes up to two arguments; received ${args}`);
+        }
+        const autoPagePromise = wrapAsyncIteratorWithCallback(asyncIteratorNext, 
+        // @ts-ignore we might need a null check
+        onItem);
+        return (0, utils_js_1.callbackifyPromiseWithTimeout)(autoPagePromise, onDone);
+    };
+}
+function makeAutoPagingToArray(autoPagingEach) {
+    return function autoPagingToArray(opts, onDone) {
+        const limit = opts && opts.limit;
+        if (!limit) {
+            throw Error('You must pass a `limit` option to autoPagingToArray, e.g., `autoPagingToArray({limit: 1000});`.');
+        }
+        if (limit > 10000) {
+            throw Error('You cannot specify a limit of more than 10,000 items to fetch in `autoPagingToArray`; use `autoPagingEach` to iterate through longer lists.');
+        }
+        const promise = new Promise((resolve, reject) => {
+            const items = [];
+            autoPagingEach((item) => {
+                items.push(item);
+                if (items.length >= limit) {
+                    return false;
+                }
+            })
+                .then(() => {
+                resolve(items);
+            })
+                .catch(reject);
+        });
+        // @ts-ignore
+        return (0, utils_js_1.callbackifyPromiseWithTimeout)(promise, onDone);
+    };
+}
+function wrapAsyncIteratorWithCallback(asyncIteratorNext, onItem) {
+    return new Promise((resolve, reject) => {
+        function handleIteration(iterResult) {
+            if (iterResult.done) {
+                resolve();
+                return;
+            }
+            const item = iterResult.value;
+            return new Promise((next) => {
+                // Bit confusing, perhaps; we pass a `resolve` fn
+                // to the user, so they can decide when and if to continue.
+                // They can return false, or a promise which resolves to false, to break.
+                onItem(item, next);
+            }).then((shouldContinue) => {
+                if (shouldContinue === false) {
+                    return handleIteration({ done: true, value: undefined });
+                }
+                else {
+                    return asyncIteratorNext().then(handleIteration);
+                }
+            });
+        }
+        asyncIteratorNext()
+            .then(handleIteration)
+            .catch(reject);
+    });
+}
+function isReverseIteration(requestArgs) {
+    const args = [].slice.call(requestArgs);
+    const dataFromArgs = (0, utils_js_1.getDataFromArgs)(args);
+    return !!dataFromArgs.ending_before;
+}

package/cjs/crypto/CryptoProvider.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoProviderOnlySupportsAsyncError = exports.CryptoProvider = void 0;
+/**
+ * Interface encapsulating the various crypto computations used by the library,
+ * allowing pluggable underlying crypto implementations.
+ */
+class CryptoProvider {
+    /**
+     * Computes a SHA-256 HMAC given a secret and a payload (encoded in UTF-8).
+     * The output HMAC should be encoded in hexadecimal.
+     *
+     * Sample values for implementations:
+     * - computeHMACSignature('', 'test_secret') => 'f7f9bd47fb987337b5796fdc1fdb9ba221d0d5396814bfcaf9521f43fd8927fd'
+     * - computeHMACSignature('\ud83d\ude00', 'test_secret') => '837da296d05c4fe31f61d5d7ead035099d9585a5bcde87de952012a78f0b0c43
+     */
+    computeHMACSignature(payload, secret) {
+        throw new Error('computeHMACSignature not implemented.');
+    }
+    /**
+     * Asynchronous version of `computeHMACSignature`. Some implementations may
+     * only allow support async signature computation.
+     *
+     * Computes a SHA-256 HMAC given a secret and a payload (encoded in UTF-8).
+     * The output HMAC should be encoded in hexadecimal.
+     *
+     * Sample values for implementations:
+     * - computeHMACSignature('', 'test_secret') => 'f7f9bd47fb987337b5796fdc1fdb9ba221d0d5396814bfcaf9521f43fd8927fd'
+     * - computeHMACSignature('\ud83d\ude00', 'test_secret') => '837da296d05c4fe31f61d5d7ead035099d9585a5bcde87de952012a78f0b0c43
+     */
+    computeHMACSignatureAsync(payload, secret) {
+        throw new Error('computeHMACSignatureAsync not implemented.');
+    }
+    /**
+     * Computes a SHA-256 hash of the data.
+     */
+    computeSHA256Async(data) {
+        throw new Error('computeSHA256 not implemented.');
+    }
+}
+exports.CryptoProvider = CryptoProvider;
+/**
+ * If the crypto provider only supports asynchronous operations,
+ * throw CryptoProviderOnlySupportsAsyncError instead of
+ * a generic error so that the caller can choose to provide
+ * a more helpful error message to direct the user to use
+ * an asynchronous pathway.
+ */
+class CryptoProviderOnlySupportsAsyncError extends Error {
+}
+exports.CryptoProviderOnlySupportsAsyncError = CryptoProviderOnlySupportsAsyncError;

package/cjs/crypto/NodeCryptoProvider.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeCryptoProvider = void 0;
+const crypto = require("crypto");
+const CryptoProvider_js_1 = require("./CryptoProvider.js");
+/**
+ * `CryptoProvider which uses the Node `crypto` package for its computations.
+ */
+class NodeCryptoProvider extends CryptoProvider_js_1.CryptoProvider {
+    /** @override */
+    computeHMACSignature(payload, secret) {
+        return crypto
+            .createHmac('sha256', secret)
+            .update(payload, 'utf8')
+            .digest('hex');
+    }
+    /** @override */
+    async computeHMACSignatureAsync(payload, secret) {
+        const signature = await this.computeHMACSignature(payload, secret);
+        return signature;
+    }
+    /** @override */
+    async computeSHA256Async(data) {
+        return new Uint8Array(await crypto
+            .createHash('sha256')
+            .update(data)
+            .digest());
+    }
+}
+exports.NodeCryptoProvider = NodeCryptoProvider;

package/cjs/crypto/SubtleCryptoProvider.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubtleCryptoProvider = void 0;
+const CryptoProvider_js_1 = require("./CryptoProvider.js");
+/**
+ * `CryptoProvider which uses the SubtleCrypto interface of the Web Crypto API.
+ *
+ * This only supports asynchronous operations.
+ */
+class SubtleCryptoProvider extends CryptoProvider_js_1.CryptoProvider {
+    constructor(subtleCrypto) {
+        super();
+        // If no subtle crypto is interface, default to the global namespace. This
+        // is to allow custom interfaces (eg. using the Node webcrypto interface in
+        // tests).
+        this.subtleCrypto = subtleCrypto || crypto.subtle;
+    }
+    /** @override */
+    computeHMACSignature(payload, secret) {
+        throw new CryptoProvider_js_1.CryptoProviderOnlySupportsAsyncError('SubtleCryptoProvider cannot be used in a synchronous context.');
+    }
+    /** @override */
+    async computeHMACSignatureAsync(payload, secret) {
+        const encoder = new TextEncoder();
+        const key = await this.subtleCrypto.importKey('raw', encoder.encode(secret), {
+            name: 'HMAC',
+            hash: { name: 'SHA-256' },
+        }, false, ['sign']);
+        const signatureBuffer = await this.subtleCrypto.sign('hmac', key, encoder.encode(payload));
+        // crypto.subtle returns the signature in base64 format. This must be
+        // encoded in hex to match the CryptoProvider contract. We map each byte in
+        // the buffer to its corresponding hex octet and then combine into a string.
+        const signatureBytes = new Uint8Array(signatureBuffer);
+        const signatureHexCodes = new Array(signatureBytes.length);
+        for (let i = 0; i < signatureBytes.length; i++) {
+            signatureHexCodes[i] = byteHexMapping[signatureBytes[i]];
+        }
+        return signatureHexCodes.join('');
+    }
+    /** @override */
+    async computeSHA256Async(data) {
+        return new Uint8Array(await this.subtleCrypto.digest('SHA-256', data));
+    }
+}
+exports.SubtleCryptoProvider = SubtleCryptoProvider;
+// Cached mapping of byte to hex representation. We do this once to avoid re-
+// computing every time we need to convert the result of a signature to hex.
+const byteHexMapping = new Array(256);
+for (let i = 0; i < byteHexMapping.length; i++) {
+    byteHexMapping[i] = i.toString(16).padStart(2, '0');
+}

package/cjs/multipart.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multipartRequestDataProcessor = void 0;
+const utils_js_1 = require("./utils.js");
+// Method for formatting HTTP body for the multipart/form-data specification
+// Mostly taken from Fermata.js
+// https://github.com/natevw/fermata/blob/5d9732a33d776ce925013a265935facd1626cc88/fermata.js#L315-L343
+const multipartDataGenerator = (method, data, headers) => {
+    const segno = (Math.round(Math.random() * 1e16) + Math.round(Math.random() * 1e16)).toString();
+    headers['Content-Type'] = `multipart/form-data; boundary=${segno}`;
+    const textEncoder = new TextEncoder();
+    let buffer = new Uint8Array(0);
+    const endBuffer = textEncoder.encode('\r\n');
+    function push(l) {
+        const prevBuffer = buffer;
+        const newBuffer = l instanceof Uint8Array ? l : new Uint8Array(textEncoder.encode(l));
+        buffer = new Uint8Array(prevBuffer.length + newBuffer.length + 2);
+        buffer.set(prevBuffer);
+        buffer.set(newBuffer, prevBuffer.length);
+        buffer.set(endBuffer, buffer.length - 2);
+    }
+    function q(s) {
+        return `"${s.replace(/"|"/g, '%22').replace(/\r\n|\r|\n/g, ' ')}"`;
+    }
+    const flattenedData = (0, utils_js_1.flattenAndStringify)(data);
+    for (const k in flattenedData) {
+        if (!Object.prototype.hasOwnProperty.call(flattenedData, k)) {
+            continue;
+        }
+        const v = flattenedData[k];
+        push(`--${segno}`);
+        if (Object.prototype.hasOwnProperty.call(v, 'data')) {
+            const typedEntry = v;
+            push(`Content-Disposition: form-data; name=${q(k)}; filename=${q(typedEntry.name || 'blob')}`);
+            push(`Content-Type: ${typedEntry.type || 'application/octet-stream'}`);
+            push('');
+            push(typedEntry.data);
+        }
+        else {
+            push(`Content-Disposition: form-data; name=${q(k)}`);
+            push('');
+            push(v);
+        }
+    }
+    push(`--${segno}--`);
+    return buffer;
+};
+function multipartRequestDataProcessor(method, data, headers, callback) {
+    data = data || {};
+    if (method !== 'POST') {
+        return callback(null, (0, utils_js_1.queryStringifyRequestData)(data));
+    }
+    this._stripe._platformFunctions
+        .tryBufferData(data)
+        .then((bufferedData) => {
+        const buffer = multipartDataGenerator(method, bufferedData, headers);
+        return callback(null, buffer);
+    })
+        .catch((err) => callback(err, null));
+}
+exports.multipartRequestDataProcessor = multipartRequestDataProcessor;

package/cjs/net/FetchHttpClient.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchHttpClientResponse = exports.FetchHttpClient = void 0;
+const utils_js_1 = require("../utils.js");
+const HttpClient_js_1 = require("./HttpClient.js");
+/**
+ * HTTP client which uses a `fetch` function to issue requests.
+ *
+ * By default relies on the global `fetch` function, but an optional function
+ * can be passed in. If passing in a function, it is expected to match the Web
+ * Fetch API. As an example, this could be the function provided by the
+ * node-fetch package (https://github.com/node-fetch/node-fetch).
+ */
+class FetchHttpClient extends HttpClient_js_1.HttpClient {
+    constructor(fetchFn) {
+        super();
+        // Default to global fetch if available
+        if (!fetchFn) {
+            if (!globalThis.fetch) {
+                throw new Error('fetch() function not provided and is not defined in the global scope. ' +
+                    'You must provide a fetch implementation.');
+            }
+            fetchFn = globalThis.fetch;
+        }
+        // Both timeout behaviors 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.
+        if (globalThis.AbortController) {
+            // Utilise native AbortController if available
+            // AbortController was added in Node v15.0.0, v14.17.0
+            this._fetchFn = FetchHttpClient.makeFetchWithAbortTimeout(fetchFn);
+        }
+        else {
+            // Fall back to racing against a timeout promise if not available in the runtime
+            // This does not actually cancel the underlying fetch operation or resources
+            this._fetchFn = FetchHttpClient.makeFetchWithRaceTimeout(fetchFn);
+        }
+    }
+    static makeFetchWithRaceTimeout(fetchFn) {
+        return (url, init, timeout) => {
+            let pendingTimeoutId;
+            const timeoutPromise = new Promise((_, reject) => {
+                pendingTimeoutId = setTimeout(() => {
+                    pendingTimeoutId = null;
+                    reject(HttpClient_js_1.HttpClient.makeTimeoutError());
+                }, timeout);
+            });
+            const fetchPromise = fetchFn(url, init);
+            return Promise.race([fetchPromise, timeoutPromise]).finally(() => {
+                if (pendingTimeoutId) {
+                    clearTimeout(pendingTimeoutId);
+                }
+            });
+        };
+    }
+    static makeFetchWithAbortTimeout(fetchFn) {
+        return async (url, init, timeout) => {
+            // Use AbortController because AbortSignal.timeout() was added later in Node v17.3.0, v16.14.0
+            const abort = new AbortController();
+            let timeoutId = setTimeout(() => {
+                timeoutId = null;
+                abort.abort(HttpClient_js_1.HttpClient.makeTimeoutError());
+            }, timeout);
+            try {
+                return await fetchFn(url, {
+                    ...init,
+                    signal: abort.signal,
+                });
+            }
+            catch (err) {
+                // Some implementations, like node-fetch, do not respect the reason passed to AbortController.abort()
+                // and instead it always throws an AbortError
+                // We catch this case to normalise all timeout errors
+                if (err.name === 'AbortError') {
+                    throw HttpClient_js_1.HttpClient.makeTimeoutError();
+                }
+                else {
+                    throw err;
+                }
+            }
+            finally {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+            }
+        };
+    }
+    /** @override. */
+    getClientName() {
+        return 'fetch';
+    }
+    async 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;
+        // For methods which expect payloads, we should always pass a body value
+        // even when it is empty. Without this, some JS runtimes (eg. Deno) will
+        // inject a second Content-Length header. See https://github.com/stripe/stripe-node/issues/1519
+        // for more details.
+        const methodHasPayload = method == 'POST' || method == 'PUT' || method == 'PATCH';
+        const body = requestData || (methodHasPayload ? '' : undefined);
+        const res = await this._fetchFn(url.toString(), {
+            method,
+            headers: (0, utils_js_1.parseHeadersForFetch)(headers),
+            body: body,
+        }, timeout);
+        return new FetchHttpClientResponse(res);
+    }
+}
+exports.FetchHttpClient = FetchHttpClient;
+class FetchHttpClientResponse extends HttpClient_js_1.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;
+    }
+}
+exports.FetchHttpClientResponse = FetchHttpClientResponse;

package/cjs/net/HttpClient.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClientResponse = exports.HttpClient = void 0;
+/**
+ * Encapsulates the logic for issuing a request to the Stripe API.
+ *
+ * A custom HTTP client should should implement:
+ * 1. A response class which extends HttpClientResponse and wraps around their
+ *    own internal representation of a response.
+ * 2. A client class which extends HttpClient and implements all methods,
+ *    returning their own response class when making requests.
+ */
+class HttpClient {
+    /** The client name used for diagnostics. */
+    getClientName() {
+        throw new Error('getClientName not implemented.');
+    }
+    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;
+    }
+}
+exports.HttpClient = HttpClient;
+// Public API accessible via Stripe.HttpClient
+HttpClient.CONNECTION_CLOSED_ERROR_CODES = ['ECONNRESET', 'EPIPE'];
+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.');
+    }
+}
+exports.HttpClientResponse = HttpClientResponse;