stripe 12.5.0 → 15.0.0

data/lib/stripe/stripe_configuration.rb

@@ -25,12 +25,11 @@ module Stripe
   # If `.logger` is set, the value of `.log_level` is ignored. The decision on
   # what levels to print is entirely deferred to the logger.
   class StripeConfiguration
-    attr_accessor :api_key, :api_version, :client_id, :enable_telemetry, :logger, :stripe_account
+    attr_accessor :api_key, :api_version, :client_id, :enable_telemetry, :logger, :stripe_account, :stripe_context
 
-    attr_reader :api_base, :uploads_base, :connect_base, :ca_bundle_path, :log_level, :initial_network_retry_delay,
-                # rubocop:todo Layout/LineLength
-                :max_network_retries, :max_network_retry_delay, :open_timeout, :read_timeout, :write_timeout, :proxy, :verify_ssl_certs
-    # rubocop:enable Layout/LineLength
+    attr_reader :api_base, :uploads_base, :connect_base, :meter_events_base, :base_addresses, :ca_bundle_path,
+                :log_level, :initial_network_retry_delay, :max_network_retries, :max_network_retry_delay,
+                :open_timeout, :read_timeout, :write_timeout, :proxy, :verify_ssl_certs
 
     def self.setup
       new.tap do |instance|
@@ -38,6 +37,25 @@ module Stripe
       end
     end
 
+    # Set options to the StripeClient configured options, if valid as a client option and provided
+    # Otherwise, for user configurable global options, set them to the global configuration
+    # For all other options, set them to the StripeConfiguration default value
+    def self.client_init(config_opts)
+      global_config = Stripe.config
+      imported_options = USER_CONFIGURABLE_GLOBAL_OPTIONS - StripeClient::CLIENT_OPTIONS
+      client_config = StripeConfiguration.setup do |instance|
+        imported_options.each do |key|
+          begin
+            instance.public_send("#{key}=", global_config.public_send(key)) if global_config.respond_to?(key)
+          rescue NotImplementedError => e
+            # In Ruby <= 2.5, we can't set write_timeout on Net::HTTP, log an error and continue
+            Util.log_error("Failed to set #{key} on client configuration: #{e}")
+          end
+        end
+      end
+      client_config.reverse_duplicate_merge(config_opts)
+    end
+
     # Create a new config based off an existing one. This is useful when the
     # caller wants to override the global configuration
     def reverse_duplicate_merge(hash)
@@ -45,6 +63,9 @@ module Stripe
         hash.each do |option, value|
           instance.public_send("#{option}=", value)
         end
+        instance.send("instance_variable_set", "@base_addresses",
+                      { api: instance.api_base, connect: instance.connect_base,
+                        files: instance.uploads_base, meter_events: instance.meter_events_base, })
       end
     end
 
@@ -54,17 +75,20 @@ module Stripe
       @enable_telemetry = true
       @verify_ssl_certs = true
 
-      @max_network_retries = 0
+      @max_network_retries = 2
       @initial_network_retry_delay = 0.5
-      @max_network_retry_delay = 2
+      @max_network_retry_delay = 5
 
       @open_timeout = 30
       @read_timeout = 80
       @write_timeout = 30
 
-      @api_base = "https://api.stripe.com"
-      @connect_base = "https://connect.stripe.com"
-      @uploads_base = "https://files.stripe.com"
+      @api_base = DEFAULT_API_BASE
+      @connect_base = DEFAULT_CONNECT_BASE
+      @uploads_base = DEFAULT_UPLOAD_BASE
+      @meter_events_base = DEFAULT_METER_EVENTS_BASE
+      @base_addresses = { api: @api_base, connect: @connect_base, files: @uploads_base,
+                          meter_events: @meter_events_base, }
     end
 
     def log_level=(val)
@@ -101,44 +125,53 @@ module Stripe
 
     def open_timeout=(open_timeout)
       @open_timeout = open_timeout
-      StripeClient.clear_all_connection_managers(config: self)
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def read_timeout=(read_timeout)
       @read_timeout = read_timeout
-      StripeClient.clear_all_connection_managers(config: self)
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def write_timeout=(write_timeout)
       raise NotImplementedError unless Net::HTTP.instance_methods.include?(:write_timeout=)
 
       @write_timeout = write_timeout
-      StripeClient.clear_all_connection_managers(config: self)
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def proxy=(proxy)
       @proxy = proxy
-      StripeClient.clear_all_connection_managers(config: self)
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def verify_ssl_certs=(verify_ssl_certs)
       @verify_ssl_certs = verify_ssl_certs
-      StripeClient.clear_all_connection_managers(config: self)
+      APIRequestor.clear_all_connection_managers(config: self)
+    end
+
+    def meter_events_base=(meter_events_base)
+      @meter_events_base = meter_events_base
+      @base_addresses[:meter_events] = meter_events_base
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def uploads_base=(uploads_base)
       @uploads_base = uploads_base
-      StripeClient.clear_all_connection_managers(config: self)
+      @base_addresses[:files] = uploads_base
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def connect_base=(connect_base)
       @connect_base = connect_base
-      StripeClient.clear_all_connection_managers(config: self)
+      @base_addresses[:connect] = connect_base
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def api_base=(api_base)
       @api_base = api_base
-      StripeClient.clear_all_connection_managers(config: self)
+      @base_addresses[:api] = api_base
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     def ca_bundle_path=(path)
@@ -147,7 +180,7 @@ module Stripe
       # empty this field so a new store is initialized
       @ca_store = nil
 
-      StripeClient.clear_all_connection_managers(config: self)
+      APIRequestor.clear_all_connection_managers(config: self)
     end
 
     # A certificate store initialized from the the bundle in #ca_bundle_path and

data/lib/stripe/stripe_object.rb

@@ -72,7 +72,8 @@ module Stripe
       @additive_params.include?(name)
     end
 
-    def initialize(id = nil, opts = {})
+    def initialize(id = nil, opts = {}, api_mode = :v1, requestor = nil)
+      @api_mode = api_mode
       id, @retrieve_params = Util.normalize_id(id)
       @opts = Util.normalize_opts(opts)
       @original_values = {}
@@ -82,14 +83,16 @@ module Stripe
       @unsaved_values = Set.new
       @transient_values = Set.new
       @values[:id] = id if id
+      @id = id
       @last_response = nil
+      @requestor = requestor || APIRequestor.active_requestor
     end
 
-    def self.construct_from(values, opts = {}, last_response = nil)
+    def self.construct_from(values, opts = {}, last_response = nil, api_mode = :v1, requestor = nil)
       values = Stripe::Util.symbolize_names(values)
 
       # work around protected #initialize_from for now
-      new(values[:id]).send(:initialize_from, values, opts, last_response)
+      new(values[:id]).send(:initialize_from, values, opts, last_response, api_mode: api_mode, requestor: requestor)
     end
 
     # Determines the equality of two Stripe objects. Stripe objects are
@@ -151,7 +154,7 @@ module Stripe
     def update_attributes(values, opts = {}, dirty: true)
       values.each do |k, v|
         add_accessors([k], values) unless metaclass.method_defined?(k.to_sym)
-        @values[k] = Util.convert_to_stripe_object(v, opts)
+        @values[k] = Util.convert_to_stripe_object(v, opts, api_mode: @api_mode, requestor: @requestor)
         dirty_value!(@values[k]) if dirty
         @unsaved_values.add(k)
       end
@@ -220,20 +223,22 @@ module Stripe
     # This allows us to remove certain features that cannot or should not be
     # serialized.
     def marshal_dump
-      # The StripeClient instance in @opts is not serializable and is not
+      # The APIRequestor instance in @opts is not serializable and is not
       # really a property of the StripeObject, so we exclude it when
       # dumping
       opts = @opts.clone
+
+      # TODO: (major) Remove the :client option. This is not explicitly supported as a user-specified option.
       opts.delete(:client)
       [@values, opts]
     end
 
     # Implements custom decoding for Ruby's Marshal. Consumes data that's
     # produced by #marshal_dump.
-    def marshal_load(data)
+    def marshal_load(data, api_mode: :v1)
       values, opts = data
-      initialize(values[:id])
-      initialize_from(values, opts)
+      initialize(values[:id], api_mode: api_mode)
+      initialize_from(values, opts, api_mode: api_mode, requestor: @requestor)
     end
 
     def serialize_params(options = {})
@@ -331,7 +336,7 @@ module Stripe
       end
     end
 
-    protected def add_accessors(keys, values)
+    protected def add_accessors(keys, values) # rubocop:todo Metrics/PerceivedComplexity
       # not available in the #instance_eval below
       protected_fields = self.class.protected_fields
 
@@ -357,7 +362,7 @@ module Stripe
                                    "We interpret empty strings as nil in requests. " \
                                    "You may set (object).#{k} = nil to delete the property."
             end
-            @values[k] = Util.convert_to_stripe_object(v, @opts)
+            @values[k] = Util.convert_to_stripe_object(v, @opts, api_mode: @api_mode, requestor: @requestor)
             dirty_value!(@values[k])
             @unsaved_values.add(k)
           end
@@ -365,6 +370,19 @@ module Stripe
           define_method(:"#{k}?") { @values[k] } if [FalseClass, TrueClass].include?(values[k].class)
         end
       end
+
+      keys.each do |k|
+        if Util.valid_variable_name?(k)
+          instance_variable_set(:"@#{k}", values[k])
+        else
+          Util.log_info(<<~LOG
+            The variable name '#{k}' is not a valid Ruby variable name.
+            Use ["#{k}"] to access this field, skipping instance variable instantiation...
+          LOG
+                       )
+
+        end
+      end
     end
 
     # Disabling the cop because it's confused by the fact that the methods are
@@ -427,13 +445,15 @@ module Stripe
     # * +:opts:+ Options for StripeObject like an API key.
     # * +:partial:+ Indicates that the re-initialization should not attempt to
     #   remove accessors.
-    protected def initialize_from(values, opts, last_response = nil)
+    protected def initialize_from(values, opts, last_response = nil, api_mode:, requestor: nil)
+      @api_mode = api_mode
       @last_response = last_response
+      @requestor = requestor
 
       @opts = Util.normalize_opts(opts)
 
       # the `#send` is here so that we can keep this method private
-      @original_values = self.class.send(:deep_copy, values)
+      @original_values = self.class.send(:deep_copy, values, api_mode: api_mode)
 
       removed = Set.new(@values.keys - values.keys)
       added = Set.new(values.keys - @values.keys)
@@ -460,6 +480,19 @@ module Stripe
       self
     end
 
+    # Should only be for v2 events and lists, for now.
+    protected def _request(method:, path:, base_address:, params: {}, opts: {})
+      req_opts = RequestOptions.extract_opts_from_hash(opts)
+      req_opts = RequestOptions.combine_opts(@opts, req_opts)
+      @requestor.execute_request(
+        method,
+        path,
+        base_address,
+        params: params,
+        opts: req_opts
+      )
+    end
+
     # rubocop:todo Metrics/PerceivedComplexity
     protected def serialize_params_value(value, original, unsaved, force, # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
                                          key: nil)
@@ -516,7 +549,7 @@ module Stripe
       # example by appending a new hash onto `additional_owners` for an
       # account.
       elsif value.is_a?(Hash)
-        Util.convert_to_stripe_object(value, @opts).serialize_params
+        Util.convert_to_stripe_object(value, @opts, api_mode: @api_mode, requestor: @requestor).serialize_params
 
       elsif value.is_a?(StripeObject)
         update = value.serialize_params(force: force)
@@ -540,21 +573,22 @@ module Stripe
 
     # Produces a deep copy of the given object including support for arrays,
     # hashes, and StripeObjects.
-    private_class_method def self.deep_copy(obj)
+    private_class_method def self.deep_copy(obj, api_mode:)
       case obj
       when Array
-        obj.map { |e| deep_copy(e) }
+        obj.map { |e| deep_copy(e, api_mode: api_mode) }
       when Hash
         obj.each_with_object({}) do |(k, v), copy|
-          copy[k] = deep_copy(v)
+          copy[k] = deep_copy(v, api_mode: api_mode)
           copy
         end
       when StripeObject
         obj.class.construct_from(
-          deep_copy(obj.instance_variable_get(:@values)),
-          obj.instance_variable_get(:@opts).select do |k, _v|
-            Util::OPTS_COPYABLE.include?(k)
-          end
+          deep_copy(obj.instance_variable_get(:@values), api_mode: api_mode),
+          RequestOptions.copyable(obj.instance_variable_get(:@opts)),
+          nil,
+          api_mode,
+          obj.instance_variable_get(:@requestor)
         )
       else
         obj

data/lib/stripe/stripe_service.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+# typed: true
+
+module Stripe
+  class StripeService
+    # Initializes a new StripeService
+    def initialize(requestor)
+      @requestor = requestor
+    end
+
+    def request(method:, path:, base_address:, params: {}, opts: {})
+      @requestor.execute_request(
+        method,
+        path,
+        base_address,
+        params: params,
+        opts: RequestOptions.extract_opts_from_hash(opts)
+      )
+    end
+
+    def request_stream(method:, path:, base_address:, params: {}, opts: {}, &read_body_chunk_block)
+      @requestor.execute_request_stream(
+        method,
+        path,
+        base_address,
+        params: params,
+        opts: RequestOptions.extract_opts_from_hash(opts),
+        &read_body_chunk_block
+      )
+    end
+  end
+end

data/lib/stripe/thin_event.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Stripe
+  class EventReasonRequest
+    attr_reader :id, :idempotency_key
+
+    def initialize(event_reason_request_payload = {})
+      @id = event_reason_request_payload[:id]
+      @idempotency_key = event_reason_request_payload[:idempotency_key]
+    end
+  end
+
+  class EventReason
+    attr_reader :type, :request
+
+    def initialize(event_reason_payload = {})
+      @type = event_reason_payload[:type]
+      @request = EventReasonRequest.new(event_reason_payload[:request])
+    end
+  end
+
+  class ThinEvent
+    attr_reader :id, :type, :created, :context, :related_object, :livemode, :reason
+
+    def initialize(event_payload = {})
+      @id = event_payload[:id]
+      @type = event_payload[:type]
+      @created = event_payload[:created]
+      @context = event_payload[:context]
+      @livemode = event_payload[:livemode]
+      @related_object = event_payload[:related_object]
+      return if event_payload[:reason].nil?
+
+      @reason = EventReason.new(event_payload[:reason])
+    end
+  end
+end

data/lib/stripe/util.rb

@@ -4,25 +4,8 @@ require "cgi"
 
 module Stripe
   module Util
-    # Options that a user is allowed to specify.
-    OPTS_USER_SPECIFIED = Set[
-      :api_key,
-      :idempotency_key,
-      :stripe_account,
-      :stripe_version
-    ].freeze
-
-    # Options that should be copyable from one StripeObject to another
-    # including options that may be internal.
-    OPTS_COPYABLE = (
-      OPTS_USER_SPECIFIED + Set[:api_base]
-    ).freeze
-
-    # Options that should be persisted between API requests. This includes
-    # client, which is an object containing an HTTP client to reuse.
-    OPTS_PERSISTABLE = (
-      OPTS_USER_SPECIFIED + Set[:client] - Set[:idempotency_key]
-    ).freeze
+    LEGAL_FIRST_CHARACTER = /[a-zA-Z_]/.freeze
+    LEGAL_VARIABLE_CHARACTER = /[a-zA-Z0-9_]/.freeze
 
     def self.objects_to_ids(obj)
       case obj
@@ -43,6 +26,14 @@ module Stripe
       @object_classes ||= Stripe::ObjectTypes.object_names_to_classes
     end
 
+    def self.v2_object_classes
+      @v2_object_classes ||= Stripe::ObjectTypes.v2_object_names_to_classes
+    end
+
+    def self.thin_event_classes
+      @thin_event_classes ||= Stripe::EventTypes.thin_event_names_to_classes
+    end
+
     def self.object_name_matches_class?(object_name, klass)
       Util.object_classes[object_name] == klass
     end
@@ -61,6 +52,7 @@ module Stripe
     #     custom_method :capture, http_verb: post
     # adds a `capture` class method to the resource class that, when called,
     # will send a POST request to `/v1/<object_name>/capture`.
+    # TODO: are we comfortable with deleting this?
     def self.custom_method(resource, target, name, http_verb, http_path)
       unless %i[get post delete].include?(http_verb)
         raise ArgumentError,
@@ -83,14 +75,13 @@ module Stripe
               "#{CGI.escape(id)}/" \
               "#{CGI.escape(http_path)}"
 
-        resp, opts = resource.execute_resource_request(
+        resource.execute_resource_request(
           http_verb,
           url,
+          :api,
           params,
           opts
         )
-
-        Util.convert_to_stripe_object_with_params(resp.data, params, opts, resp)
       end
     end
 
@@ -108,8 +99,8 @@ module Stripe
     #   will be reused on subsequent API calls.
     # * +opts+ - Options for +StripeObject+ like an API key that will be reused
     #   on subsequent API calls.
-    def self.convert_to_stripe_object(data, opts = {})
-      convert_to_stripe_object_with_params(data, {}, opts)
+    def self.convert_to_stripe_object(data, opts = {}, api_mode: :v1, requestor: nil)
+      convert_to_stripe_object_with_params(data, {}, opts, api_mode: api_mode, requestor: requestor)
     end
 
     # Converts a hash of fields or an array of hashes into a +StripeObject+ or
@@ -124,18 +115,47 @@ module Stripe
     # * +data+ - Hash of fields and values to be converted into a StripeObject.
     # * +opts+ - Options for +StripeObject+ like an API key that will be reused
     #   on subsequent API calls.
-    def self.convert_to_stripe_object_with_params(data, params, opts = {}, last_response = nil)
+    # * +last_response+ - The raw response associated with the object.
+    # * +api_mode+ - The API mode to use when converting the object, either :v1 or :v2.
+    # * +requestor+ - The requestor to use when constructing the object.
+    def self.convert_to_stripe_object_with_params(
+      data,
+      params,
+      opts = {},
+      last_response = nil,
+      api_mode: :v1,
+      requestor: nil
+    )
       opts = normalize_opts(opts)
 
       case data
       when Array
-        data.map { |i| convert_to_stripe_object(i, opts) }
+        data.map { |i| convert_to_stripe_object(i, opts, api_mode: api_mode, requestor: requestor) }
       when Hash
+        # TODO: This is a terrible hack.
+        # Waiting on https://jira.corp.stripe.com/browse/API_SERVICES-3167 to add
+        # an object in v2 lists
+        if api_mode == :v2 && data.include?(:data) && data.include?(:next_page_url)
+          return V2::ListObject.construct_from(data, opts, last_response, api_mode, requestor)
+        end
+
         # Try converting to a known object class.  If none available, fall back
         # to generic StripeObject
+        object_type = data[:type] || data["type"]
         object_name = data[:object] || data["object"]
-        obj = object_classes.fetch(object_name, StripeObject)
-                            .construct_from(data, opts, last_response)
+        object_class = if api_mode == :v2
+                         if object_name == "v2.core.event" && thin_event_classes.key?(object_type)
+                           thin_event_classes.fetch(object_type)
+                         else
+                           v2_object_classes.fetch(
+                             object_name, StripeObject
+                           )
+                         end
+                       else
+                         object_classes.fetch(object_name, StripeObject)
+                       end
+
+        obj = object_class.construct_from(data, opts, last_response, api_mode, requestor)
 
         # set filters so that we can fetch the same limit, expansions, and
         # predicates when accessing the next and previous pages
@@ -201,8 +221,8 @@ module Stripe
     # parameters in a URI or as form parameters in a request body. This mainly
     # involves escaping special characters from parameter keys and values (e.g.
     # `&`).
-    def self.encode_parameters(params)
-      Util.flatten_params(params)
+    def self.encode_parameters(params, api_mode)
+      Util.flatten_params(params, api_mode)
           .map { |k, v| "#{url_encode(k)}=#{url_encode(v)}" }.join("&")
     end
 
@@ -217,7 +237,7 @@ module Stripe
         gsub("%5B", "[").gsub("%5D", "]")
     end
 
-    def self.flatten_params(params, parent_key = nil)
+    def self.flatten_params(params, api_mode, parent_key = nil)
       result = []
 
       # do not sort the final output because arrays (and arrays of hashes
@@ -225,9 +245,9 @@ module Stripe
       params.each do |key, value|
         calculated_key = parent_key ? "#{parent_key}[#{key}]" : key.to_s
         if value.is_a?(Hash)
-          result += flatten_params(value, calculated_key)
+          result += flatten_params(value, api_mode, calculated_key)
         elsif value.is_a?(Array)
-          result += flatten_params_array(value, calculated_key)
+          result += flatten_params_array(value, api_mode, calculated_key)
         else
           result << [calculated_key, value]
         end
@@ -236,15 +256,19 @@ module Stripe
       result
     end
 
-    def self.flatten_params_array(value, calculated_key)
+    def self.flatten_params_array(value, api_mode, calculated_key)
       result = []
       value.each_with_index do |elem, i|
         if elem.is_a?(Hash)
-          result += flatten_params(elem, "#{calculated_key}[#{i}]")
+          result += flatten_params(elem, api_mode, "#{calculated_key}[#{i}]")
         elsif elem.is_a?(Array)
-          result += flatten_params_array(elem, calculated_key)
+          result += flatten_params_array(elem, api_mode, calculated_key)
         else
-          result << ["#{calculated_key}[#{i}]", elem]
+          result << if api_mode == :v2
+                      [calculated_key, elem]
+                    else
+                      ["#{calculated_key}[#{i}]", elem]
+                    end
         end
       end
       result
@@ -288,6 +312,14 @@ module Stripe
       end
     end
 
+    # Return false for strings that are invalid variable names
+    # Does NOT expect there to be a preceding '@' for instance variables
+    def self.valid_variable_name?(key)
+      return false if key.empty? || key[0] !~ LEGAL_FIRST_CHARACTER
+
+      key[1..-1].chars.all? { |char| char =~ LEGAL_VARIABLE_CHARACTER }
+    end
+
     def self.check_string_argument!(key)
       raise TypeError, "argument must be a string" unless key.is_a?(String)
 
@@ -334,6 +366,15 @@ module Stripe
       res.zero?
     end
 
+    # Returns either v1 or v2 as api_mode based on the given path
+    def self.get_api_mode(path)
+      if path.start_with?("/v2/")
+        :v2
+      else
+        :v1
+      end
+    end
+
     #
     # private
     #