stripe 16.12.0 → 17.0.0

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## 17.0.0 - 2024-10-01
+* [#2192](https://github.com/stripe/stripe-node/pull/2192) Support for APIs in the new API version 2024-09-30.acacia
+  
+  This release changes the pinned API version to `2024-09-30.acacia`. Please read the [API Upgrade Guide](https://stripe.com/docs/upgrades#2024-09-30.acacia) and carefully review the API changes before upgrading.
+  
+  ### ⚠️ Breaking changes  due to changes in the Stripe API
+  - Rename `usage_threshold_config` to `usage_threshold` on `Billing.AlertCreateParams` and `Billing.Alert`
+  - Remove support for `filter` on `Billing.AlertCreateParams` and `Billing.Alert`. Use the filters on the `usage_threshold` instead
+  - Remove support for `customer_consent_collected` on `Terminal.ReaderProcessSetupIntentParams`. 
+  
+  ### ⚠️ Other Breaking changes in the SDK 
+  - Adjusted default values around reties for HTTP requests. You can use the old defaults by setting them explicitly. New values are:
+      - max retries: `1` -> `2`
+      - max timeout (seconds): `2` -> `5`
+  
+  
+  ### Additions
+  * Add support for `custom_unit_amount` on `ProductCreateParams.default_price_data`
+  * Add support for `allow_redisplay` on `Terminal.ReaderProcessPaymentIntentParams.process_config` and `Terminal.ReaderProcessSetupIntentParams`
+  * Add support for new value `international_transaction` on enum `Treasury.ReceivedCredit.failure_code`
+  * Add support for new value `2024-09-30.acacia` on enum `WebhookEndpointCreateParams.api_version`
+  * Add support for new Usage Billing APIs `Billing.MeterEvent`, `Billing.MeterEventAdjustments`, `Billing.MeterEventSession`, `Billing.MeterEventStream` and the new Events API `Core.Events` in the [v2 namespace ](https://docs.corp.stripe.com/api-v2-overview)
+  * Add method `parseThinEvent()` on the `Stripe` class to parse [thin events](https://docs.corp.stripe.com/event-destinations#events-overview). 
+  * Add method [rawRequest()](https://github.com/stripe/stripe-node/tree/master?tab=readme-ov-file#custom-requests) on the `Stripe` class that takes a HTTP method type, url and relevant parameters to make requests to the Stripe API that are not yet supported in the SDK.
+  
+  ### Changes
+  * Change `BillingPortal.ConfigurationCreateParams.features.subscription_update.default_allowed_updates` and `BillingPortal.ConfigurationCreateParams.features.subscription_update.products` to be optional
+* [#2195](https://github.com/stripe/stripe-node/pull/2195) Remove parseSnapshotEvent
+* [#2188](https://github.com/stripe/stripe-node/pull/2188) Revert "Add raw_request (#2185)"
+* [#2185](https://github.com/stripe/stripe-node/pull/2185) Add raw_request
+  Adds the ability to make raw requests to the Stripe API, by providing an HTTP method and url.
+  
+  Example:
+  ```node
+  import Stripe from 'stripe';
+  const stripe = new Stripe('sk_test_...');
+  
+  const response = await stripe.rawRequest(
+    'POST',
+    '/v1/beta_endpoint',
+    { param: 123 },
+    { apiVersion: '2022-11-15; feature_beta=v3' }
+  );
+  
+  ```
+
 ## 16.12.0 - 2024-09-18
 * [#2177](https://github.com/stripe/stripe-node/pull/2177) Update generated code
   * Add support for new value `international_transaction` on enum `Treasury.ReceivedDebit.failure_code`

package/README.md

@@ -517,6 +517,40 @@ const stripe = new Stripe('sk_test_...', {
 });
 ```
 
+### Custom requests
+
+If you would like to send a request to an undocumented API (for example you are in a private beta), or if you prefer to bypass the method definitions in the library and specify your request details directly, you can use the `rawRequest` method on the StripeClient object.
+
+```javascript
+const client = new Stripe('sk_test_...');
+
+client.rawRequest(
+    'POST',
+    '/v1/beta_endpoint',
+    { param: 123 },
+    { apiVersion: '2022-11-15; feature_beta=v3' }
+  )
+  .then((response) => /* handle response */ )
+  .catch((error) => console.error(error));
+```
+
+Or using ES modules and `async`/`await`:
+
+```javascript
+import Stripe from 'stripe';
+const stripe = new Stripe('sk_test_...');
+
+const response = await stripe.rawRequest(
+  'POST',
+  '/v1/beta_endpoint',
+  { param: 123 },
+  { apiVersion: '2022-11-15; feature_beta=v3' }
+);
+
+// handle response
+```
+
+
 ## Support
 
 New features and bug fixes are released on the latest major version of the `stripe` package. If you are on an older major version, we recommend that you upgrade to the latest in order to use the new features and bug fixes including those for security vulnerabilities. Older major versions of the package will continue to be available for use, but will not be receiving any updates.

package/VERSION

@@ -1 +1 @@
-16.12.0
+17.0.0

package/cjs/Error.js

@@ -1,8 +1,9 @@
 "use strict";
 /* eslint-disable camelcase */
+/* eslint-disable no-warning-comments */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StripeUnknownError = exports.StripeInvalidGrantError = exports.StripeIdempotencyError = exports.StripeSignatureVerificationError = exports.StripeConnectionError = exports.StripeRateLimitError = exports.StripePermissionError = exports.StripeAuthenticationError = exports.StripeAPIError = exports.StripeInvalidRequestError = exports.StripeCardError = exports.StripeError = exports.generate = void 0;
-const generate = (rawStripeError) => {
+exports.TemporarySessionExpiredError = exports.StripeUnknownError = exports.StripeInvalidGrantError = exports.StripeIdempotencyError = exports.StripeSignatureVerificationError = exports.StripeConnectionError = exports.StripeRateLimitError = exports.StripePermissionError = exports.StripeAuthenticationError = exports.StripeAPIError = exports.StripeInvalidRequestError = exports.StripeCardError = exports.StripeError = exports.generateV2Error = exports.generateV1Error = void 0;
+const generateV1Error = (rawStripeError) => {
     switch (rawStripeError.type) {
         case 'card_error':
             return new StripeCardError(rawStripeError);
@@ -22,7 +23,24 @@ const generate = (rawStripeError) => {
             return new StripeUnknownError(rawStripeError);
     }
 };
-exports.generate = generate;
+exports.generateV1Error = generateV1Error;
+// eslint-disable-next-line complexity
+const generateV2Error = (rawStripeError) => {
+    switch (rawStripeError.type) {
+        // switchCases: The beginning of the section generated from our OpenAPI spec
+        case 'temporary_session_expired':
+            return new TemporarySessionExpiredError(rawStripeError);
+        // switchCases: The end of the section generated from our OpenAPI spec
+    }
+    // Special handling for requests with missing required fields in V2 APIs.
+    // invalid_field response in V2 APIs returns the field 'code' instead of 'type'.
+    switch (rawStripeError.code) {
+        case 'invalid_fields':
+            return new StripeInvalidRequestError(rawStripeError);
+    }
+    return (0, exports.generateV1Error)(rawStripeError);
+};
+exports.generateV2Error = generateV2Error;
 /**
  * StripeError is the base error from which all other more specific Stripe errors derive.
  * Specifically for errors returned from Stripe's REST API.
@@ -42,6 +60,7 @@ class StripeError extends Error {
         this.statusCode = raw.statusCode;
         // @ts-ignore
         this.message = raw.message;
+        this.userMessage = raw.user_message;
         this.charge = raw.charge;
         this.decline_code = raw.decline_code;
         this.payment_intent = raw.payment_intent;
@@ -55,7 +74,7 @@ exports.StripeError = StripeError;
 /**
  * Helper factory which takes raw stripe errors and outputs wrapping instances
  */
-StripeError.generate = exports.generate;
+StripeError.generate = exports.generateV1Error;
 // Specific Stripe Error types:
 /**
  * CardError is raised when a user enters a card that can't be charged for
@@ -174,3 +193,11 @@ class StripeUnknownError extends StripeError {
     }
 }
 exports.StripeUnknownError = StripeUnknownError;
+// classDefinitions: The beginning of the section generated from our OpenAPI spec
+class TemporarySessionExpiredError extends StripeError {
+    constructor(rawStripeError = {}) {
+        super(rawStripeError, 'TemporarySessionExpiredError');
+    }
+}
+exports.TemporarySessionExpiredError = TemporarySessionExpiredError;
+// classDefinitions: The end of the section generated from our OpenAPI spec

package/cjs/RequestSender.js

@@ -2,8 +2,8 @@
 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 utils_js_1 = require("./utils.js");
 const MAX_RETRY_AFTER_WAIT = 60;
 class RequestSender {
     constructor(stripe, maxBufferedRequestMetric) {
@@ -69,7 +69,7 @@ class RequestSender {
      * 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) {
+    _jsonResponseHandler(requestEvent, apiMode, usage, callback) {
         return (res) => {
             const headers = res.getHeaders();
             const requestId = this._getRequestId(headers);
@@ -101,8 +101,11 @@ class RequestSender {
                     else if (statusCode === 429) {
                         err = new Error_js_1.StripeRateLimitError(jsonResponse.error);
                     }
+                    else if (apiMode === 'v2') {
+                        err = (0, Error_js_1.generateV2Error)(jsonResponse.error);
+                    }
                     else {
-                        err = Error_js_1.StripeError.generate(jsonResponse.error);
+                        err = (0, Error_js_1.generateV1Error)(jsonResponse.error);
                     }
                     throw err;
                 }
@@ -174,7 +177,7 @@ class RequestSender {
         // 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);
+        let sleepSeconds = Math.min(initialNetworkRetryDelay * Math.pow(2, numRetries - 1), maxNetworkRetryDelay);
         // Apply some jitter by randomizing the value in the range of
         // (sleepSeconds / 2) to (sleepSeconds).
         sleepSeconds *= 0.5 * (1 + Math.random());
@@ -193,26 +196,34 @@ class RequestSender {
             ? settings.maxNetworkRetries
             : this._stripe.getMaxNetworkRetries();
     }
-    _defaultIdempotencyKey(method, settings) {
+    _defaultIdempotencyKey(method, settings, apiMode) {
         // 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()}`;
+        const genKey = () => `stripe-node-retry-${this._stripe._platformFunctions.uuid4()}`;
+        // more verbose than it needs to be, but gives clear separation between V1 and V2 behavior
+        if (apiMode === 'v2') {
+            if (method === 'POST' || method === 'DELETE') {
+                return genKey();
+            }
+        }
+        else if (apiMode === 'v1') {
+            if (method === 'POST' && maxRetries > 0) {
+                return genKey();
+            }
         }
         return null;
     }
-    _makeHeaders(auth, contentLength, apiVersion, clientUserAgent, method, userSuppliedHeaders, userSuppliedSettings) {
+    _makeHeaders({ contentType, contentLength, apiVersion, clientUserAgent, method, userSuppliedHeaders, userSuppliedSettings, stripeAccount, stripeContext, apiMode, }) {
         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(),
+            'Content-Type': contentType,
+            'User-Agent': this._getUserAgentString(apiMode),
             '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),
+            'Stripe-Account': stripeAccount,
+            'Stripe-Context': stripeContext,
+            'Idempotency-Key': this._defaultIdempotencyKey(method, userSuppliedSettings, apiMode),
         };
         // 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
@@ -241,12 +252,12 @@ class RequestSender {
         // If the user supplied, say 'idempotency-key', override instead of appending by ensuring caps are the same.
         (0, utils_js_1.normalizeHeaders)(userSuppliedHeaders));
     }
-    _getUserAgentString() {
+    _getUserAgentString(apiMode) {
         const packageVersion = this._stripe.getConstant('PACKAGE_VERSION');
         const appInfo = this._stripe._appInfo
             ? this._stripe.getAppInfoAsString()
             : '';
-        return `Stripe/v1 NodeBindings/${packageVersion} ${appInfo}`.trim();
+        return `Stripe/${apiMode} NodeBindings/${packageVersion} ${appInfo}`.trim();
     }
     _getTelemetryHeader() {
         if (this._stripe.getTelemetryEnabled() &&
@@ -274,8 +285,61 @@ class RequestSender {
             }
         }
     }
-    _request(method, host, path, data, auth, options = {}, usage = [], callback, requestDataProcessor = null) {
+    _rawRequest(method, path, params, options) {
+        const requestPromise = new Promise((resolve, reject) => {
+            let opts;
+            try {
+                const requestMethod = method.toUpperCase();
+                if (requestMethod !== 'POST' &&
+                    params &&
+                    Object.keys(params).length !== 0) {
+                    throw new Error('rawRequest only supports params on POST requests. Please pass null and add your parameters to path.');
+                }
+                const args = [].slice.call([params, options]);
+                // Pull request data and options (headers, auth) from args.
+                const dataFromArgs = (0, utils_js_1.getDataFromArgs)(args);
+                const data = Object.assign({}, dataFromArgs);
+                const calculatedOptions = (0, utils_js_1.getOptionsFromArgs)(args);
+                const headers = calculatedOptions.headers;
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const authenticator = calculatedOptions.authenticator;
+                opts = {
+                    requestMethod,
+                    requestPath: path,
+                    bodyData: data,
+                    queryData: {},
+                    authenticator,
+                    headers,
+                    host: null,
+                    streaming: false,
+                    settings: {},
+                    usage: ['raw_request'],
+                };
+            }
+            catch (err) {
+                reject(err);
+                return;
+            }
+            function requestCallback(err, response) {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(response);
+                }
+            }
+            const { headers, settings } = opts;
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const authenticator = opts.authenticator;
+            this._request(opts.requestMethod, opts.host, path, opts.bodyData, authenticator, { headers, settings, streaming: opts.streaming }, opts.usage, requestCallback);
+        });
+        return requestPromise;
+    }
+    _request(method, host, path, data, authenticator, options, usage = [], callback, requestDataProcessor = null) {
+        var _a;
         let requestData;
+        authenticator = (_a = authenticator !== null && authenticator !== void 0 ? authenticator : this._stripe._authenticator) !== null && _a !== void 0 ? _a : null;
+        const apiMode = (0, utils_js_1.getAPIMode)(path);
         const retryRequest = (requestFn, apiVersion, headers, requestRetries, retryAfter) => {
             return setTimeout(requestFn, this._getSleepTimeInMS(requestRetries, retryAfter), apiVersion, headers, requestRetries + 1);
         };
@@ -287,50 +351,68 @@ class RequestSender {
                 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),
+            const request = {
+                host: host || this._stripe.getApiField('host'),
+                port: this._stripe.getApiField('port'),
+                path: path,
+                method: method,
+                headers: Object.assign({}, headers),
+                body: requestData,
+                protocol: this._stripe.getApiField('protocol'),
+            };
+            authenticator(request)
+                .then(() => {
+                const req = this._stripe
+                    .getApiField('httpClient')
+                    .makeRequest(request.host, request.port, request.path, request.method, request.headers, request.body, request.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
-                        detail: error,
-                    }));
-                }
+                        res.getHeaders()['retry-after']);
+                    }
+                    else if (options.streaming && res.getStatusCode() < 400) {
+                        return this._streamingResponseHandler(requestEvent, usage, callback)(res);
+                    }
+                    else {
+                        return this._jsonResponseHandler(requestEvent, apiMode, 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,
+                        }));
+                    }
+                });
+            })
+                .catch((e) => {
+                throw new Error_js_1.StripeError({
+                    message: 'Unable to authenticate the request',
+                    exception: e,
+                });
             });
         };
         const prepareAndMakeRequest = (error, data) => {
@@ -339,9 +421,21 @@ class RequestSender {
             }
             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 : {});
+                const headers = this._makeHeaders({
+                    contentType: apiMode == 'v2'
+                        ? 'application/json'
+                        : 'application/x-www-form-urlencoded',
+                    contentLength: requestData.length,
+                    apiVersion: apiVersion,
+                    clientUserAgent,
+                    method,
+                    userSuppliedHeaders: options.headers,
+                    userSuppliedSettings: options.settings,
+                    stripeAccount: apiMode == 'v2' ? null : this._stripe.getApiField('stripeAccount'),
+                    stripeContext: apiMode == 'v2' ? this._stripe.getApiField('stripeContext') : null,
+                    apiMode: apiMode,
+                });
                 makeRequest(apiVersion, headers, 0);
             });
         };
@@ -349,7 +443,14 @@ class RequestSender {
             requestDataProcessor(method, data, options.headers, prepareAndMakeRequest);
         }
         else {
-            prepareAndMakeRequest(null, (0, utils_js_1.stringifyRequestData)(data || {}));
+            let stringifiedData;
+            if (apiMode == 'v2') {
+                stringifiedData = data ? (0, utils_js_1.jsonStringifyRequestData)(data) : '';
+            }
+            else {
+                stringifiedData = (0, utils_js_1.queryStringifyRequestData)(data || {}, apiMode);
+            }
+            prepareAndMakeRequest(null, stringifiedData);
         }
     }
 }

package/cjs/StripeResource.js

@@ -79,6 +79,7 @@ StripeResource.prototype = {
         return parts.join('/').replace(/\/{2,}/g, '/');
     },
     _getRequestOpts(requestArgs, spec, overrideData) {
+        var _a;
         // Extract spec values with defaults.
         const requestMethod = (spec.method || 'GET').toUpperCase();
         const usage = spec.usage || [];
@@ -129,7 +130,7 @@ StripeResource.prototype = {
             requestPath,
             bodyData,
             queryData,
-            auth: options.auth,
+            authenticator: (_a = options.authenticator) !== null && _a !== void 0 ? _a : null,
             headers,
             host: host !== null && host !== void 0 ? host : null,
             streaming,
@@ -162,10 +163,14 @@ StripeResource.prototype = {
             const path = [
                 opts.requestPath,
                 emptyQuery ? '' : '?',
-                (0, utils_js_1.stringifyRequestData)(opts.queryData),
+                (0, utils_js_1.queryStringifyRequestData)(opts.queryData, (0, utils_js_1.getAPIMode)(opts.requestPath)),
             ].join('');
             const { headers, settings } = opts;
-            this._stripe._requestSender._request(opts.requestMethod, opts.host, path, opts.bodyData, opts.auth, { headers, settings, streaming: opts.streaming }, opts.usage, requestCallback, (_a = this.requestDataProcessor) === null || _a === void 0 ? void 0 : _a.bind(this));
+            this._stripe._requestSender._request(opts.requestMethod, opts.host, path, opts.bodyData, opts.authenticator, {
+                headers,
+                settings,
+                streaming: opts.streaming,
+            }, opts.usage, requestCallback, (_a = this.requestDataProcessor) === null || _a === void 0 ? void 0 : _a.bind(this));
         });
     },
 };

package/cjs/apiVersion.js

@@ -2,4 +2,4 @@
 // File generated from our OpenAPI spec
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiVersion = void 0;
-exports.ApiVersion = '2024-06-20';
+exports.ApiVersion = '2024-09-30.acacia';

package/cjs/autoPagination.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeAutoPaginationMethods = void 0;
 const utils_js_1 = require("./utils.js");
-class StripeIterator {
+class V1Iterator {
     constructor(firstPagePromise, requestArgs, spec, stripeResource) {
         this.index = 0;
         this.pagePromise = firstPagePromise;
@@ -60,7 +60,7 @@ class StripeIterator {
         return nextPromise;
     }
 }
-class ListIterator extends StripeIterator {
+class V1ListIterator extends V1Iterator {
     getNextPage(pageResult) {
         const reverseIteration = isReverseIteration(this.requestArgs);
         const lastId = getLastId(pageResult, reverseIteration);
@@ -69,7 +69,7 @@ class ListIterator extends StripeIterator {
         });
     }
 }
-class SearchIterator extends StripeIterator {
+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.');
@@ -79,12 +79,56 @@ class SearchIterator extends StripeIterator {
         });
     }
 }
+class V2ListIterator {
+    constructor(firstPagePromise, requestArgs, spec, stripeResource) {
+        this.currentPageIterator = (async () => {
+            const page = await firstPagePromise;
+            return page.data[Symbol.iterator]();
+        })();
+        this.nextPageUrl = (async () => {
+            const page = await firstPagePromise;
+            return page.next_page_url || null;
+        })();
+        this.requestArgs = requestArgs;
+        this.spec = spec;
+        this.stripeResource = stripeResource;
+    }
+    async turnPage() {
+        const nextPageUrl = await this.nextPageUrl;
+        if (!nextPageUrl)
+            return null;
+        this.spec.fullPath = nextPageUrl;
+        const page = await this.stripeResource._makeRequest([], this.spec, {});
+        this.nextPageUrl = Promise.resolve(page.next_page_url);
+        this.currentPageIterator = Promise.resolve(page.data[Symbol.iterator]());
+        return this.currentPageIterator;
+    }
+    async next() {
+        {
+            const result = (await 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) => {
-    if (spec.methodType === 'search') {
-        return makeAutoPaginationMethodsFromIterator(new SearchIterator(firstPagePromise, requestArgs, spec, stripeResource));
+    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 (spec.methodType === 'list') {
-        return makeAutoPaginationMethodsFromIterator(new ListIterator(firstPagePromise, requestArgs, spec, stripeResource));
+    if (apiMode === 'v2' && spec.methodType === 'list') {
+        return makeAutoPaginationMethodsFromIterator(new V2ListIterator(firstPagePromise, requestArgs, spec, stripeResource));
     }
     return null;
 };

package/cjs/crypto/CryptoProvider.js

@@ -31,6 +31,12 @@ class CryptoProvider {
     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;
 /**

package/cjs/crypto/NodeCryptoProvider.js

@@ -19,5 +19,12 @@ class NodeCryptoProvider extends CryptoProvider_js_1.CryptoProvider {
         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

@@ -37,6 +37,10 @@ class SubtleCryptoProvider extends CryptoProvider_js_1.CryptoProvider {
         }
         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-

package/cjs/multipart.js

@@ -48,7 +48,7 @@ const multipartDataGenerator = (method, data, headers) => {
 function multipartRequestDataProcessor(method, data, headers, callback) {
     data = data || {};
     if (method !== 'POST') {
-        return callback(null, (0, utils_js_1.stringifyRequestData)(data));
+        return callback(null, (0, utils_js_1.queryStringifyRequestData)(data));
     }
     this._stripe._platformFunctions
         .tryBufferData(data)