Complete Email Sortierer implementation with Appwrite and Stripe integration

server/node_modules/stripe/cjs/RequestSender.js

@@ -0,0 +1,356 @@
+"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, usage, 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, usage);
+            };
+            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, usage, 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, usage);
+                // 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 !== undefined &&
+            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, usage) {
+        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 {
+                const m = {
+                    request_id: requestId,
+                    request_duration_ms: requestDurationMs,
+                };
+                if (usage && usage.length > 0) {
+                    m.usage = usage;
+                }
+                this._stripe._prevRequestMetrics.push(m);
+            }
+        }
+    }
+    _request(method, host, path, data, auth, options = {}, usage = [], 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, usage, callback)(res);
+                }
+                else {
+                    return this._jsonResponseHandler(requestEvent, usage, 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;