Merge changes from stripe/stripe-node master

# Conflicts:
#	src/Types.d.ts
#	types/Errors.d.ts

Author: xavdid

.github/workflows/main.yml

@@ -64,13 +64,14 @@ jobs:
         os:
           - 'ubuntu-24.04'
         node:
-          # should include even numbers >= 16
+          # should include even numbers >= 18
           # see: https://docs.stripe.com/sdks/versioning?lang=node#stripe-sdk-language-version-support-policy
+          # note that in Oct 2026, every version will be LTS, so it's not just even numbers anymore
+          # see: https://nodejs.org/en/blog/announcements/evolving-the-nodejs-release-schedule
           - '24'
           - '22'
           - '20'
           - '18'
-          - '16'
     runs-on: ${{ matrix.os }}
     permissions:
       contents: read
@@ -117,8 +118,7 @@ jobs:
     name: Publish
     if: >-
       (github.event_name == 'workflow_dispatch' || github.event_name == 'push') &&
-      startsWith(github.ref, 'refs/tags/v') &&
-      endsWith(github.actor, '-stripe')
+      startsWith(github.ref, 'refs/tags/v')
     needs: [build, test]
     runs-on: 'ubuntu-24.04'
     permissions:

README.md

@@ -19,9 +19,9 @@ See the [`stripe-node` API docs](https://stripe.com/docs/api?lang=node) for Node
 
 ## Requirements
 
-Per our [Language Version Support Policy](https://docs.stripe.com/sdks/versioning?lang=node#stripe-sdk-language-version-support-policy), we currently support all LTS versions of **Node.js 16+**.
+Per our [Language Version Support Policy](https://docs.stripe.com/sdks/versioning?lang=node#stripe-sdk-language-version-support-policy), we currently support all LTS versions of **Node.js 18+**.
 
-Support for Node 16 is deprecated and will be removed in an upcoming major version. Read more and see the full schedule in the docs: https://docs.stripe.com/sdks/versioning?lang=node#stripe-sdk-language-version-support-policy
+Read more and see the full schedule in the docs: https://docs.stripe.com/sdks/versioning?lang=node#stripe-sdk-language-version-support-policy
 
 ## Installation
 

package.json

@@ -22,7 +22,7 @@
   },
   "bugs": "https://github.com/stripe/stripe-node/issues",
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "main": "cjs/stripe.cjs.node.js",
   "types": "types/index.d.ts",
@@ -56,7 +56,7 @@
   },
   "dependencies": {},
   "peerDependencies": {
-    "@types/node": ">=16"
+    "@types/node": ">=18"
   },
   "peerDependenciesMeta": {
     "@types/node": {

src/Error.ts

@@ -7,31 +7,65 @@ import {RawErrorType, StripeRawError} from './Types.js';
 export const generateV1Error = (
   rawStripeError: StripeRawError
 ): StripeError => {
-  switch (rawStripeError.type) {
-    case 'card_error':
-      return new StripeCardError(rawStripeError);
-    case 'invalid_request_error':
-      return new StripeInvalidRequestError(rawStripeError);
-    case 'api_error':
-      return new StripeAPIError(rawStripeError);
-    case 'authentication_error':
-      return new StripeAuthenticationError(rawStripeError);
-    case 'rate_limit_error':
-      return new StripeRateLimitError(rawStripeError);
-    case 'idempotency_error':
+  const statusCode = rawStripeError.statusCode;
+
+  if (
+    statusCode === 429 ||
+    (statusCode === 400 && rawStripeError.code === 'rate_limit')
+  ) {
+    return new StripeRateLimitError(rawStripeError);
+  }
+
+  if (statusCode === 400 || statusCode === 404) {
+    if (rawStripeError.type === 'idempotency_error') {
       return new StripeIdempotencyError(rawStripeError);
+    }
+    return new StripeInvalidRequestError(rawStripeError);
+  }
+
+  if (statusCode === 401) {
+    return new StripeAuthenticationError(rawStripeError);
+  }
+
+  if (statusCode === 402) {
+    return new StripeCardError(rawStripeError);
+  }
+
+  if (statusCode === 403) {
+    return new StripePermissionError(rawStripeError);
+  }
+
+  return new StripeAPIError(rawStripeError);
+};
+
+export const generateOAuthError = (
+  rawStripeError: StripeRawError
+): StripeError => {
+  const oauthType = rawStripeError.type;
+  switch (oauthType) {
     case 'invalid_grant':
       return new StripeInvalidGrantError(rawStripeError);
+    case 'invalid_client':
+      return new StripeInvalidClientError(rawStripeError);
+    case 'invalid_request':
+      return new StripeOAuthInvalidRequestError(rawStripeError);
+    case 'invalid_scope':
+      return new StripeInvalidScopeError(rawStripeError);
+    case 'unsupported_grant_type':
+      return new StripeUnsupportedGrantTypeError(rawStripeError);
+    case 'unsupported_response_type':
+      return new StripeUnsupportedResponseTypeError(rawStripeError);
     default:
-      return new StripeUnknownError(rawStripeError);
+      return new StripeOAuthError(rawStripeError);
   }
 };
 
-// eslint-disable-next-line complexity
 export const generateV2Error = (
   rawStripeError: StripeRawError
 ): StripeError => {
   switch (rawStripeError.type) {
+    case 'idempotency_error':
+      return new StripeIdempotencyError(rawStripeError);
     // switchCases: The beginning of the section generated from our OpenAPI spec
     case 'already_canceled':
       return new AlreadyCanceledError(rawStripeError);
@@ -240,24 +274,74 @@ export class StripeIdempotencyError extends StripeError {
   }
 }
 
+/**
+ * StripeOAuthError is the base error for OAuth-specific errors.
+ */
+export class StripeOAuthError extends StripeError {
+  constructor(raw: StripeRawError = {}, type = 'StripeOAuthError') {
+    super(raw, type);
+  }
+}
+
 /**
  * InvalidGrantError is raised when a specified code doesn't exist, is
  * expired, has been used, or doesn't belong to you; a refresh token doesn't
  * exist, or doesn't belong to you; or if an API key's mode (live or test)
  * doesn't match the mode of a code or refresh token.
  */
-export class StripeInvalidGrantError extends StripeError {
+export class StripeInvalidGrantError extends StripeOAuthError {
   constructor(raw: StripeRawError = {}) {
     super(raw, 'StripeInvalidGrantError');
   }
 }
 
 /**
- * Any other error from Stripe not specifically captured above
+ * InvalidClientError is raised when the client_id does not belong to you,
+ * or an API key is required but not provided.
+ */
+export class StripeInvalidClientError extends StripeOAuthError {
+  constructor(raw: StripeRawError = {}) {
+    super(raw, 'StripeInvalidClientError');
+  }
+}
+
+/**
+ * OAuthInvalidRequestError is raised when a required parameter is missing,
+ * or an unsupported parameter or value is provided in the OAuth request.
+ */
+export class StripeOAuthInvalidRequestError extends StripeOAuthError {
+  constructor(raw: StripeRawError = {}) {
+    super(raw, 'StripeOAuthInvalidRequestError');
+  }
+}
+
+/**
+ * InvalidScopeError is raised when an invalid scope is provided in the
+ * OAuth request.
+ */
+export class StripeInvalidScopeError extends StripeOAuthError {
+  constructor(raw: StripeRawError = {}) {
+    super(raw, 'StripeInvalidScopeError');
+  }
+}
+
+/**
+ * UnsupportedGrantTypeError is raised when an unsupported grant_type is
+ * provided in the OAuth request.
+ */
+export class StripeUnsupportedGrantTypeError extends StripeOAuthError {
+  constructor(raw: StripeRawError = {}) {
+    super(raw, 'StripeUnsupportedGrantTypeError');
+  }
+}
+
+/**
+ * UnsupportedResponseTypeError is raised when an unsupported response_type
+ * is provided in the OAuth request.
  */
-export class StripeUnknownError extends StripeError {
+export class StripeUnsupportedResponseTypeError extends StripeOAuthError {
   constructor(raw: StripeRawError = {}) {
-    super(raw, 'StripeUnknownError');
+    super(raw, 'StripeUnsupportedResponseTypeError');
   }
 }
 

src/RequestSender.ts

@@ -1,10 +1,8 @@
 import {
   StripeAPIError,
-  StripeAuthenticationError,
   StripeConnectionError,
   StripeError,
-  StripePermissionError,
-  StripeRateLimitError,
+  generateOAuthError,
   generateV1Error,
   generateV2Error,
 } from './Error.js';
@@ -172,11 +170,9 @@ export class RequestSender {
         .then(
           (jsonResponse) => {
             if (jsonResponse.error) {
-              let err;
+              const isOAuth = typeof jsonResponse.error === 'string';
 
-              // Convert OAuth error responses into a standard format
-              // so that the rest of the error logic can be shared
-              if (typeof jsonResponse.error === 'string') {
+              if (isOAuth) {
                 jsonResponse.error = {
                   type: jsonResponse.error,
                   message: jsonResponse.error_description,
@@ -187,12 +183,10 @@ export class RequestSender {
               jsonResponse.error.statusCode = statusCode;
               jsonResponse.error.requestId = requestId;
 
-              if (statusCode === 401) {
-                err = new StripeAuthenticationError(jsonResponse.error);
-              } else if (statusCode === 403) {
-                err = new StripePermissionError(jsonResponse.error);
-              } else if (statusCode === 429) {
-                err = new StripeRateLimitError(jsonResponse.error);
+              let err;
+
+              if (isOAuth) {
+                err = generateOAuthError(jsonResponse.error);
               } else if (apiMode === 'v2') {
                 err = generateV2Error(jsonResponse.error);
               } else {

src/StripeResource.ts

@@ -1,4 +1,5 @@
 import {
+  getAPIMode,
   getDataFromArgs,
   getOptionsFromArgs,
   makeURLInterpolator,
@@ -16,6 +17,7 @@ import {
   UrlInterpolator,
 } from './Types.js';
 import {HttpClientResponseInterface} from './net/HttpClient.js';
+import {coerceV2RequestData, coerceV2ResponseData} from './V2Int64.js';
 
 // Provide extension mechanism for Stripe Resource Sub-Classes
 StripeResource.extend = protoExtend;
@@ -209,18 +211,35 @@ StripeResource.prototype = {
         return;
       }
 
+      // Coerce int64_string fields in request body: number → string
+      const apiMode = getAPIMode(spec.fullPath || spec.path);
+      if (apiMode === 'v2' && spec.requestSchema && opts.bodyData) {
+        opts.bodyData = coerceV2RequestData(
+          opts.bodyData,
+          spec.requestSchema
+        ) as RequestData;
+      }
+
       function requestCallback(
         err: any,
         response: HttpClientResponseInterface
       ): void {
         if (err) {
           reject(err);
         } else {
-          resolve(
-            spec.transformResponseData
-              ? spec.transformResponseData(response)
-              : response
-          );
+          // Coerce int64_string fields in response: string → bigint
+          try {
+            if (apiMode === 'v2' && spec.responseSchema) {
+              coerceV2ResponseData(response, spec.responseSchema);
+            }
+            resolve(
+              spec.transformResponseData
+                ? spec.transformResponseData(response)
+                : response
+            );
+          } catch (e) {
+            reject(e);
+          }
         }
       }
 

src/Types.d.ts

@@ -15,6 +15,11 @@ export type BufferedFile = {
   type: string;
   file: {data: Uint8Array};
 };
+export type V2RuntimeSchema =
+  | {kind: 'int64_string'}
+  | {kind: 'object'; fields: Record<string, V2RuntimeSchema>}
+  | {kind: 'array'; element: V2RuntimeSchema}
+  | {kind: 'nullable'; inner: V2RuntimeSchema};
 export type MethodSpec = {
   method: string;
   methodType?: string;
@@ -28,6 +33,8 @@ export type MethodSpec = {
   host?: string;
   transformResponseData?: (response: HttpClientResponseInterface) => any;
   usage?: Array<string>;
+  requestSchema?: V2RuntimeSchema;
+  responseSchema?: V2RuntimeSchema;
 };
 export type MultipartRequestData = RequestData | StreamingFile | BufferedFile;
 // rawErrorTypeEnum: The beginning of the section generated from our OpenAPI spec