Merge upstream and update generated code for v2204 and

Author: stripe-openapi[bot]

.github/workflows/ci.yml

@@ -54,7 +54,7 @@ jobs:
     strategy:
       matrix:
         # following https://docs.stripe.com/sdks/versioning?lang=ruby#stripe-sdk-language-version-support-policy
-        ruby-version: [2.6, 2.7, '3.0', 3.1, 3.2, 3.3, 3.4, jruby-9.4.0.0, truffleruby-25.0.0]
+        ruby-version: [2.7, '3.0', 3.1, 3.2, 3.3, 3.4, jruby-9.4.0.0, truffleruby-25.0.0]
     steps:
     - uses: extractions/setup-just@v2
     - uses: actions/checkout@v3
@@ -72,8 +72,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-22.04
     permissions:

.rubocop.yml

@@ -2,7 +2,7 @@ inherit_from: .rubocop_todo.yml
 
 AllCops:
   DisplayCopNames: true
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 2.7
   SuggestExtensions: false
 
 Layout/CaseIndentation:

CODEGEN_VERSION

@@ -1 +1 @@
-273184f052dd3c191b1993098365d0c2437d2cb4
+a88a25f98754c8d1414ef03c9d8fc76b915fc181

README.md

@@ -40,9 +40,9 @@ gem build stripe.gemspec
 
 ### Requirements
 
-Per our [Language Version Support Policy](https://docs.stripe.com/sdks/versioning?lang=ruby#stripe-sdk-language-version-support-policy), we currently support **Ruby 2.6+**.
+Per our [Language Version Support Policy](https://docs.stripe.com/sdks/versioning?lang=ruby#stripe-sdk-language-version-support-policy), we currently support **Ruby 2.7+**.
 
-Support for Ruby 2.6 and 2.7 is deprecated and will be removed in upcoming major versions. Read more and see the full schedule in the docs: https://docs.stripe.com/sdks/versioning?lang=ruby#stripe-sdk-language-version-support-policy
+Support for Ruby 2.7 is deprecated and will be removed in upcoming major versions. Read more and see the full schedule in the docs: https://docs.stripe.com/sdks/versioning?lang=ruby#stripe-sdk-language-version-support-policy
 
 ### Bundler
 

lib/stripe/request_params.rb

@@ -31,6 +31,7 @@ def attr_accessor(*names)
     end
 
     def to_h
+      encodings = self.class.field_encodings
       instance_variables.each_with_object({}) do |var, hash|
         # _explicitly_set_keys is set as an instance variable.
         # Ignore the var if it is _explicitly_set_keys itself.
@@ -50,6 +51,76 @@ def to_h
                     else
                       value
                     end
+
+        # Coerce fields based on encoding schema (int64_string, nested objects, arrays)
+        encoding = encodings[key]
+        hash[key] = self.class.coerce_value(hash[key], encoding) if encoding
+      end
+    end
+
+    def self.field_encodings
+      @field_encodings ||= {}
+    end
+
+    # Recursively coerce a value based on its field encoding schema.
+    # Handles :int64_string leaves, { kind: :object, fields: ... } nesting,
+    # and { kind: :array, element: ... } for arrays.
+    def self.coerce_value(value, encoding)
+      return value if value.nil?
+
+      case encoding
+      when :int64_string
+        coerce_int64_string(value)
+      when Hash
+        coerce_composite(value, encoding)
+      else
+        value
+      end
+    end
+
+    private_class_method def self.coerce_int64_string(value)
+      case value
+      when Integer then value.to_s
+      when Array then value.map { |v| v.is_a?(Integer) ? v.to_s : v }
+      else value
+      end
+    end
+
+    private_class_method def self.coerce_composite(value, encoding)
+      case encoding[:kind]
+      when :object
+        coerce_object(value, encoding[:fields] || {})
+      when :array
+        return value unless value.is_a?(Array)
+
+        value.map { |v| coerce_value(v, encoding[:element]) }
+      else
+        value
+      end
+    end
+
+    private_class_method def self.coerce_object(value, fields_schema)
+      return value unless value.is_a?(Hash)
+
+      value.each_with_object({}) do |(k, v), result|
+        field_encoding = fields_schema[k.to_sym]
+        result[k] = field_encoding ? coerce_value(v, field_encoding) : v
+      end
+    end
+
+    # Coerce a plain Hash using this class's field_encodings.
+    # Called from generated service methods when params is a Hash
+    # (not a RequestParams instance) to ensure int64_string fields
+    # are serialized as strings on the wire.
+    def self.coerce_params(params)
+      return params unless params.is_a?(Hash)
+
+      encodings = field_encodings
+      return params if encodings.empty?
+
+      params.each_with_object({}) do |(k, v), result|
+        encoding = encodings[k.to_sym]
+        result[k] = encoding ? coerce_value(v, encoding) : v
       end
     end
   end

stripe.gemspec

@@ -7,7 +7,7 @@ require "stripe/version"
 Gem::Specification.new do |s|
   s.name = "stripe"
   s.version = Stripe::VERSION
-  s.required_ruby_version = ">= 2.6.0"
+  s.required_ruby_version = ">= 2.7.0"
   s.summary = "Ruby bindings for the Stripe API"
   s.description = "Stripe is the easiest way to accept payments online.  " \
                   "See https://stripe.com for details."

test/stripe/request_params_test.rb

@@ -21,6 +21,47 @@ def initialize(games: nil)
       end
     end
 
+    # Used in ".coerce_params" context
+    class Int64Params < Stripe::RequestParams
+      attr_accessor :amount, :name, :items
+
+      def initialize(amount: nil, name: nil, items: nil)
+        @amount = amount
+        @name = name
+        @items = items
+      end
+
+      def self.field_encodings
+        {
+          amount: :int64_string,
+          items: { kind: :array, element: { kind: :object, fields: { qty: :int64_string } } },
+        }
+      end
+    end
+
+    # Used in ".coerce_params" context
+    class PlainParams < Stripe::RequestParams
+      attr_accessor :foo
+
+      def initialize(foo: nil)
+        @foo = foo
+      end
+    end
+
+    # Used in "#to_h with field_encodings" context
+    class AmountParams < Stripe::RequestParams
+      attr_accessor :amount, :label
+
+      def initialize(amount: nil, label: nil)
+        @amount = amount
+        @label = label
+      end
+
+      def self.field_encodings
+        { amount: :int64_string }
+      end
+    end
+
     context "#to_h" do
       should "convert to hash" do
         params = FooCreateParams.new(
@@ -261,7 +302,204 @@ def initialize(games: nil)
       end
     end
 
-    context "RequestParams explicit key tracking" do
+    context ".coerce_value" do
+      should "return nil as-is" do
+        assert_nil Stripe::RequestParams.coerce_value(nil, :int64_string)
+        assert_nil Stripe::RequestParams.coerce_value(nil, { kind: :object, fields: {} })
+      end
+
+      should "convert Integer to String for int64_string encoding" do
+        assert_equal "42", Stripe::RequestParams.coerce_value(42, :int64_string)
+        assert_equal "0", Stripe::RequestParams.coerce_value(0, :int64_string)
+        assert_equal "-7", Stripe::RequestParams.coerce_value(-7, :int64_string)
+      end
+
+      should "pass through String for int64_string encoding" do
+        assert_equal "42", Stripe::RequestParams.coerce_value("42", :int64_string)
+        assert_equal "hello", Stripe::RequestParams.coerce_value("hello", :int64_string)
+      end
+
+      should "convert Array of Integers for int64_string encoding" do
+        assert_equal %w[1 2 3], Stripe::RequestParams.coerce_value([1, 2, 3], :int64_string)
+      end
+
+      should "handle mixed Array for int64_string encoding" do
+        assert_equal %w[1 already 3], Stripe::RequestParams.coerce_value([1, "already", 3], :int64_string)
+      end
+
+      should "return value as-is for unknown encoding symbol" do
+        assert_equal 42, Stripe::RequestParams.coerce_value(42, :unknown_encoding)
+        assert_equal "hello", Stripe::RequestParams.coerce_value("hello", :something_else)
+      end
+
+      should "coerce object fields recursively" do
+        encoding = {
+          kind: :object,
+          fields: { amount: :int64_string, name: nil },
+        }
+        input = { amount: 100, name: "test", extra: "untouched" }
+        expected = { amount: "100", name: "test", extra: "untouched" }
+        assert_equal expected, Stripe::RequestParams.coerce_value(input, encoding)
+      end
+
+      should "coerce object fields with string keys" do
+        encoding = {
+          kind: :object,
+          fields: { amount: :int64_string, name: nil },
+        }
+        input = { "amount" => 100, "name" => "test", "extra" => "untouched" }
+        expected = { "amount" => "100", "name" => "test", "extra" => "untouched" }
+        assert_equal expected, Stripe::RequestParams.coerce_value(input, encoding)
+      end
+
+      should "coerce deeply nested objects with string keys" do
+        encoding = {
+          kind: :object,
+          fields: {
+            inner: { kind: :object, fields: { val: :int64_string } },
+          },
+        }
+        input = { "inner" => { "val" => 99, "other" => "keep" }, "top" => "also keep" }
+        expected = { "inner" => { "val" => "99", "other" => "keep" }, "top" => "also keep" }
+        assert_equal expected, Stripe::RequestParams.coerce_value(input, encoding)
+      end
+
+      should "coerce array of objects with string keys" do
+        encoding = {
+          kind: :array,
+          element: { kind: :object, fields: { id: :int64_string } },
+        }
+        input = [{ "id" => 1, "name" => "a" }, { "id" => 2, "name" => "b" }]
+        expected = [{ "id" => "1", "name" => "a" }, { "id" => "2", "name" => "b" }]
+        assert_equal expected, Stripe::RequestParams.coerce_value(input, encoding)
+      end
+
+      should "return non-Hash as-is for object encoding" do
+        encoding = { kind: :object, fields: { amount: :int64_string } }
+        assert_equal "not a hash", Stripe::RequestParams.coerce_value("not a hash", encoding)
+        assert_equal 42, Stripe::RequestParams.coerce_value(42, encoding)
+      end
+
+      should "coerce array elements" do
+        encoding = { kind: :array, element: :int64_string }
+        assert_equal %w[1 2 3], Stripe::RequestParams.coerce_value([1, 2, 3], encoding)
+      end
+
+      should "return non-Array as-is for array encoding" do
+        encoding = { kind: :array, element: :int64_string }
+        assert_equal "not an array", Stripe::RequestParams.coerce_value("not an array", encoding)
+      end
+
+      should "coerce array of objects" do
+        encoding = {
+          kind: :array,
+          element: { kind: :object, fields: { id: :int64_string } },
+        }
+        input = [{ id: 1, name: "a" }, { id: 2, name: "b" }]
+        expected = [{ id: "1", name: "a" }, { id: "2", name: "b" }]
+        assert_equal expected, Stripe::RequestParams.coerce_value(input, encoding)
+      end
+
+      should "coerce deeply nested object-in-object" do
+        encoding = {
+          kind: :object,
+          fields: {
+            inner: { kind: :object, fields: { val: :int64_string } },
+          },
+        }
+        input = { inner: { val: 99, other: "keep" }, top: "also keep" }
+        expected = { inner: { val: "99", other: "keep" }, top: "also keep" }
+        assert_equal expected, Stripe::RequestParams.coerce_value(input, encoding)
+      end
+
+      should "handle object encoding with missing fields key" do
+        encoding = { kind: :object }
+        input = { amount: 100 }
+        assert_equal({ amount: 100 }, Stripe::RequestParams.coerce_value(input, encoding))
+      end
+
+      should "return value as-is for unknown composite kind" do
+        encoding = { kind: :unknown }
+        assert_equal 42, Stripe::RequestParams.coerce_value(42, encoding)
+      end
+    end
+
+    context ".coerce_params" do
+      should "return non-Hash input as-is" do
+        assert_nil Int64Params.coerce_params(nil)
+        assert_equal "string", Int64Params.coerce_params("string")
+        assert_equal 42, Int64Params.coerce_params(42)
+      end
+
+      should "return Hash as-is when no encodings are defined" do
+        input = { foo: 123, bar: "hello" }
+        assert_equal input, PlainParams.coerce_params(input)
+      end
+
+      should "coerce fields with encodings and pass through others" do
+        input = { amount: 500, name: "test" }
+        expected = { amount: "500", name: "test" }
+        assert_equal expected, Int64Params.coerce_params(input)
+      end
+
+      should "coerce nested array-of-objects encoding" do
+        input = {
+          amount: 42,
+          name: "order",
+          items: [{ qty: 10, label: "a" }, { qty: 20, label: "b" }],
+        }
+        expected = {
+          amount: "42",
+          name: "order",
+          items: [{ qty: "10", label: "a" }, { qty: "20", label: "b" }],
+        }
+        assert_equal expected, Int64Params.coerce_params(input)
+      end
+
+      should "handle nil values in encoded fields" do
+        input = { amount: nil, name: "test" }
+        expected = { amount: nil, name: "test" }
+        assert_equal expected, Int64Params.coerce_params(input)
+      end
+
+      should "coerce fields with string keys" do
+        input = { "amount" => 500, "name" => "test" }
+        expected = { "amount" => "500", "name" => "test" }
+        assert_equal expected, Int64Params.coerce_params(input)
+      end
+
+      should "coerce nested array-of-objects with string keys" do
+        input = {
+          "amount" => 42,
+          "name" => "order",
+          "items" => [{ "qty" => 10, "label" => "a" }, { "qty" => 20, "label" => "b" }],
+        }
+        expected = {
+          "amount" => "42",
+          "name" => "order",
+          "items" => [{ "qty" => "10", "label" => "a" }, { "qty" => "20", "label" => "b" }],
+        }
+        assert_equal expected, Int64Params.coerce_params(input)
+      end
+    end
+
+    context "#to_h with field_encodings" do
+      should "coerce int64_string fields when serializing via to_h" do
+        params = AmountParams.new(amount: 9_999_999_999, label: "big")
+        result = params.to_h
+        assert_equal "9999999999", result[:amount]
+        assert_equal "big", result[:label]
+      end
+
+      should "leave non-integer amount alone in to_h" do
+        params = AmountParams.new(amount: "already_string", label: "ok")
+        result = params.to_h
+        assert_equal "already_string", result[:amount]
+        assert_equal "ok", result[:label]
+      end
+    end
+
+    context "V2 RequestParams explicit key tracking" do
       should "only serialize explicitly set fields for V2 classes" do
         params = Stripe::V2::Billing::MeterEventCreateParams.new(
           event_name: "my_event",