stripe 5.55.0 → 18.2.0.pre.beta.1

data/lib/stripe/stripe_configuration.rb

@@ -25,26 +25,12 @@ 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
-    attr_accessor :api_version
-    attr_accessor :client_id
-    attr_accessor :enable_telemetry
-    attr_accessor :logger
-    attr_accessor :stripe_account
-
-    attr_reader :api_base
-    attr_reader :uploads_base
-    attr_reader :connect_base
-    attr_reader :ca_bundle_path
-    attr_reader :log_level
-    attr_reader :initial_network_retry_delay
-    attr_reader :max_network_retries
-    attr_reader :max_network_retry_delay
-    attr_reader :open_timeout
-    attr_reader :read_timeout
-    attr_reader :write_timeout
-    attr_reader :proxy
-    attr_reader :verify_ssl_certs
+    attr_accessor :api_key, :api_version, :authenticator, :client_id, :enable_telemetry, :logger,
+                  :stripe_account, :stripe_context
+
+    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|
@@ -52,6 +38,20 @@ 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|
+          instance.public_send("#{key}=", global_config.public_send(key)) if global_config.respond_to?(key)
+        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)
@@ -59,25 +59,33 @@ 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,
+                          meter_events: @meter_events_base, }
     end
 
     def log_level=(val)
@@ -86,13 +94,16 @@ module Stripe
         val = Stripe::LEVEL_DEBUG
       elsif val == "info"
         val = Stripe::LEVEL_INFO
+      elsif val == "error"
+        val = Stripe::LEVEL_ERROR
       end
 
       levels = [Stripe::LEVEL_INFO, Stripe::LEVEL_DEBUG, Stripe::LEVEL_ERROR]
 
       if !val.nil? && !levels.include?(val)
         raise ArgumentError,
-              "log_level should only be set to `nil`, `debug` or `info`"
+              "log_level should only be set to `nil`, `debug`, `info`, " \
+              "or `error`"
       end
       @log_level = val
     end
@@ -111,46 +122,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)
-      unless Net::HTTP.instance_methods.include?(:write_timeout=)
-        raise NotImplementedError
-      end
+      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)
@@ -159,7 +177,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
@@ -173,10 +191,10 @@ module Stripe
     # and is itself not thread safe.
     def ca_store
       @ca_store ||= begin
-                      store = OpenSSL::X509::Store.new
-                      store.add_file(ca_bundle_path)
-                      store
-                    end
+        store = OpenSSL::X509::Store.new
+        store.add_file(ca_bundle_path)
+        store
+      end
     end
 
     def enable_telemetry?

data/lib/stripe/stripe_context.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Stripe
+  # Represents hierarchical context for Stripe API operations.
+  #
+  # This class is immutable - all methods return new instances rather than
+  # modifying the existing instance. It provides utilities for building
+  # context hierarchies and converting to/from string representations.
+  class StripeContext
+    include Comparable
+
+    attr_reader :segments
+
+    # Creates a new StripeContext with the given segments.
+    def initialize(segments = nil)
+      @segments = (segments || []).map(&:to_s).freeze
+    end
+
+    # Parses a context string into a StripeContext instance.
+    def self.parse(context_str)
+      return new if context_str.nil? || context_str.empty?
+
+      new(context_str.split("/"))
+    end
+
+    # Creates a new StripeContext with an additional segment appended.
+    def push(segment)
+      segment_str = segment.to_s.strip
+      raise ArgumentError, "Segment cannot be empty or whitespace" if segment_str.empty?
+
+      new_segments = @segments + [segment_str]
+      self.class.new(new_segments)
+    end
+
+    # Creates a new StripeContext with the last segment removed.
+    # If there are no segments, returns a new empty StripeContext.
+    def pop
+      raise IndexError, "No segments to pop" if @segments.empty?
+
+      new_segments = @segments[0...-1]
+      self.class.new(new_segments)
+    end
+
+    # Converts this context to its string representation.
+    def to_s
+      @segments.join("/")
+    end
+
+    # Checks equality with another StripeContext.
+    def ==(other)
+      other.is_a?(StripeContext) && @segments == other.segments
+    end
+
+    # Alias for == to support eql? method
+    alias eql? ==
+
+    # Returns a human-readable representation for debugging.
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)} segments=#{@segments.inspect}>"
+    end
+
+    # Returns true if the context has no segments.
+    # @return [Boolean] true if empty, false otherwise
+    def empty?
+      @segments.empty?
+    end
+  end
+end

data/lib/stripe/stripe_event_notification_handler.rb

@@ -0,0 +1,425 @@
+# frozen_string_literal: true
+
+module Stripe
+  class UnhandledNotificationDetails
+    attr_reader :is_known_event_type
+
+    def initialize(is_known_event_type)
+      @is_known_event_type = is_known_event_type
+    end
+  end
+
+  class StripeEventNotificationHandler
+    def initialize(client, webhook_secret, &fallback_callback)
+      raise ArgumentError, "You must pass a block to act as a fallback" if fallback_callback.nil?
+
+      @client = client
+      @webhook_secret = webhook_secret
+      @fallback_callback = fallback_callback
+
+      @registered_handlers = {}
+      @has_handled_events = false
+    end
+
+    def handle(webhook_body, sig_header)
+      # we're ok with this not being a thread-safe write since registering
+      # handlers should happen synchronously on startup before any multi-threaded reads happen
+      @has_handled_events = true
+
+      notif = @client.parse_event_notification(
+        webhook_body,
+        sig_header,
+        @webhook_secret
+      )
+
+      # Create a new client with the event's context to ensure thread-safety
+      event_client = new_client_with_context(notif.context)
+
+      handler = @registered_handlers[notif.type]
+      if handler
+        handler.call(notif, event_client)
+      else
+        @fallback_callback.call(notif, event_client,
+                                UnhandledNotificationDetails.new(!notif.is_a?(Stripe::Events::UnknownEventNotification)))
+      end
+    end
+
+    def registered_event_types
+      @registered_handlers.keys.sort
+    end
+
+    private def register(event_type, &handler)
+      raise "Cannot register new event handlers after handling events" if @has_handled_events
+      if @registered_handlers.key?(event_type)
+        raise ArgumentError, "Handler already registered for event type: #{event_type}"
+      end
+
+      @registered_handlers[event_type] = handler
+    end
+
+    private def new_client_with_context(context)
+      config = @client.requestor.config
+      StripeClient.new(
+        config.api_key,
+        stripe_account: config.stripe_account,
+        stripe_context: context,
+        stripe_version: config.api_version,
+        api_base: config.api_base,
+        uploads_base: config.uploads_base,
+        connect_base: config.connect_base,
+        meter_events_base: config.meter_events_base,
+        client_id: config.client_id
+      )
+    end
+
+    # event-handler-methods: The beginning of the section generated from our OpenAPI spec
+    def on_v1_billing_meter_error_report_triggered(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v1.billing.meter.error_report_triggered", &handler)
+    end
+
+    def on_v1_billing_meter_no_meter_found(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v1.billing.meter.no_meter_found", &handler)
+    end
+
+    def on_v2_core_account_closed(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account.closed", &handler)
+    end
+
+    def on_v2_core_account_created(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account.created", &handler)
+    end
+
+    def on_v2_core_account_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account.updated", &handler)
+    end
+
+    def on_v2_core_account_including_configuration_customer_capability_status_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account[configuration.customer].capability_status_updated", &handler)
+    end
+
+    def on_v2_core_account_including_configuration_customer_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account[configuration.customer].updated", &handler)
+    end
+
+    def on_v2_core_account_including_configuration_merchant_capability_status_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account[configuration.merchant].capability_status_updated", &handler)
+    end
+
+    def on_v2_core_account_including_configuration_merchant_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account[configuration.merchant].updated", &handler)
+    end
+
+    def on_v2_core_account_including_configuration_recipient_capability_status_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account[configuration.recipient].capability_status_updated", &handler)
+    end
+
+    def on_v2_core_account_including_configuration_recipient_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account[configuration.recipient].updated", &handler)
+    end
+
+    def on_v2_core_account_including_configuration_storer_capability_status_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account[configuration.storer].capability_status_updated", &handler)
+    end
+
+    def on_v2_core_account_including_configuration_storer_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account[configuration.storer].updated", &handler)
+    end
+
+    def on_v2_core_account_including_defaults_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account[defaults].updated", &handler)
+    end
+
+    def on_v2_core_account_including_identity_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account[identity].updated", &handler)
+    end
+
+    def on_v2_core_account_including_requirements_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account[requirements].updated", &handler)
+    end
+
+    def on_v2_core_account_link_returned(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account_link.returned", &handler)
+    end
+
+    def on_v2_core_account_person_created(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account_person.created", &handler)
+    end
+
+    def on_v2_core_account_person_deleted(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account_person.deleted", &handler)
+    end
+
+    def on_v2_core_account_person_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.account_person.updated", &handler)
+    end
+
+    def on_v2_core_event_destination_ping(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.event_destination.ping", &handler)
+    end
+
+    def on_v2_core_health_event_generation_failure_resolved(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.core.health.event_generation_failure.resolved", &handler)
+    end
+
+    def on_v2_money_management_adjustment_created(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.adjustment.created", &handler)
+    end
+
+    def on_v2_money_management_financial_account_created(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.financial_account.created", &handler)
+    end
+
+    def on_v2_money_management_financial_account_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.financial_account.updated", &handler)
+    end
+
+    def on_v2_money_management_financial_address_activated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.financial_address.activated", &handler)
+    end
+
+    def on_v2_money_management_financial_address_failed(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.financial_address.failed", &handler)
+    end
+
+    def on_v2_money_management_inbound_transfer_available(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.inbound_transfer.available", &handler)
+    end
+
+    def on_v2_money_management_inbound_transfer_bank_debit_failed(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.inbound_transfer.bank_debit_failed", &handler)
+    end
+
+    def on_v2_money_management_inbound_transfer_bank_debit_processing(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.inbound_transfer.bank_debit_processing", &handler)
+    end
+
+    def on_v2_money_management_inbound_transfer_bank_debit_queued(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.inbound_transfer.bank_debit_queued", &handler)
+    end
+
+    def on_v2_money_management_inbound_transfer_bank_debit_returned(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.inbound_transfer.bank_debit_returned", &handler)
+    end
+
+    def on_v2_money_management_inbound_transfer_bank_debit_succeeded(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.inbound_transfer.bank_debit_succeeded", &handler)
+    end
+
+    def on_v2_money_management_outbound_payment_canceled(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.outbound_payment.canceled", &handler)
+    end
+
+    def on_v2_money_management_outbound_payment_created(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.outbound_payment.created", &handler)
+    end
+
+    def on_v2_money_management_outbound_payment_failed(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.outbound_payment.failed", &handler)
+    end
+
+    def on_v2_money_management_outbound_payment_posted(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.outbound_payment.posted", &handler)
+    end
+
+    def on_v2_money_management_outbound_payment_returned(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.outbound_payment.returned", &handler)
+    end
+
+    def on_v2_money_management_outbound_payment_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.outbound_payment.updated", &handler)
+    end
+
+    def on_v2_money_management_outbound_transfer_canceled(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.outbound_transfer.canceled", &handler)
+    end
+
+    def on_v2_money_management_outbound_transfer_created(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.outbound_transfer.created", &handler)
+    end
+
+    def on_v2_money_management_outbound_transfer_failed(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.outbound_transfer.failed", &handler)
+    end
+
+    def on_v2_money_management_outbound_transfer_posted(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.outbound_transfer.posted", &handler)
+    end
+
+    def on_v2_money_management_outbound_transfer_returned(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.outbound_transfer.returned", &handler)
+    end
+
+    def on_v2_money_management_outbound_transfer_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.outbound_transfer.updated", &handler)
+    end
+
+    def on_v2_money_management_payout_method_created(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.payout_method.created", &handler)
+    end
+
+    def on_v2_money_management_payout_method_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.payout_method.updated", &handler)
+    end
+
+    def on_v2_money_management_received_credit_available(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.received_credit.available", &handler)
+    end
+
+    def on_v2_money_management_received_credit_failed(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.received_credit.failed", &handler)
+    end
+
+    def on_v2_money_management_received_credit_returned(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.received_credit.returned", &handler)
+    end
+
+    def on_v2_money_management_received_credit_succeeded(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.received_credit.succeeded", &handler)
+    end
+
+    def on_v2_money_management_received_debit_canceled(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.received_debit.canceled", &handler)
+    end
+
+    def on_v2_money_management_received_debit_failed(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.received_debit.failed", &handler)
+    end
+
+    def on_v2_money_management_received_debit_pending(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.received_debit.pending", &handler)
+    end
+
+    def on_v2_money_management_received_debit_succeeded(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.received_debit.succeeded", &handler)
+    end
+
+    def on_v2_money_management_received_debit_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.received_debit.updated", &handler)
+    end
+
+    def on_v2_money_management_transaction_created(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.transaction.created", &handler)
+    end
+
+    def on_v2_money_management_transaction_updated(&handler)
+      raise ArgumentError, "Block required to register event handler" if handler.nil?
+
+      register("v2.money_management.transaction.updated", &handler)
+    end
+    # event-handler-methods: The end of the section generated from our OpenAPI spec
+  end
+end