stripe 5.38.0 → 15.2.1

data/lib/stripe/api_operations/create.rb

@@ -4,8 +4,12 @@ module Stripe
   module APIOperations
     module Create
       def create(params = {}, opts = {})
-        resp, opts = execute_resource_request(:post, resource_url, params, opts)
-        Util.convert_to_stripe_object(resp.data, opts)
+        request_stripe_object(
+          method: :post,
+          path: resource_url,
+          params: params,
+          opts: opts
+        )
       end
     end
   end

data/lib/stripe/api_operations/delete.rb

@@ -18,17 +18,22 @@ module Stripe
         #   api_key to be overwritten. See
         #   {APIOperations::Request.execute_resource_request}.
         def delete(id, params = {}, opts = {})
-          resp, opts = execute_resource_request(:delete,
-                                                "#{resource_url}/#{id}",
-                                                params, opts)
-          Util.convert_to_stripe_object(resp.data, opts)
+          request_stripe_object(
+            method: :delete,
+            path: "#{resource_url}/#{id}",
+            params: params,
+            opts: opts
+          )
         end
       end
 
       def delete(params = {}, opts = {})
-        resp, opts = execute_resource_request(:delete, resource_url,
-                                              params, opts)
-        initialize_from(resp.data, opts)
+        request_stripe_object(
+          method: :delete,
+          path: resource_url,
+          params: params,
+          opts: opts
+        )
       end
 
       def self.included(base)

data/lib/stripe/api_operations/list.rb

@@ -4,15 +4,12 @@ module Stripe
   module APIOperations
     module List
       def list(filters = {}, opts = {})
-        opts = Util.normalize_opts(opts)
-
-        resp, opts = execute_resource_request(:get, resource_url, filters, opts)
-        obj = ListObject.construct_from(resp.data, opts)
-
-        # set filters so that we can fetch the same limit, expansions, and
-        # predicates when accessing the next and previous pages
-        obj.filters = filters.dup
-        obj
+        request_stripe_object(
+          method: :get,
+          path: resource_url,
+          params: filters,
+          opts: opts
+        )
       end
     end
   end

data/lib/stripe/api_operations/nested_resource.rb

@@ -26,46 +26,74 @@ module Stripe
         end
 
         operations.each do |operation|
-          case operation
-          when :create
-            define_singleton_method(:"create_#{resource}") \
+          define_operation(
+            resource,
+            operation,
+            resource_url_method,
+            resource_plural
+          )
+        end
+      end
+
+      private def define_operation(
+        resource,
+        operation,
+        resource_url_method,
+        resource_plural
+      )
+        case operation
+        when :create
+          define_singleton_method(:"create_#{resource}") \
               do |id, params = {}, opts = {}|
-                url = send(resource_url_method, id)
-                resp, opts = execute_resource_request(:post, url, params, opts)
-                Util.convert_to_stripe_object(resp.data, opts)
+                request_stripe_object(
+                  method: :post,
+                  path: send(resource_url_method, id),
+                  params: params,
+                  opts: opts
+                )
               end
-          when :retrieve
-            define_singleton_method(:"retrieve_#{resource}") \
-              do |id, nested_id, opts = {}|
-                url = send(resource_url_method, id, nested_id)
-                resp, opts = execute_resource_request(:get, url, {}, opts)
-                Util.convert_to_stripe_object(resp.data, opts)
+        when :retrieve
+          define_singleton_method(:"retrieve_#{resource}") \
+              do |id, nested_id, params = {}, opts = {}|
+                request_stripe_object(
+                  method: :get,
+                  path: send(resource_url_method, id, nested_id),
+                  params: params,
+                  opts: opts
+                )
               end
-          when :update
-            define_singleton_method(:"update_#{resource}") \
+        when :update
+          define_singleton_method(:"update_#{resource}") \
               do |id, nested_id, params = {}, opts = {}|
-                url = send(resource_url_method, id, nested_id)
-                resp, opts = execute_resource_request(:post, url, params, opts)
-                Util.convert_to_stripe_object(resp.data, opts)
+                request_stripe_object(
+                  method: :post,
+                  path: send(resource_url_method, id, nested_id),
+                  params: params,
+                  opts: opts
+                )
               end
-          when :delete
-            define_singleton_method(:"delete_#{resource}") \
+        when :delete
+          define_singleton_method(:"delete_#{resource}") \
               do |id, nested_id, params = {}, opts = {}|
-                url = send(resource_url_method, id, nested_id)
-                resp, opts = execute_resource_request(:delete, url, params,
-                                                      opts)
-                Util.convert_to_stripe_object(resp.data, opts)
+                request_stripe_object(
+                  method: :delete,
+                  path: send(resource_url_method, id, nested_id),
+                  params: params,
+                  opts: opts
+                )
               end
-          when :list
-            define_singleton_method(:"list_#{resource_plural}") \
+        when :list
+          define_singleton_method(:"list_#{resource_plural}") \
               do |id, params = {}, opts = {}|
-                url = send(resource_url_method, id)
-                resp, opts = execute_resource_request(:get, url, params, opts)
-                Util.convert_to_stripe_object(resp.data, opts)
+                request_stripe_object(
+                  method: :get,
+                  path: send(resource_url_method, id),
+                  params: params,
+                  opts: opts
+                )
               end
-          else
-            raise ArgumentError, "Unknown operation: #{operation.inspect}"
-          end
+        else
+          raise ArgumentError, "Unknown operation: #{operation.inspect}"
         end
       end
     end

data/lib/stripe/api_operations/request.rb

@@ -4,86 +4,52 @@ module Stripe
   module APIOperations
     module Request
       module ClassMethods
-        def execute_resource_request(method, url,
-                                     params = {}, opts = {})
+        def execute_resource_request(method, url, base_address = :api,
+                                     params = {}, opts = {}, usage = [])
           execute_resource_request_internal(
-            :execute_request, method, url, params, opts
+            :execute_request, method, url, base_address, params, opts, usage
           )
         end
 
-        def execute_resource_request_stream(method, url,
-                                            params = {}, opts = {},
+        def execute_resource_request_stream(method, url, base_address = :api,
+                                            params = {}, opts = {}, usage = [],
                                             &read_body_chunk_block)
           execute_resource_request_internal(
             :execute_request_stream,
             method,
             url,
+            base_address,
             params,
             opts,
+            usage,
             &read_body_chunk_block
           )
         end
 
+        private def request_stripe_object(method:, path:, base_address: :api, params: {}, opts: {}, usage: [])
+          execute_resource_request(method, path, base_address, params, opts, usage)
+        end
+
         private def execute_resource_request_internal(client_request_method_sym,
-                                                      method, url,
-                                                      params, opts,
+                                                      method, url, base_address,
+                                                      params, opts, usage,
                                                       &read_body_chunk_block)
+          params = params.to_h if params.is_a?(Stripe::RequestParams)
           params ||= {}
 
           error_on_invalid_params(params)
           warn_on_opts_in_params(params)
 
           opts = Util.normalize_opts(opts)
-          error_on_non_string_user_opts(opts)
-
-          opts[:client] ||= StripeClient.active_client
-
-          headers = opts.clone
-          api_key = headers.delete(:api_key)
-          api_base = headers.delete(:api_base)
-          client = headers.delete(:client)
-          # Assume all remaining opts must be headers
+          req_opts = RequestOptions.extract_opts_from_hash(opts)
 
-          resp, opts[:api_key] = client.send(
+          APIRequestor.active_requestor.send(
             client_request_method_sym,
             method, url,
-            api_base: api_base, api_key: api_key,
-            headers: headers, params: params,
+            base_address,
+            params: params, opts: req_opts, usage: usage,
             &read_body_chunk_block
           )
-
-          # Hash#select returns an array before 1.9
-          opts_to_persist = {}
-          opts.each do |k, v|
-            opts_to_persist[k] = v if Util::OPTS_PERSISTABLE.include?(k)
-          end
-
-          [resp, opts_to_persist]
-        end
-
-        # This method used to be called `request`, but it's such a short name
-        # that it eventually conflicted with the name of a field on an API
-        # resource (specifically, `Event#request`), so it was renamed to
-        # something more unique.
-        #
-        # The former name had been around for just about forever though, and
-        # although all internal uses have been renamed, I've left this alias in
-        # place for backwards compatibility. Consider removing it on the next
-        # major.
-        alias request execute_resource_request
-
-        private def error_on_non_string_user_opts(opts)
-          Util::OPTS_USER_SPECIFIED.each do |opt|
-            next unless opts.key?(opt)
-
-            val = opts[opt]
-            next if val.nil?
-            next if val.is_a?(String)
-
-            raise ArgumentError,
-                  "request option '#{opt}' should be a string value " \
-                    "(was a #{val.class})"
-          end
         end
 
         private def error_on_invalid_params(params)
@@ -91,14 +57,12 @@ module Stripe
 
           raise ArgumentError,
                 "request params should be either a Hash or nil " \
-                  "(was a #{params.class})"
+                "(was a #{params.class})"
         end
 
         private def warn_on_opts_in_params(params)
-          Util::OPTS_USER_SPECIFIED.each do |opt|
-            if params.key?(opt)
-              warn("WARNING: '#{opt}' should be in opts instead of params.")
-            end
+          RequestOptions::OPTS_USER_SPECIFIED.each do |opt|
+            warn("WARNING: '#{opt}' should be in opts instead of params.") if params.key?(opt)
           end
         end
       end
@@ -107,23 +71,24 @@ module Stripe
         base.extend(ClassMethods)
       end
 
-      protected def execute_resource_request(method, url,
-                                             params = {}, opts = {})
+      protected def execute_resource_request(method, url, base_address = :api,
+                                             params = {}, opts = {}, usage = [])
         opts = @opts.merge(Util.normalize_opts(opts))
-        self.class.execute_resource_request(method, url, params, opts)
+        self.class.execute_resource_request(method, url, base_address, params, opts, usage)
       end
 
-      protected def execute_resource_request_stream(method, url,
-                                                    params = {}, opts = {},
+      protected def execute_resource_request_stream(method, url, base_address = :api,
+                                                    params = {}, opts = {}, usage = [],
                                                     &read_body_chunk_block)
         opts = @opts.merge(Util.normalize_opts(opts))
         self.class.execute_resource_request_stream(
-          method, url, params, opts, &read_body_chunk_block
+          method, url, base_address, params, opts, usage, &read_body_chunk_block
         )
       end
 
-      # See notes on `alias` above.
-      alias request execute_resource_request
+      private def request_stripe_object(method:, path:, params:, base_address: :api, opts: {}, usage: [])
+        execute_resource_request(method, path, base_address, params, opts, usage)
+      end
     end
   end
 end

data/lib/stripe/api_operations/save.rb

@@ -19,17 +19,21 @@ module Stripe
         #   {APIOperations::Request.execute_resource_request}.
         def update(id, params = {}, opts = {})
           params.each_key do |k|
-            if protected_fields.include?(k)
-              raise ArgumentError, "Cannot update protected field: #{k}"
-            end
+            raise ArgumentError, "Cannot update protected field: #{k}" if protected_fields.include?(k)
           end
 
-          resp, opts = execute_resource_request(:post, "#{resource_url}/#{id}",
-                                                params, opts)
-          Util.convert_to_stripe_object(resp.data, opts)
+          request_stripe_object(
+            method: :post,
+            path: "#{resource_url}/#{id}",
+            params: params,
+            opts: opts
+          )
         end
       end
 
+      # The `save` method is DEPRECATED and will be removed in a future major
+      # version of the library. Use the `update` method on the resource instead.
+      #
       # Creates or updates an API resource.
       #
       # If the resource doesn't yet have an assigned ID and the resource is one
@@ -58,13 +62,19 @@ module Stripe
 
         values = serialize_params(self).merge(params)
 
-        # note that id gets removed here our call to #url above has already
+        # Please note that id gets removed here our call to #url above has already
         # generated a uri for this object with an identifier baked in
         values.delete(:id)
-
-        resp, opts = execute_resource_request(:post, save_url, values, opts)
-        initialize_from(resp.data, opts)
+        opts = Util.normalize_opts(opts)
+        APIRequestor.active_requestor.execute_request_initialize_from(:post, save_url, :api, self,
+                                                                      params: values,
+                                                                      opts: RequestOptions.extract_opts_from_hash(opts),
+                                                                      usage: ["save"])
       end
+      extend Gem::Deprecate
+      deprecate :save, "the `update` class method (for examples " \
+                       "see https://github.com/stripe/stripe-ruby" \
+                       "/wiki/Migration-guide-for-v8)", 2022, 11
 
       def self.included(base)
         # Set `metadata` as additive so that when it's set directly we remember

data/lib/stripe/api_operations/search.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Stripe
+  module APIOperations
+    # The _search method via API Operations is deprecated.
+    # Please use the search method from within the resource instead.
+    module Search
+      def _search(search_url, filters = {}, opts = {})
+        request_stripe_object(
+          method: :get,
+          path: search_url,
+          params: filters,
+          opts: opts
+        )
+      end
+
+      extend Gem::Deprecate
+      deprecate :_search, "request_stripe_object", 2024, 1
+    end
+  end
+end

data/lib/stripe/api_operations/singleton_save.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Stripe
+  module APIOperations
+    module SingletonSave
+      module ClassMethods
+        # Updates a singleton API resource
+        #
+        # Updates the identified resource with the passed in parameters.
+        #
+        # ==== Attributes
+        #
+        # * +params+ - A hash of parameters to pass to the API
+        # * +opts+ - A Hash of additional options (separate from the params /
+        #   object values) to be added to the request. E.g. to allow for an
+        #   idempotency_key to be passed in the request headers, or for the
+        #   api_key to be overwritten. See
+        #   {APIOperations::Request.execute_resource_request}.
+        def update(params = {}, opts = {})
+          params.each_key do |k|
+            raise ArgumentError, "Cannot update protected field: #{k}" if protected_fields.include?(k)
+          end
+
+          request_stripe_object(
+            method: :post,
+            path: resource_url,
+            params: params,
+            opts: opts
+          )
+        end
+      end
+
+      # The `save` method is DEPRECATED and will be removed in a future major
+      # version of the library. Use the `update` method on the resource instead.
+      #
+      # Updates a singleton API resource.
+      #
+      # If the resource doesn't yet have an assigned ID and the resource is one
+      # that can be created, then the method attempts to create the resource.
+      # The resource is updated otherwise.
+      #
+      # ==== Attributes
+      #
+      # * +params+ - Overrides any parameters in the resource's serialized data
+      #   and includes them in the create or update. If +:req_url:+ is included
+      #   in the list, it overrides the update URL used for the create or
+      #   update.
+      # * +opts+ - A Hash of additional options (separate from the params /
+      #   object values) to be added to the request. E.g. to allow for an
+      #   idempotency_key to be passed in the request headers, or for the
+      #   api_key to be overwritten. See
+      #   {APIOperations::Request.execute_resource_request}.
+      def save(params = {}, opts = {})
+        # We started unintentionally (sort of) allowing attributes sent to
+        # +save+ to override values used during the update. So as not to break
+        # the API, this makes that official here.
+        update_attributes(params)
+
+        # Now remove any parameters that look like object attributes.
+        params = params.reject { |k, _| respond_to?(k) }
+
+        values = serialize_params(self).merge(params)
+
+        opts = Util.normalize_opts(opts)
+
+        APIRequestor.active_requestor.execute_request_initialize_from(:post, resource_url, :api, self,
+                                                                      params: values,
+                                                                      opts: RequestOptions.extract_opts_from_hash(opts),
+                                                                      usage: ["save"])
+      end
+      extend Gem::Deprecate
+      deprecate :save, "the `update` class method (for examples " \
+                       "see https://github.com/stripe/stripe-ruby" \
+                       "/wiki/Migration-guide-for-v8)", 2022, 11
+
+      def self.included(base)
+        # Set `metadata` as additive so that when it's set directly we remember
+        # to clear keys that may have been previously set by sending empty
+        # values for them.
+        #
+        # It's possible that not every object with `Save` has `metadata`, but
+        # it's a close enough heuristic, and having this option set when there
+        # is no `metadata` field is not harmful.
+        base.additive_object_param(:metadata)
+
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end