stripe 12.7.0.pre.beta.1 → 13.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, :authenticator, :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|
@@ -45,27 +44,31 @@ 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
 
     def initialize
       @api_version = ApiVersion::CURRENT
-
       @ca_bundle_path = Stripe::DEFAULT_CA_BUNDLE_PATH
       @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, events: @meter_events_base }
     end
 
     def log_level=(val)
@@ -102,44 +105,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)
@@ -148,7 +160,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 = {}
@@ -83,13 +84,14 @@ module Stripe
       @transient_values = Set.new
       @values[:id] = id if 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 +153,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)
         dirty_value!(@values[k]) if dirty
         @unsaved_values.add(k)
       end
@@ -220,20 +222,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 = {})
@@ -357,7 +361,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)
             dirty_value!(@values[k])
             @unsaved_values.add(k)
           end
@@ -427,13 +431,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 +466,18 @@ 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.combine_opts(@opts, opts)
+      @requestor.execute_request(
+        method,
+        path,
+        base_address,
+        params: params,
+        opts: RequestOptions.extract_opts_from_hash(req_opts)
+      )
+    end
+
     # rubocop:todo Metrics/PerceivedComplexity
     protected def serialize_params_value(value, original, unsaved, force, # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
                                          key: nil)
@@ -540,21 +558,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,17 @@
+# frozen_string_literal: true
+
+module Stripe
+  class ThinEvent
+    attr_reader :id, :type, :created, :context, :related_object
+
+    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]
+      @reason = event_payload[:reason]
+    end
+  end
+end

data/lib/stripe/util.rb

@@ -4,27 +4,6 @@ require "cgi"
 
 module Stripe
   module Util
-    # Options that a user is allowed to specify.
-    OPTS_USER_SPECIFIED = Set[
-      :api_key,
-      :authenticator,
-      :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
-
     def self.objects_to_ids(obj)
       case obj
       when APIResource
@@ -44,6 +23,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
@@ -62,6 +49,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,
@@ -84,14 +72,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
 
@@ -109,8 +96,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
@@ -125,18 +112,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) }
       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
@@ -202,8 +218,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
 
@@ -218,7 +234,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
@@ -226,9 +242,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
@@ -237,15 +253,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, calculated_key, api_mode)
         else
-          result << ["#{calculated_key}[#{i}]", elem]
+          result << if api_mode == :v2
+                      [calculated_key, elem]
+                    else
+                      ["#{calculated_key}[#{i}]", elem]
+                    end
         end
       end
       result
@@ -280,13 +300,7 @@ module Stripe
       when String
         { api_key: opts }
       when Hash
-        # If the user is using request signing for authentication,
-        # no need to check the api_key per request.
-        if !(opts.key?(:client) &&
-           opts.fetch(:client).config.authenticator) &&
-           opts.key?(:api_key)
-          check_api_key!(opts.fetch(:api_key))
-        end
+        check_api_key!(opts.fetch(:api_key)) if opts.key?(:api_key)
         # Explicitly use dup here instead of clone to avoid preserving freeze
         # state on input params.
         opts.dup
@@ -341,6 +355,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
     #

data/lib/stripe/v2_list_object.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Stripe
+  module V2
+    class ListObject < StripeObject
+      OBJECT_NAME = "list"
+      def self.object_name
+        "list"
+      end
+
+      # An empty list object. This is returned from +fetch_next_page+ when we know that
+      # there isn't a next page.
+      def self.empty_list(opts = {})
+        ListObject.construct_from({ data: [] }, opts, nil, :v2)
+      end
+
+      def [](key)
+        case key
+        when String, Symbol
+          super
+        else
+          raise ArgumentError,
+                "You tried to access the #{key.inspect} index, but ListObject " \
+                "types only support String keys. (HINT: List calls return an " \
+                "object with a 'data' (which is the data array). You likely " \
+                "want to call #data[#{key.inspect}])"
+        end
+      end
+
+      # Iterates through each resource in the page represented by the current
+      # `ListObject`.
+      #
+      # Note that this method makes no effort to fetch a new page when it gets to
+      # the end of the current page's resources. See also +auto_paging_each+.
+      def each(&blk)
+        data.each(&blk)
+      end
+
+      # Iterates through each resource in the page represented by the current
+      # `ListObject` in reverse.
+      def reverse_each(&blk)
+        data.reverse_each(&blk)
+      end
+
+      # Iterates through each resource in all pages, making additional fetches to
+      # the API as necessary.
+      #
+      # Note that this method will make as many API calls as necessary to fetch
+      # all resources. For more granular control, please see +each+ and
+      # +fetch_next_page+.
+      def auto_paging_each(&blk)
+        return enum_for(:auto_paging_each) unless block_given?
+
+        page = self
+        loop do
+          page.each(&blk)
+
+          break if page.next_page_url.nil?
+
+          page = page.fetch_next_page
+        end
+      end
+
+      # Returns true if the page object contains no elements.
+      def empty?
+        data.empty?
+      end
+
+      # Fetches the next page in the resource list (if there is one).
+      #
+      # This method will try to respect the limit of the current page. If none
+      # was given, the default limit will be fetched again.
+      def fetch_next_page(opts = {})
+        return self.class.empty_list(opts) if next_page_url.nil?
+
+        _request(
+          method: :get,
+          path: next_page_url,
+          base_address: :api
+        )
+      end
+    end
+  end
+end

data/lib/stripe/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Stripe
-  VERSION = "12.7.0-beta.1"
+  VERSION = "13.0.0"
 end

data/lib/stripe/webhook.rb

@@ -18,7 +18,7 @@ module Stripe
       # doesn't GC symbols. It also decreases the likelihood that we receive a
       # bad payload that fails to parse and throws an exception.
       data = JSON.parse(payload, symbolize_names: true)
-      Event.construct_from(data)
+      Event.construct_from(data, {}, nil, :v1)
     end
 
     module Signature