Do not serialize nil on GETs (stripe#1786)

Author: mbroshi-stripe

lib/stripe/api_requestor.rb

@@ -471,17 +471,17 @@ def self.maybe_gc_connection_managers
       raise ArgumentError, "api_base cannot be empty" if base_url.nil? || base_url.empty?
 
       api_key ||= opts[:api_key]
-      params = Util.objects_to_ids(params)
 
       check_api_key!(api_key)
 
       body_params = nil
       query_params = nil
       case method
       when :get, :head, :delete
-        query_params = params
+        query_params = Util.objects_to_ids(params)
       else
-        body_params = params
+        # For v2 body params, serialize nil values to preserve explicit nulls
+        body_params = Util.objects_to_ids(params, serialize_empty: api_mode == :v2)
       end
 
       query_params, path = merge_query_params(query_params, path)

lib/stripe/util.rb

@@ -7,16 +7,22 @@ module Util
     LEGAL_FIRST_CHARACTER = /[a-zA-Z_]/.freeze
     LEGAL_VARIABLE_CHARACTER = /[a-zA-Z0-9_]/.freeze
 
-    def self.objects_to_ids(obj)
+    def self.objects_to_ids(obj, serialize_empty: false)
       case obj
       when APIResource
         obj.id
       when Hash
         res = {}
-        obj.each { |k, v| res[k] = objects_to_ids(v) unless v.nil? }
+        obj.each do |k, v|
+          if !v.nil?
+            res[k] = objects_to_ids(v, serialize_empty: serialize_empty)
+          elsif serialize_empty
+            res[k] = nil
+          end
+        end
         res
       when Array
-        obj.map { |v| objects_to_ids(v) }
+        obj.map { |v| objects_to_ids(v, serialize_empty: serialize_empty) }
       else
         obj
       end

test/stripe/util_test.rb

@@ -158,6 +158,113 @@ class UtilTest < Test::Unit::TestCase
       assert_equal [1, 2, 3], obj
     end
 
+    context "#objects_to_ids" do
+      should "convert APIResource to id" do
+        resource = Stripe::Charge.construct_from(id: "ch_123", object: "charge")
+        result = Util.objects_to_ids(resource)
+        assert_equal "ch_123", result
+      end
+
+      should "pass through primitives unchanged" do
+        assert_equal "string", Util.objects_to_ids("string")
+        assert_equal 123, Util.objects_to_ids(123)
+        assert_equal true, Util.objects_to_ids(true)
+      end
+
+      should "skip nil values in hashes by default" do
+        input = { a: "value", b: nil, c: "another" }
+        result = Util.objects_to_ids(input)
+        assert_equal({ a: "value", c: "another" }, result)
+        refute result.key?(:b)
+      end
+
+      should "keep nil values in hashes when serialize_empty is true" do
+        input = { a: "value", b: nil, c: "another" }
+        result = Util.objects_to_ids(input, serialize_empty: true)
+        assert_equal({ a: "value", b: nil, c: "another" }, result)
+        assert result.key?(:b)
+        assert_nil result[:b]
+      end
+
+      should "recurse on non-nil hash values" do
+        resource = Stripe::Charge.construct_from(id: "ch_123", object: "charge")
+        input = { charge: resource, amount: 100 }
+        result = Util.objects_to_ids(input)
+        assert_equal({ charge: "ch_123", amount: 100 }, result)
+      end
+
+      should "handle nested hashes with nil values by default" do
+        resource = Stripe::Charge.construct_from(id: "ch_123", object: "charge")
+        input = {
+          charge: resource,
+          metadata: { key: "value", empty: nil },
+          description: nil,
+        }
+        result = Util.objects_to_ids(input)
+        expected = {
+          charge: "ch_123",
+          metadata: { key: "value" },
+        }
+        assert_equal expected, result
+        refute result[:metadata].key?(:empty)
+        refute result.key?(:description)
+      end
+
+      should "handle nested hashes with nil values when serialize_empty is true" do
+        resource = Stripe::Charge.construct_from(id: "ch_123", object: "charge")
+        input = {
+          charge: resource,
+          metadata: { key: "value", empty: nil },
+          description: nil,
+        }
+        result = Util.objects_to_ids(input, serialize_empty: true)
+        expected = {
+          charge: "ch_123",
+          metadata: { key: "value", empty: nil },
+          description: nil,
+        }
+        assert_equal expected, result
+        assert result[:metadata].key?(:empty)
+        assert result.key?(:description)
+      end
+
+      should "process arrays" do
+        resource1 = Stripe::Charge.construct_from(id: "ch_123", object: "charge")
+        resource2 = Stripe::Charge.construct_from(id: "ch_456", object: "charge")
+        input = [resource1, "string", resource2]
+        result = Util.objects_to_ids(input)
+        assert_equal %w[ch_123 string ch_456], result
+      end
+
+      should "handle complex nested structures by default" do
+        resource = Stripe::Charge.construct_from(id: "ch_123", object: "charge")
+        input = {
+          charges: [resource, nil],
+          metadata: { key: nil, nested: { value: "test", empty: nil } },
+        }
+        result = Util.objects_to_ids(input)
+        expected = {
+          charges: ["ch_123", nil],
+          metadata: { nested: { value: "test" } },
+        }
+        assert_equal expected, result
+      end
+
+      should "handle complex nested structures when serialize_empty is true" do
+        resource = Stripe::Charge.construct_from(id: "ch_123", object: "charge")
+        input = {
+          charges: [resource, nil],
+          metadata: { key: nil, nested: { value: "test", empty: nil } },
+        }
+        result = Util.objects_to_ids(input, serialize_empty: true)
+        expected = {
+          charges: ["ch_123", nil],
+          metadata: { key: nil, nested: { value: "test", empty: nil } },
+        }
+        assert_equal expected, result
+      end
+    end
+
     context ".request_id_dashboard_url" do
       should "generate a livemode URL" do
         assert_equal "https://dashboard.stripe.com/live/logs/request-id",