#389

Build # #389

Build Type

push

Committed by

Commit Message

<a href="https://github.com/stripe/stripe-node/commit/<a class=hub.com/stripe/stripe-node/commit/6d9aed0e9dae2b66a63f9368f9229e6b0fd8820a">6d9aed0e9<a href="https://github.com/stripe/stripe-node/commit/6d9aed0e9dae2b66a63f9368f9229e6b0fd8820a">">Merge </a><a class="double-link" href="https://github.com/stripe/stripe-node/commit/<a class="double-link" href="https://github.com/stripe/stripe-node/commit/623e4b7c167f20e8c044f34568c5f33fc2cc6bb8">623e4b7c1</a>">623e4b7c1</a><a href="https://github.com/stripe/stripe-node/commit/6d9aed0e9dae2b66a63f9368f9229e6b0fd8820a"> into 3dc8c54cf">3dc8c54cf</a>

Run Details

506 of 574 branches covered (88.15%)

Branch coverage included in aggregate %.

510 of 510 new or added lines in 104 files covered. (100.0%)

1662 of 1728 relevant lines covered (96.18%)

298.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.72

/cjs/RequestSender.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.RequestSender = void 0;
const Error_js_1 = require("./Error.js");
const utils_js_1 = require("./utils.js");
const HttpClient_js_1 = require("./net/HttpClient.js");
const MAX_RETRY_AFTER_WAIT = 60;
class RequestSender {
    constructor(stripe, maxBufferedRequestMetric) {
        this._stripe = stripe;
        this._maxBufferedRequestMetric = maxBufferedRequestMetric;
    }
    _addHeadersDirectlyToObject(obj, headers) {
        // For convenience, make some headers easily accessible on
        // lastResponse.
        // NOTE: Stripe responds with lowercase header names/keys.
        obj.requestId = headers['request-id'];
        obj.stripeAccount = obj.stripeAccount || headers['stripe-account'];
        obj.apiVersion = obj.apiVersion || headers['stripe-version'];
        obj.idempotencyKey = obj.idempotencyKey || headers['idempotency-key'];
    }
    _makeResponseEvent(requestEvent, statusCode, headers) {
        const requestEndTime = Date.now();
        const requestDurationMs = requestEndTime - requestEvent.request_start_time;
        return (0, utils_js_1.removeNullish)({
            api_version: headers['stripe-version'],
            account: headers['stripe-account'],
            idempotency_key: headers['idempotency-key'],
            method: requestEvent.method,
            path: requestEvent.path,
            status: statusCode,
            request_id: this._getRequestId(headers),
            elapsed: requestDurationMs,
            request_start_time: requestEvent.request_start_time,
            request_end_time: requestEndTime,
        });
    }
    _getRequestId(headers) {
        return headers['request-id'];
    }
    /**
     * Used by methods with spec.streaming === true. For these methods, we do not
     * buffer successful responses into memory or do parse them into stripe
     * objects, we delegate that all of that to the user and pass back the raw
     * http.Response object to the callback.
     *
     * (Unsuccessful responses shouldn't make it here, they should
     * still be buffered/parsed and handled by _jsonResponseHandler -- see
     * makeRequest)
     */
    _streamingResponseHandler(requestEvent, callback) {
        return (res) => {
            const headers = res.getHeaders();
            const streamCompleteCallback = () => {
                const responseEvent = this._makeResponseEvent(requestEvent, res.getStatusCode(), headers);
                this._stripe._emitter.emit('response', responseEvent);
                this._recordRequestMetrics(this._getRequestId(headers), responseEvent.elapsed);
            };
            const stream = res.toStream(streamCompleteCallback);
            // This is here for backwards compatibility, as the stream is a raw
            // HTTP response in Node and the legacy behavior was to mutate this
            // response.
            this._addHeadersDirectlyToObject(stream, headers);
            return callback(null, stream);
        };
    }
    /**
     * Default handler for Stripe responses. Buffers the response into memory,
     * parses the JSON and returns it (i.e. passes it to the callback) if there
     * is no "error" field. Otherwise constructs/passes an appropriate Error.
     */
    _jsonResponseHandler(requestEvent, callback) {
        return (res) => {
            const headers = res.getHeaders();
            const requestId = this._getRequestId(headers);
            const statusCode = res.getStatusCode();
            const responseEvent = this._makeResponseEvent(requestEvent, statusCode, headers);
            this._stripe._emitter.emit('response', responseEvent);
            res
                .toJSON()
                .then((jsonResponse) => {
                if (jsonResponse.error) {
                    let err;
                    // Convert OAuth error responses into a standard format
                    // so that the rest of the error logic can be shared
                    if (typeof jsonResponse.error === 'string') {
                        jsonResponse.error = {
                            type: jsonResponse.error,
                            message: jsonResponse.error_description,
                        };
                    }
                    jsonResponse.error.headers = headers;
                    jsonResponse.error.statusCode = statusCode;
                    jsonResponse.error.requestId = requestId;
                    if (statusCode === 401) {
                        err = new Error_js_1.StripeAuthenticationError(jsonResponse.error);
                    }
                    else if (statusCode === 403) {
                        err = new Error_js_1.StripePermissionError(jsonResponse.error);
                    }
                    else if (statusCode === 429) {
                        err = new Error_js_1.StripeRateLimitError(jsonResponse.error);
                    }
                    else {
                        err = Error_js_1.StripeError.generate(jsonResponse.error);
                    }
                    throw err;
                }
                return jsonResponse;
            }, (e) => {
                throw new Error_js_1.StripeAPIError({
                    message: 'Invalid JSON received from the Stripe API',
                    exception: e,
                    requestId: headers['request-id'],
                });
            })
                .then((jsonResponse) => {
                this._recordRequestMetrics(requestId, responseEvent.elapsed);
                // Expose raw response object.
                const rawResponse = res.getRawResponse();
                this._addHeadersDirectlyToObject(rawResponse, headers);
                Object.defineProperty(jsonResponse, 'lastResponse', {
                    enumerable: false,
                    writable: false,
                    value: rawResponse,
                });
                callback(null, jsonResponse);
            }, (e) => callback(e, null));
        };
    }
    static _generateConnectionErrorMessage(requestRetries) {
        return `An error occurred with our connection to Stripe.${requestRetries > 0 ? ` Request was retried ${requestRetries} times.` : ''}`;
    }
    // For more on when and how to retry API requests, see https://stripe.com/docs/error-handling#safely-retrying-requests-with-idempotency
    static _shouldRetry(res, numRetries, maxRetries, error) {
        if (error &&
            numRetries === 0 &&
            HttpClient_js_1.HttpClient.CONNECTION_CLOSED_ERROR_CODES.includes(error.code)) {
            return true;
        }
        // Do not retry if we are out of retries.
        if (numRetries >= maxRetries) {
            return false;
        }
        // Retry on connection error.
        if (!res) {
            return true;
        }
        // The API may ask us not to retry (e.g., if doing so would be a no-op)
        // or advise us to retry (e.g., in cases of lock timeouts); we defer to that.
        if (res.getHeaders()['stripe-should-retry'] === 'false') {
            return false;
        }
        if (res.getHeaders()['stripe-should-retry'] === 'true') {
            return true;
        }
        // Retry on conflict errors.
        if (res.getStatusCode() === 409) {
            return true;
        }
        // Retry on 500, 503, and other internal errors.
        //
        // Note that we expect the stripe-should-retry header to be false
        // in most cases when a 500 is returned, since our idempotency framework
        // would typically replay it anyway.
        if (res.getStatusCode() >= 500) {
            return true;
        }
        return false;
    }
    _getSleepTimeInMS(numRetries, retryAfter = null) {
        const initialNetworkRetryDelay = this._stripe.getInitialNetworkRetryDelay();
        const maxNetworkRetryDelay = this._stripe.getMaxNetworkRetryDelay();
        // Apply exponential backoff with initialNetworkRetryDelay on the
        // number of numRetries so far as inputs. Do not allow the number to exceed
        // maxNetworkRetryDelay.
        let sleepSeconds = Math.min(initialNetworkRetryDelay * Math.pow(numRetries - 1, 2), maxNetworkRetryDelay);
        // Apply some jitter by randomizing the value in the range of
        // (sleepSeconds / 2) to (sleepSeconds).
        sleepSeconds *= 0.5 * (1 + Math.random());
        // But never sleep less than the base sleep seconds.
        sleepSeconds = Math.max(initialNetworkRetryDelay, sleepSeconds);
        // And never sleep less than the time the API asks us to wait, assuming it's a reasonable ask.
        if (Number.isInteger(retryAfter) && retryAfter <= MAX_RETRY_AFTER_WAIT) {
            sleepSeconds = Math.max(sleepSeconds, retryAfter);
        }
        return sleepSeconds * 1000;
    }
    // Max retries can be set on a per request basis. Favor those over the global setting
    _getMaxNetworkRetries(settings = {}) {
        return settings.maxNetworkRetries &&
            Number.isInteger(settings.maxNetworkRetries)
            ? settings.maxNetworkRetries
            : this._stripe.getMaxNetworkRetries();
    }
    _defaultIdempotencyKey(method, settings) {
        // If this is a POST and we allow multiple retries, ensure an idempotency key.
        const maxRetries = this._getMaxNetworkRetries(settings);
        if (method === 'POST' && maxRetries > 0) {
            return `stripe-node-retry-${this._stripe._platformFunctions.uuid4()}`;
        }
        return null;
    }
    _makeHeaders(auth, contentLength, apiVersion, clientUserAgent, method, userSuppliedHeaders, userSuppliedSettings) {
        const defaultHeaders = {
            // Use specified auth token or use default from this stripe instance:
            Authorization: auth ? `Bearer ${auth}` : this._stripe.getApiField('auth'),
            Accept: 'application/json',
            'Content-Type': 'application/x-www-form-urlencoded',
            'User-Agent': this._getUserAgentString(),
            'X-Stripe-Client-User-Agent': clientUserAgent,
            'X-Stripe-Client-Telemetry': this._getTelemetryHeader(),
            'Stripe-Version': apiVersion,
            'Stripe-Account': this._stripe.getApiField('stripeAccount'),
            'Idempotency-Key': this._defaultIdempotencyKey(method, userSuppliedSettings),
        };
        // As per https://datatracker.ietf.org/doc/html/rfc7230#section-3.3.2:
        //   A user agent SHOULD send a Content-Length in a request message when
        //   no Transfer-Encoding is sent and the request method defines a meaning
        //   for an enclosed payload body.  For example, a Content-Length header
        //   field is normally sent in a POST request even when the value is 0
        //   (indicating an empty payload body).  A user agent SHOULD NOT send a
        //   Content-Length header field when the request message does not contain
        //   a payload body and the method semantics do not anticipate such a
        //   body.
        //
        // These method types are expected to have bodies and so we should always
        // include a Content-Length.
        const methodHasPayload = method == 'POST' || method == 'PUT' || method == 'PATCH';
        // If a content length was specified, we always include it regardless of
        // whether the method semantics anticipate such a body. This keeps us
        // consistent with historical behavior. We do however want to warn on this
        // and fix these cases as they are semantically incorrect.
        if (methodHasPayload || contentLength) {
            if (!methodHasPayload) {
                (0, utils_js_1.emitWarning)(`${method} method had non-zero contentLength but no payload is expected for this verb`);
            }
            defaultHeaders['Content-Length'] = contentLength;
        }
        return Object.assign((0, utils_js_1.removeNullish)(defaultHeaders), 
        // If the user supplied, say 'idempotency-key', override instead of appending by ensuring caps are the same.
        (0, utils_js_1.normalizeHeaders)(userSuppliedHeaders));
    }
    _getUserAgentString() {
        const packageVersion = this._stripe.getConstant('PACKAGE_VERSION');
        const appInfo = this._stripe._appInfo
            ? this._stripe.getAppInfoAsString()
            : '';
        return `Stripe/v1 NodeBindings/${packageVersion} ${appInfo}`.trim();
    }
    _getTelemetryHeader() {
        if (this._stripe.getTelemetryEnabled() &&
            this._stripe._prevRequestMetrics.length > 0) {
            const metrics = this._stripe._prevRequestMetrics.shift();
            return JSON.stringify({
                last_request_metrics: metrics,
            });
        }
    }
    _recordRequestMetrics(requestId, requestDurationMs) {
        if (this._stripe.getTelemetryEnabled() && requestId) {
            if (this._stripe._prevRequestMetrics.length > this._maxBufferedRequestMetric) {
                (0, utils_js_1.emitWarning)('Request metrics buffer is full, dropping telemetry message.');
            }
            else {
                this._stripe._prevRequestMetrics.push({
                    request_id: requestId,
                    request_duration_ms: requestDurationMs,
                });
            }
        }
    }
    _request(method, host, path, data, auth, options = {}, callback, requestDataProcessor = null) {
        let requestData;
        const retryRequest = (requestFn, apiVersion, headers, requestRetries, retryAfter) => {
            return setTimeout(requestFn, this._getSleepTimeInMS(requestRetries, retryAfter), apiVersion, headers, requestRetries + 1);
        };
        const makeRequest = (apiVersion, headers, numRetries) => {
            // timeout can be set on a per-request basis. Favor that over the global setting
            const timeout = options.settings &&
                options.settings.timeout &&
                Number.isInteger(options.settings.timeout) &&
                options.settings.timeout >= 0
                ? options.settings.timeout
                : this._stripe.getApiField('timeout');
            const req = this._stripe
                .getApiField('httpClient')
                .makeRequest(host || this._stripe.getApiField('host'), this._stripe.getApiField('port'), path, method, headers, requestData, this._stripe.getApiField('protocol'), timeout);
            const requestStartTime = Date.now();
            // @ts-ignore
            const requestEvent = (0, utils_js_1.removeNullish)({
                api_version: apiVersion,
                account: headers['Stripe-Account'],
                idempotency_key: headers['Idempotency-Key'],
                method,
                path,
                request_start_time: requestStartTime,
            });
            const requestRetries = numRetries || 0;
            const maxRetries = this._getMaxNetworkRetries(options.settings || {});
            this._stripe._emitter.emit('request', requestEvent);
            req
                .then((res) => {
                if (RequestSender._shouldRetry(res, requestRetries, maxRetries)) {
                    return retryRequest(makeRequest, apiVersion, headers, requestRetries, 
                    // @ts-ignore
                    res.getHeaders()['retry-after']);
                }
                else if (options.streaming && res.getStatusCode() < 400) {
                    return this._streamingResponseHandler(requestEvent, callback)(res);
                }
                else {
                    return this._jsonResponseHandler(requestEvent, callback)(res);
                }
            })
                .catch((error) => {
                if (RequestSender._shouldRetry(null, requestRetries, maxRetries, error)) {
                    return retryRequest(makeRequest, apiVersion, headers, requestRetries, null);
                }
                else {
                    const isTimeoutError = error.code && error.code === HttpClient_js_1.HttpClient.TIMEOUT_ERROR_CODE;
                    return callback(new Error_js_1.StripeConnectionError({
                        message: isTimeoutError
                            ? `Request aborted due to timeout being reached (${timeout}ms)`
                            : RequestSender._generateConnectionErrorMessage(requestRetries),
                        // @ts-ignore
                        detail: error,
                    }));
                }
            });
        };
        const prepareAndMakeRequest = (error, data) => {
            if (error) {
                return callback(error);
            }
            requestData = data;
            this._stripe.getClientUserAgent((clientUserAgent) => {
                var _a, _b;
                const apiVersion = this._stripe.getApiField('version');
                const headers = this._makeHeaders(auth, requestData.length, apiVersion, clientUserAgent, method, (_a = options.headers) !== null && _a !== void 0 ? _a : null, (_b = options.settings) !== null && _b !== void 0 ? _b : {});
                makeRequest(apiVersion, headers, 0);
            });
        };
        if (requestDataProcessor) {
            requestDataProcessor(method, data, options.headers, prepareAndMakeRequest);
        }
        else {
            prepareAndMakeRequest(null, (0, utils_js_1.stringifyRequestData)(data || {}));
        }
    }
}
exports.RequestSender = RequestSender;

1	"use strict";
2	Object.defineProperty(exports, "__esModule", { value: true });	3✔
3	exports.RequestSender = void 0;	3✔
4	const Error_js_1 = require("./Error.js");	3✔
5	const utils_js_1 = require("./utils.js");	3✔
6	const HttpClient_js_1 = require("./net/HttpClient.js");	3✔
7	const MAX_RETRY_AFTER_WAIT = 60;	3✔
8	class RequestSender {
9	constructor(stripe, maxBufferedRequestMetric) {
10	this._stripe = stripe;	235✔
11	this._maxBufferedRequestMetric = maxBufferedRequestMetric;	235✔
12	}
13	_addHeadersDirectlyToObject(obj, headers) {
14	// For convenience, make some headers easily accessible on
15	// lastResponse.
16	// NOTE: Stripe responds with lowercase header names/keys.
17	obj.requestId = headers['request-id'];	511✔
18	obj.stripeAccount = obj.stripeAccount \|\| headers['stripe-account'];	511✔
19	obj.apiVersion = obj.apiVersion \|\| headers['stripe-version'];	511✔
20	obj.idempotencyKey = obj.idempotencyKey \|\| headers['idempotency-key'];	511✔
21	}
22	_makeResponseEvent(requestEvent, statusCode, headers) {
23	const requestEndTime = Date.now();	859✔
24	const requestDurationMs = requestEndTime - requestEvent.request_start_time;	859✔
25	return (0, utils_js_1.removeNullish)({	859✔
26	api_version: headers['stripe-version'],
27	account: headers['stripe-account'],
28	idempotency_key: headers['idempotency-key'],
29	method: requestEvent.method,
30	path: requestEvent.path,
31	status: statusCode,
32	request_id: this._getRequestId(headers),
33	elapsed: requestDurationMs,
34	request_start_time: requestEvent.request_start_time,
35	request_end_time: requestEndTime,
36	});
37	}
38	_getRequestId(headers) {
39	return headers['request-id'];	1,718✔
40	}
41	/**
42	* Used by methods with spec.streaming === true. For these methods, we do not
43	* buffer successful responses into memory or do parse them into stripe
44	* objects, we delegate that all of that to the user and pass back the raw
45	* http.Response object to the callback.
46	*
47	* (Unsuccessful responses shouldn't make it here, they should
48	* still be buffered/parsed and handled by _jsonResponseHandler -- see
49	* makeRequest)
50	*/
51	_streamingResponseHandler(requestEvent, callback) {
52	return (res) => {	2✔
53	const headers = res.getHeaders();	2✔
54	const streamCompleteCallback = () => {	2✔
55	const responseEvent = this._makeResponseEvent(requestEvent, res.getStatusCode(), headers);	2✔
56	this._stripe._emitter.emit('response', responseEvent);	2✔
57	this._recordRequestMetrics(this._getRequestId(headers), responseEvent.elapsed);	2✔
58	};
59	const stream = res.toStream(streamCompleteCallback);	2✔
60	// This is here for backwards compatibility, as the stream is a raw
61	// HTTP response in Node and the legacy behavior was to mutate this
62	// response.
63	this._addHeadersDirectlyToObject(stream, headers);	2✔
64	return callback(null, stream);	2✔
65	};
66	}
67	/**
68	* Default handler for Stripe responses. Buffers the response into memory,
69	* parses the JSON and returns it (i.e. passes it to the callback) if there
70	* is no "error" field. Otherwise constructs/passes an appropriate Error.
71	*/
72	_jsonResponseHandler(requestEvent, callback) {
73	return (res) => {	857✔
74	const headers = res.getHeaders();	857✔
75	const requestId = this._getRequestId(headers);	857✔
76	const statusCode = res.getStatusCode();	857✔
77	const responseEvent = this._makeResponseEvent(requestEvent, statusCode, headers);	857✔
78	this._stripe._emitter.emit('response', responseEvent);	857✔
79	res	857✔
80	.toJSON()
81	.then((jsonResponse) => {
82	if (jsonResponse.error) {	856✔
83	let err;
84	// Convert OAuth error responses into a standard format
85	// so that the rest of the error logic can be shared
86	if (typeof jsonResponse.error === 'string') {	347✔
87	jsonResponse.error = {	6✔
88	type: jsonResponse.error,
89	message: jsonResponse.error_description,
90	};
91	}
92	jsonResponse.error.headers = headers;	347✔
93	jsonResponse.error.statusCode = statusCode;	347✔
94	jsonResponse.error.requestId = requestId;	347✔
95	if (statusCode === 401) {	347✔
96	err = new Error_js_1.StripeAuthenticationError(jsonResponse.error);	329✔
97	}
98	else if (statusCode === 403) {	18✔
99	err = new Error_js_1.StripePermissionError(jsonResponse.error);	1✔
100	}
101	else if (statusCode === 429) {	17✔
102	err = new Error_js_1.StripeRateLimitError(jsonResponse.error);	1✔
103	}
104	else {
105	err = Error_js_1.StripeError.generate(jsonResponse.error);	16✔
106	}
107	throw err;	347✔
108	}
109	return jsonResponse;	509✔
110	}, (e) => {
111	throw new Error_js_1.StripeAPIError({	1✔
112	message: 'Invalid JSON received from the Stripe API',
113	exception: e,
114	requestId: headers['request-id'],
115	});
116	})
117	.then((jsonResponse) => {
118	this._recordRequestMetrics(requestId, responseEvent.elapsed);	509✔
119	// Expose raw response object.
120	const rawResponse = res.getRawResponse();	509✔
121	this._addHeadersDirectlyToObject(rawResponse, headers);	509✔
122	Object.defineProperty(jsonResponse, 'lastResponse', {	509✔
123	enumerable: false,
124	writable: false,
125	value: rawResponse,
126	});
127	callback(null, jsonResponse);	509✔
128	}, (e) => callback(e, null));	348✔
129	};
130	}
131	static _generateConnectionErrorMessage(requestRetries) {
132	return `An error occurred with our connection to Stripe.${requestRetries > 0 ? ` Request was retried ${requestRetries} times.` : ''}`;	5✔
133	}
134	// For more on when and how to retry API requests, see https://stripe.com/docs/error-handling#safely-retrying-requests-with-idempotency
135	static _shouldRetry(res, numRetries, maxRetries, error) {
136	if (error &&	887✔
137	numRetries === 0 &&
138	HttpClient_js_1.HttpClient.CONNECTION_CLOSED_ERROR_CODES.includes(error.code)) {
139	return true;	3✔
140	}
141	// Do not retry if we are out of retries.
142	if (numRetries >= maxRetries) {	884✔
143	return false;	863✔
144	}
145	// Retry on connection error.
146	if (!res) {	21✔
147	return true;	9✔
148	}
149	// The API may ask us not to retry (e.g., if doing so would be a no-op)
150	// or advise us to retry (e.g., in cases of lock timeouts); we defer to that.
151	if (res.getHeaders()['stripe-should-retry'] === 'false') {	12✔
152	return false;	1✔
153	}
154	if (res.getHeaders()['stripe-should-retry'] === 'true') {	11✔
155	return true;	1✔
156	}
157	// Retry on conflict errors.
158	if (res.getStatusCode() === 409) {	10✔
159	return true;	3✔
160	}
161	// Retry on 500, 503, and other internal errors.
162	//
163	// Note that we expect the stripe-should-retry header to be false
164	// in most cases when a 500 is returned, since our idempotency framework
165	// would typically replay it anyway.
166	if (res.getStatusCode() >= 500) {	7✔
167	return true;	3✔
168	}
169	return false;	4✔
170	}
171	_getSleepTimeInMS(numRetries, retryAfter = null) {	14✔
172	const initialNetworkRetryDelay = this._stripe.getInitialNetworkRetryDelay();	31✔
173	const maxNetworkRetryDelay = this._stripe.getMaxNetworkRetryDelay();	31✔
174	// Apply exponential backoff with initialNetworkRetryDelay on the
175	// number of numRetries so far as inputs. Do not allow the number to exceed
176	// maxNetworkRetryDelay.
177	let sleepSeconds = Math.min(initialNetworkRetryDelay * Math.pow(numRetries - 1, 2), maxNetworkRetryDelay);	31✔
178	// Apply some jitter by randomizing the value in the range of
179	// (sleepSeconds / 2) to (sleepSeconds).
180	sleepSeconds = 0.5 (1 + Math.random());	31✔
181	// But never sleep less than the base sleep seconds.
182	sleepSeconds = Math.max(initialNetworkRetryDelay, sleepSeconds);	31✔
183	// And never sleep less than the time the API asks us to wait, assuming it's a reasonable ask.
184	if (Number.isInteger(retryAfter) && retryAfter <= MAX_RETRY_AFTER_WAIT) {	31✔
185	sleepSeconds = Math.max(sleepSeconds, retryAfter);	5✔
186	}
187	return sleepSeconds * 1000;	31✔
188	}
189	// Max retries can be set on a per request basis. Favor those over the global setting
190	_getMaxNetworkRetries(settings = {}) {	4✔
191	return settings.maxNetworkRetries &&	1,752✔
192	Number.isInteger(settings.maxNetworkRetries)
193	? settings.maxNetworkRetries
194	: this._stripe.getMaxNetworkRetries();
195	}
196	_defaultIdempotencyKey(method, settings) {
197	// If this is a POST and we allow multiple retries, ensure an idempotency key.
198	const maxRetries = this._getMaxNetworkRetries(settings);	870✔
199	if (method === 'POST' && maxRetries > 0) {	870✔
200	return `stripe-node-retry-${this._stripe._platformFunctions.uuid4()}`;	13✔
201	}
202	return null;	857✔
203	}
204	_makeHeaders(auth, contentLength, apiVersion, clientUserAgent, method, userSuppliedHeaders, userSuppliedSettings) {
205	const defaultHeaders = {	870✔
206	// Use specified auth token or use default from this stripe instance:
207	Authorization: auth ? `Bearer ${auth}` : this._stripe.getApiField('auth'),	870✔
208	Accept: 'application/json',
209	'Content-Type': 'application/x-www-form-urlencoded',
210	'User-Agent': this._getUserAgentString(),
211	'X-Stripe-Client-User-Agent': clientUserAgent,
212	'X-Stripe-Client-Telemetry': this._getTelemetryHeader(),
213	'Stripe-Version': apiVersion,
214	'Stripe-Account': this._stripe.getApiField('stripeAccount'),
215	'Idempotency-Key': this._defaultIdempotencyKey(method, userSuppliedSettings),
216	};
217	// As per https://datatracker.ietf.org/doc/html/rfc7230#section-3.3.2:
218	// A user agent SHOULD send a Content-Length in a request message when
219	// no Transfer-Encoding is sent and the request method defines a meaning
220	// for an enclosed payload body. For example, a Content-Length header
221	// field is normally sent in a POST request even when the value is 0
222	// (indicating an empty payload body). A user agent SHOULD NOT send a
223	// Content-Length header field when the request message does not contain
224	// a payload body and the method semantics do not anticipate such a
225	// body.
226	//
227	// These method types are expected to have bodies and so we should always
228	// include a Content-Length.
229	const methodHasPayload = method == 'POST' \|\| method == 'PUT' \|\| method == 'PATCH';	870✔
230	// If a content length was specified, we always include it regardless of
231	// whether the method semantics anticipate such a body. This keeps us
232	// consistent with historical behavior. We do however want to warn on this
233	// and fix these cases as they are semantically incorrect.
234	if (methodHasPayload \|\| contentLength) {	870✔
235	if (!methodHasPayload) {	421✔
236	(0, utils_js_1.emitWarning)(`${method} method had non-zero contentLength but no payload is expected for this verb`);	1✔
237	}
238	defaultHeaders['Content-Length'] = contentLength;	421✔
239	}
240	return Object.assign((0, utils_js_1.removeNullish)(defaultHeaders),	870✔
241	// If the user supplied, say 'idempotency-key', override instead of appending by ensuring caps are the same.
242	(0, utils_js_1.normalizeHeaders)(userSuppliedHeaders));
243	}
244	_getUserAgentString() {
245	const packageVersion = this._stripe.getConstant('PACKAGE_VERSION');	870✔
246	const appInfo = this._stripe._appInfo	870!
247	? this._stripe.getAppInfoAsString()
248	: '';
249	return `Stripe/v1 NodeBindings/${packageVersion} ${appInfo}`.trim();	870✔
250	}
251	_getTelemetryHeader() {
252	if (this._stripe.getTelemetryEnabled() &&	870✔
253	this._stripe._prevRequestMetrics.length > 0) {
254	const metrics = this._stripe._prevRequestMetrics.shift();	464✔
255	return JSON.stringify({	464✔
256	last_request_metrics: metrics,
257	});
258	}
259	}
260	_recordRequestMetrics(requestId, requestDurationMs) {
261	if (this._stripe.getTelemetryEnabled() && requestId) {	511✔
262	if (this._stripe._prevRequestMetrics.length > this._maxBufferedRequestMetric) {	475!
263	(0, utils_js_1.emitWarning)('Request metrics buffer is full, dropping telemetry message.');	×
264	}
265	else {
266	this._stripe._prevRequestMetrics.push({	475✔
267	request_id: requestId,
268	request_duration_ms: requestDurationMs,
269	});
270	}
271	}
272	}
273	_request(method, host, path, data, auth, options = {}, callback, requestDataProcessor = null) {	530!
274	let requestData;
275	const retryRequest = (requestFn, apiVersion, headers, requestRetries, retryAfter) => {	867✔
276	return setTimeout(requestFn, this._getSleepTimeInMS(requestRetries, retryAfter), apiVersion, headers, requestRetries + 1);	16✔
277	};
278	const makeRequest = (apiVersion, headers, numRetries) => {	867✔
279	// timeout can be set on a per-request basis. Favor that over the global setting
280	const timeout = options.settings &&	882✔
281	options.settings.timeout &&
282	Number.isInteger(options.settings.timeout) &&
283	options.settings.timeout >= 0
284	? options.settings.timeout
285	: this._stripe.getApiField('timeout');
286	const req = this._stripe	882✔
287	.getApiField('httpClient')
288	.makeRequest(host \|\| this._stripe.getApiField('host'), this._stripe.getApiField('port'), path, method, headers, requestData, this._stripe.getApiField('protocol'), timeout);	1,746✔
289	const requestStartTime = Date.now();	882✔
290	// @ts-ignore
291	const requestEvent = (0, utils_js_1.removeNullish)({	882✔
292	api_version: apiVersion,
293	account: headers['Stripe-Account'],
294	idempotency_key: headers['Idempotency-Key'],
295	method,
296	path,
297	request_start_time: requestStartTime,
298	});
299	const requestRetries = numRetries \|\| 0;	882✔
300	const maxRetries = this._getMaxNetworkRetries(options.settings \|\| {});	882!
301	this._stripe._emitter.emit('request', requestEvent);	882✔
302	req	882✔
303	.then((res) => {
304	if (RequestSender._shouldRetry(res, requestRetries, maxRetries)) {	863✔
305	return retryRequest(makeRequest, apiVersion, headers, requestRetries,	4✔
306	// @ts-ignore
307	res.getHeaders()['retry-after']);
308	}
309	else if (options.streaming && res.getStatusCode() < 400) {	859✔
310	return this._streamingResponseHandler(requestEvent, callback)(res);	2✔
311	}
312	else {
313	return this._jsonResponseHandler(requestEvent, callback)(res);	857✔
314	}
315	})
316	.catch((error) => {
317	if (RequestSender._shouldRetry(null, requestRetries, maxRetries, error)) {	19✔
318	return retryRequest(makeRequest, apiVersion, headers, requestRetries, null);	12✔
319	}
320	else {
321	const isTimeoutError = error.code && error.code === HttpClient_js_1.HttpClient.TIMEOUT_ERROR_CODE;	7✔
322	return callback(new Error_js_1.StripeConnectionError({	7✔
323	message: isTimeoutError	7✔
324	? `Request aborted due to timeout being reached (${timeout}ms)`
325	: RequestSender._generateConnectionErrorMessage(requestRetries),
326	// @ts-ignore
327	detail: error,
328	}));
329	}
330	});
331	};
332	const prepareAndMakeRequest = (error, data) => {	867✔
333	if (error) {	867✔
334	return callback(error);	1✔
335	}
336	requestData = data;	866✔
337	this._stripe.getClientUserAgent((clientUserAgent) => {	866✔
338	var _a, _b;
339	const apiVersion = this._stripe.getApiField('version');	866✔
340	const headers = this._makeHeaders(auth, requestData.length, apiVersion, clientUserAgent, method, (_a = options.headers) !== null && _a !== void 0 ? _a : null, (_b = options.settings) !== null && _b !== void 0 ? _b : {});	866!
341	makeRequest(apiVersion, headers, 0);	866✔
342	});
343	};
344	if (requestDataProcessor) {	867✔
345	requestDataProcessor(method, data, options.headers, prepareAndMakeRequest);	11✔
346	}
347	else {
348	prepareAndMakeRequest(null, (0, utils_js_1.stringifyRequestData)(data \|\| {}));	856!
349	}
350	}
351	}
352	exports.RequestSender = RequestSender;	3✔

stripe / stripe-node / #389

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous