Merge pull request #2720 from stripe/latest-codegen-beta

Update generated code for beta

Author: stripe-openapi[bot]

.eslintrc.js

@@ -170,7 +170,7 @@ module.exports = {
     'no-useless-return': 'error',
     'no-var': 'off',
     'no-void': 'error',
-    'no-warning-comments': 'error',
+    'no-warning-comments': 'warn',
     'no-whitespace-before-property': 'error',
     'no-with': 'error',
     'nonblock-statement-body-position': 'error',
@@ -287,5 +287,20 @@ module.exports = {
         '@typescript-eslint/explicit-function-return-type': 'off',
       },
     },
+    {
+      files: ['src/**/*.ts'],
+      rules: {
+        'wintertc-compat': 'error',
+      },
+    },
+    {
+      files: [
+        'src/**/Node*.ts',
+        'src/stripe.*.node.ts',
+      ],
+      rules: {
+        'wintertc-compat': 'off',
+      },
+    },
   ],
 };

CODEGEN_VERSION

@@ -1 +1 @@
-826bf48af8bcd391512daeaf283b8486347b14c8
+d59a1f4bdea3032b8e282d40badc032cb021fc60

OPENAPI_VERSION

@@ -1 +1 @@
-v2253
+v2277

eslint-rules/wintertc-compat.js

@@ -0,0 +1,241 @@
+/**
+ * ESLint rule: wintertc-compat
+ *
+ * Flags usage of APIs not in the WinterTC Minimum Common Web Platform API
+ * spec (ECMA-429). Designed to catch cross-runtime compatibility issues in
+ * code that must run in Node.js, browsers, Deno, Bun, and other runtimes.
+ *
+ * Spec: https://min-common-api.proposal.wintertc.org/
+ */
+
+'use strict';
+
+// Complete list of Node.js built-in modules.
+// See: https://nodejs.org/api/modules.html#built-in-modules
+const NODE_BUILTIN_MODULES = new Set([
+  'assert',
+  'assert/strict',
+  'async_hooks',
+  'buffer',
+  'child_process',
+  'cluster',
+  'console',
+  'constants',
+  'crypto',
+  'dgram',
+  'diagnostics_channel',
+  'dns',
+  'dns/promises',
+  'domain',
+  'events',
+  'fs',
+  'fs/promises',
+  'http',
+  'http2',
+  'https',
+  'inspector',
+  'module',
+  'net',
+  'os',
+  'path',
+  'path/posix',
+  'path/win32',
+  'perf_hooks',
+  'process',
+  'punycode',
+  'querystring',
+  'readline',
+  'readline/promises',
+  'repl',
+  'stream',
+  'stream/consumers',
+  'stream/promises',
+  'stream/web',
+  'string_decoder',
+  'sys',
+  'test',
+  'timers',
+  'timers/promises',
+  'tls',
+  'trace_events',
+  'tty',
+  'url',
+  'util',
+  'util/types',
+  'v8',
+  'vm',
+  'wasi',
+  'worker_threads',
+  'zlib',
+]);
+
+// Node.js-specific globals that are not in the WinterTC spec or ECMAScript.
+const NODE_GLOBALS = new Set([
+  'Buffer',
+  'process',
+  '__dirname',
+  '__filename',
+  'global',
+  'require',
+  'module',
+  'exports',
+]);
+
+function findVariable(scope, name) {
+  let s = scope;
+  while (s) {
+    const found = s.variables.find((v) => v.name === name);
+    if (found) {
+      return found;
+    }
+    s = s.upper;
+  }
+  return null;
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow Node.js-specific APIs in cross-runtime code per the WinterTC Minimum Common Web Platform API spec (ECMA-429)',
+      url: 'https://min-common-api.proposal.wintertc.org/',
+    },
+    messages: {
+      nodeImport:
+        "Import from Node.js built-in module '{{source}}' is not available in all runtimes.",
+      nodeGlobal:
+        "'{{name}}' is a Node.js-specific global not available in all runtimes.",
+      nodeType:
+        "'NodeJS.{{name}}' is a Node.js-specific type. Use a cross-runtime alternative.",
+    },
+    schema: [],
+  },
+
+  create(context) {
+    return {
+      // Flag imports from Node.js built-in modules (both bare and node: prefix).
+      ImportDeclaration(node) {
+        const source = node.source.value;
+        const moduleName = source.startsWith('node:')
+          ? source.slice(5)
+          : source;
+
+        if (NODE_BUILTIN_MODULES.has(moduleName)) {
+          context.report({
+            node: node.source,
+            messageId: 'nodeImport',
+            data: {source},
+          });
+        }
+      },
+
+      // Flag require() calls for Node.js built-in modules.
+      CallExpression(node) {
+        if (
+          node.callee.type === 'Identifier' &&
+          node.callee.name === 'require' &&
+          node.arguments.length > 0 &&
+          node.arguments[0].type === 'Literal' &&
+          typeof node.arguments[0].value === 'string'
+        ) {
+          const source = node.arguments[0].value;
+          const moduleName = source.startsWith('node:')
+            ? source.slice(5)
+            : source;
+
+          if (NODE_BUILTIN_MODULES.has(moduleName)) {
+            context.report({
+              node: node.arguments[0],
+              messageId: 'nodeImport',
+              data: {source},
+            });
+          }
+        }
+      },
+
+      // Flag references to Node.js-specific globals.
+      Identifier(node) {
+        if (!NODE_GLOBALS.has(node.name)) {
+          return;
+        }
+
+        // Skip property accesses: obj.Buffer, obj.process, etc.
+        if (
+          node.parent.type === 'MemberExpression' &&
+          node.parent.property === node &&
+          !node.parent.computed
+        ) {
+          return;
+        }
+
+        // Skip variable declarations: const Buffer = ...
+        if (
+          node.parent.type === 'VariableDeclarator' &&
+          node.parent.id === node
+        ) {
+          return;
+        }
+
+        // Skip function parameter names
+        if (
+          node.parent.type === 'FunctionDeclaration' ||
+          node.parent.type === 'FunctionExpression' ||
+          node.parent.type === 'ArrowFunctionExpression'
+        ) {
+          if (node.parent.params && node.parent.params.includes(node)) {
+            return;
+          }
+        }
+
+        // Skip object property keys: { process: ... }
+        if (
+          node.parent.type === 'Property' &&
+          node.parent.key === node &&
+          !node.parent.computed
+        ) {
+          return;
+        }
+
+        // Skip import specifiers: import { Buffer } from '...' (caught by ImportDeclaration)
+        if (
+          node.parent.type === 'ImportSpecifier' ||
+          node.parent.type === 'ImportDefaultSpecifier' ||
+          node.parent.type === 'ImportNamespaceSpecifier'
+        ) {
+          return;
+        }
+
+        // Only flag actual global references, not locally-scoped variables.
+        const scope = context.getScope();
+        const variable = findVariable(scope, node.name);
+        if (variable && variable.defs.length > 0) {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: 'nodeGlobal',
+          data: {name: node.name},
+        });
+      },
+
+      // Flag NodeJS.* type references (e.g., NodeJS.ReadableStream, NodeJS.Timeout).
+      TSTypeReference(node) {
+        if (
+          node.typeName &&
+          node.typeName.type === 'TSQualifiedName' &&
+          node.typeName.left &&
+          node.typeName.left.type === 'Identifier' &&
+          node.typeName.left.name === 'NodeJS'
+        ) {
+          context.report({
+            node,
+            messageId: 'nodeType',
+            data: {name: node.typeName.right.name},
+          });
+        }
+      },
+    };
+  },
+};

examples/snippets/event_notification_handler_endpoint.ts

@@ -1,3 +1,5 @@
+// File copied from our code generator; changes here will be overwritten.
+
 /**
  * event_notification_handler_endpoint.ts - receive and process event notifications like the
  * v1.billing.meter.error_report_triggered event.

examples/snippets/event_notification_webhook_handler.ts

@@ -1,3 +1,5 @@
+// File copied from our code generator; changes here will be overwritten.
+
 /**
  * event_notification_webhook_handler.ts - receive and process event notifications like the
  * v1.billing.meter.error_report_triggered event.

justfile

@@ -53,7 +53,7 @@ lint: (lint-check "--fix")
 
 # run style checks without changing anything
 lint-check *args: install
-    eslint --ext .js,.ts . {{ args }}
+    eslint --rulesdir eslint-rules --ext .js,.ts . {{ args }}
 
 # reinstall dependencies, if needed
 install:

src/RequestSender.ts

@@ -25,7 +25,6 @@ import {RawRequestOptions, RequestOptions} from './lib.js';
 import {HttpClient, HttpClientResponseInterface} from './net/HttpClient.js';
 import {Stripe} from './stripe.core.js';
 import {
-  emitWarning,
   jsonStringifyRequestData,
   normalizeHeaders,
   queryStringifyRequestData,
@@ -418,7 +417,7 @@ export class RequestSender {
     // and fix these cases as they are semantically incorrect.
     if (methodHasPayload || contentLength) {
       if (!methodHasPayload) {
-        emitWarning(
+        this._stripe._platformFunctions.emitWarning(
           `${method} method had non-zero contentLength but no payload is expected for this verb`
         );
       }
@@ -470,7 +469,7 @@ export class RequestSender {
       if (
         this._stripe._prevRequestMetrics.length > this._maxBufferedRequestMetric
       ) {
-        emitWarning(
+        this._stripe._platformFunctions.emitWarning(
           'Request metrics buffer is full, dropping telemetry message.'
         );
       } else {
@@ -580,7 +579,7 @@ export class RequestSender {
       headers: RequestHeaders,
       requestRetries: number,
       retryAfter: number | null
-    ): NodeJS.Timeout => {
+    ): ReturnType<typeof setTimeout> => {
       return setTimeout(
         requestFn,
         this._getSleepTimeInMS(requestRetries, retryAfter),

src/StripeEventNotificationHandler.ts

@@ -1,11 +1,13 @@
+// File copied from our code generator; changes here will be overwritten.
+
 import {Stripe} from './stripe.core.js';
 import * as Events from './resources/V2/Core/Events.js';
 
 export interface UnhandledNotificationDetails {
   isKnownEventType: boolean;
 }
 
-type FallbackCallback = (
+export type FallbackCallback = (
   event: Events.UnknownEventNotification,
   client: Stripe,
   details: UnhandledNotificationDetails
@@ -147,8 +149,8 @@ export class StripeEventNotificationHandler {
 
   public async handle(
     // these types are duplicated in the manual types, so they're just here for internal use
-    rawBody: string | Buffer,
-    signature: string | Buffer
+    rawBody: string | Uint8Array,
+    signature: string | Uint8Array
   ): Promise<void> {
     // we're not worried about thread safety here because we expect callbacks will be registered synchronously on app startup
     this.hasHandledEvent = true;

src/Types.ts

@@ -1,4 +1,6 @@
 /* eslint-disable camelcase */
+// TODO(DEVSDK-3113): Remove EventEmitter from shared types in next major version.
+// eslint-disable-next-line wintertc-compat
 import {EventEmitter} from 'events';
 import {
   HttpClientInterface,