spree_stripe 6.0.0.beta4 → 6.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 761c677448596680810cd6380436150bd4ed2451322f2942e8033511c777176f
-  data.tar.gz: 7d19dd53fe7b8c742df6d141ff166870f15c093c57081c90cd0d86efd572fb4b
+  metadata.gz: 8983341a30de22cd7fa7ad6b6d71aebe323935bfdda5ec4ae7644cd0a268d2e9
+  data.tar.gz: b249b9acba1b25c1590c960336ee58130ff94a67eb9daf4b300fd508b354a1d5
 SHA512:
-  metadata.gz: 36dc8fdf7281243405d91bf3e466429cba10b146430c93e46f10883391b47163fb5d03159314940f29c285ec380c9bc4d6fe80f89e2b535ef5850bc6873424f3
-  data.tar.gz: 05ce651862abfee5a54a2716674edfc958016a8ff868ca7a98d31439e11e20207e4885568c2517a3e3ce42449d97d02c9b791742fc3e2b629305f30d960f0ef1
+  metadata.gz: b334eb2bcb2d3be7b32688b51b5585616b895c22c6c012b8da7f42dad3595b65e35f506b58b30bccffc324fc5b704ceb80cb59199ef42470092534ab9b27ba8f
+  data.tar.gz: 8e4737ce51b74cbd937790c27a8bc2befab609b1d7391fa9c1e792dfc9a0d11be5b48f9ccb5f63dabb0c5f56acec41ba084b6db23a264e072702cdc65a8c205b

data/app/models/spree_stripe/gateway/payment_sessions.rb

@@ -15,6 +15,18 @@ module SpreeStripe
       MANUAL_CAPTURE_METHOD = 'manual'.freeze
       SETUP_FUTURE_USAGE = 'off_session'.freeze
 
+      # Not a decision about the intent. A timeout and an outage may not have
+      # arrived; a rate limit was turned away before Stripe looked; a bad key
+      # or a missing permission never reached the intent. A refusal of the
+      # cancel itself is an InvalidRequestError and stays out of this list.
+      RETRYABLE_STRIPE_ERRORS = [
+        Stripe::APIConnectionError,
+        Stripe::RateLimitError,
+        Stripe::APIError,
+        Stripe::AuthenticationError,
+        Stripe::PermissionError
+      ].freeze
+
       def session_required?
         true
       end
@@ -23,19 +35,31 @@ module SpreeStripe
         Spree::PaymentSessions::Stripe
       end
 
+      # Opens a new session on every call. Each earlier session that can still
+      # be paid is canceled first: every open intent can be paid on its own,
+      # so a reloaded checkout would charge the buyer twice. A session Stripe
+      # has already accepted, a card charge still in flight, or one this cart
+      # has already completed is left as it is and the request fails, because
+      # that money is not dropped to make room for another session.
+      #
       # @param order [Spree::Cart, Spree::Order]
       # @return [Spree::PaymentSessions::Stripe]
+      # @raise [Spree::Core::GatewayError] when a session has already been
+      #   paid, or an earlier one could not be canceled
       def create_payment_session(order:, amount: nil, external_data: {})
         total = amount.presence || order.total_minus_store_credits
-        amount_in_cents = Spree::Money.new(total, currency: order.currency).cents
+        stripe_amount = SpreeStripe::Units.to_stripe(total, order.currency)
 
-        raise Spree::Core::GatewayError, Spree.t('stripe.payment_session_errors.zero_amount') if amount_in_cents.zero?
+        raise Spree::Core::GatewayError, I18n.t('spree.stripe.payment_session_errors.zero_amount') if stripe_amount.zero?
 
-        gateway_customer = fetch_or_create_customer(order: order)
         stripe_payment_method_id = external_data[:stripe_payment_method_id] || external_data['stripe_payment_method_id']
 
+        replace_open_sessions(order)
+
+        gateway_customer = fetch_or_create_customer(order: order)
+
         response = create_payment_intent(
-          amount_in_cents, order,
+          stripe_amount, order,
           payment_method_id: stripe_payment_method_id,
           customer_profile_id: gateway_customer&.profile_id
         )
@@ -61,18 +85,18 @@ module SpreeStripe
 
       def update_payment_session(payment_session:, amount: nil, external_data: {})
         attrs = {}
-        amount_in_cents = nil
+        stripe_amount = nil
 
         if amount.present?
           attrs[:amount] = amount
-          amount_in_cents = Spree::Money.new(amount, currency: payment_session.currency).cents
+          stripe_amount = SpreeStripe::Units.to_stripe(amount, payment_session.currency)
         end
 
         stripe_payment_method_id = external_data[:stripe_payment_method_id] || external_data['stripe_payment_method_id']
 
         update_payment_intent(
           payment_session.external_id,
-          amount_in_cents || payment_session.amount_in_cents,
+          stripe_amount || SpreeStripe::Units.to_stripe(payment_session.amount, payment_session.currency),
           payment_session.owner,
           stripe_payment_method_id
         )
@@ -110,6 +134,29 @@ module SpreeStripe
         payment_session
       end
 
+      # Stripe refuses once money has moved, and that refusal is raised so the
+      # session is never shown as canceled while its money stands. An intent
+      # already canceled at Stripe, or unknown to the account the keys now
+      # reach, can no longer be paid, so its session is canceled all the same.
+      # A timeout, a rate limit, an outage, or rejected credentials is raised
+      # as Stripe's own error: wrapped as a refusal, the unused-session job
+      # would count the intent handled while the buyer can still pay it.
+      #
+      # @param payment_session [Spree::PaymentSessions::Stripe]
+      # @return [Boolean] whether the session was canceled
+      # @raise [Spree::Core::GatewayError] when Stripe refuses
+      # @raise [Stripe::StripeError] when Stripe could not be asked
+      def cancel_payment_session(payment_session:)
+        cancel_payment_intent(payment_session.external_id)
+        payment_session.cancel
+      rescue *RETRYABLE_STRIPE_ERRORS
+        raise
+      rescue Stripe::StripeError => error
+        raise Spree::Core::GatewayError, error.message unless payment_intent_unpayable?(payment_session.external_id)
+
+        payment_session.cancel
+      end
+
       def retrieve_payment_intent(payment_intent_id)
         send_request { |opts| Stripe::PaymentIntent.retrieve({ id: payment_intent_id, expand: ['payment_method'] }, opts) }
       end
@@ -118,8 +165,8 @@ module SpreeStripe
         send_request { |opts| Stripe::PaymentIntent.confirm(payment_intent_id, {}, opts) }
       end
 
-      def capture_payment_intent(payment_intent_id, amount_in_cents)
-        send_request { |opts| Stripe::PaymentIntent.capture(payment_intent_id, { amount_to_capture: amount_in_cents }, opts) }
+      def capture_payment_intent(payment_intent_id, stripe_amount)
+        send_request { |opts| Stripe::PaymentIntent.capture(payment_intent_id, { amount_to_capture: stripe_amount }, opts) }
       end
 
       def cancel_payment_intent(payment_intent_id)
@@ -170,11 +217,65 @@ module SpreeStripe
 
       private
 
+      # Nothing is canceled until every still-payable intent has been read. A
+      # later one that Stripe has already accepted must not be reached after
+      # an earlier one was dropped. A completed session is the same refusal
+      # with no provider call: the cart already has its payment.
+      def replace_open_sessions(order)
+        sessions = order.payment_sessions.where(payment_method: self)
+        if sessions.exists?(status: 'completed')
+          raise Spree::Core::GatewayError, I18n.t('spree.stripe.payment_session_errors.payment_in_progress')
+        end
+
+        # A failed confirm leaves the intent payable. It is canceled with the
+        # open ones, unless its charge is still in flight.
+        open_sessions = sessions.active.order(:id).to_a + sessions.where(status: 'failed').order(:id).to_a
+        return if open_sessions.empty?
+
+        open_sessions.each do |payment_session|
+          payment_intent = find_payment_intent(payment_session.external_id)
+          next unless payment_intent && payment_intent_in_progress?(payment_intent)
+
+          raise Spree::Core::GatewayError, I18n.t('spree.stripe.payment_session_errors.payment_in_progress')
+        end
+
+        open_sessions.each do |payment_session|
+          cancel_payment_session(payment_session: payment_session)
+        end
+      rescue *RETRYABLE_STRIPE_ERRORS => error
+        # Checkout speaks GatewayError. The unused-session job does not: it
+        # retries these, and has to see them unwrapped.
+        raise Spree::Core::GatewayError, error.message
+      end
+
+      # A card can sit in `processing` while its charge is in flight.
+      # `payment_intent_accepted?` does not record that yet, and canceling
+      # the intent can drop or refund the charge.
+      def payment_intent_in_progress?(payment_intent)
+        payment_intent.status == 'processing' || payment_intent_accepted?(payment_intent)
+      end
+
+      # nil when the account the keys now reach has no such intent.
+      def find_payment_intent(payment_intent_id)
+        retrieve_payment_intent(payment_intent_id)
+      rescue Stripe::InvalidRequestError => error
+        raise Spree::Core::GatewayError, error.message unless error.code == 'resource_missing'
+      rescue *RETRYABLE_STRIPE_ERRORS
+        raise
+      rescue Stripe::StripeError => error
+        raise Spree::Core::GatewayError, error.message
+      end
+
+      def payment_intent_unpayable?(payment_intent_id)
+        payment_intent = find_payment_intent(payment_intent_id)
+        payment_intent.nil? || payment_intent.status == 'canceled'
+      end
+
       # @param order [Spree::Cart, Spree::Order]
       # @return [Spree::PaymentResponse]
-      def create_payment_intent(amount_in_cents, order, payment_method_id: nil, customer_profile_id: nil)
+      def create_payment_intent(stripe_amount, order, payment_method_id: nil, customer_profile_id: nil)
         payload = {
-          amount: amount_in_cents,
+          amount: stripe_amount,
           currency: order.currency,
           customer: customer_profile_id,
           payment_method: payment_method_id,
@@ -203,10 +304,10 @@ module SpreeStripe
       end
 
       # Only the fields that can legitimately change while a session is pending.
-      def update_payment_intent(payment_intent_id, amount_in_cents, order, payment_method_id = nil)
+      def update_payment_intent(payment_intent_id, stripe_amount, order, payment_method_id = nil)
         protect_from_error do
           payload = {
-            amount: amount_in_cents,
+            amount: stripe_amount,
             currency: order.currency,
             customer: fetch_or_create_customer(order: order)&.profile_id,
             payment_method: payment_method_id,

data/app/models/spree_stripe/gateway.rb

@@ -3,6 +3,8 @@ module SpreeStripe
   # created and confirmed through sessions; core's payment lifecycle then drives
   # capture, refund and cancellation against the resulting intent.
   class Gateway < ::Spree::Gateway
+    self.accepts_money_amounts = true
+
     include SpreeStripe::Gateway::PaymentSessions
     include SpreeStripe::Gateway::PaymentSetupSessions
     include SpreeStripe::Gateway::Webhooks
@@ -22,6 +24,14 @@ module SpreeStripe
     validates :preferred_secret_key, :preferred_publishable_key, presence: true
     validate :validate_secret_key, unless: -> { Rails.env.test? }, if: -> { preferred_secret_key.present? }
 
+    def self.logo_url
+      'https://spreecommerce.org/docs/images/integrations/logos/stripe.png'
+    end
+
+    def self.docs_url
+      'https://spreecommerce.org/docs/integrations/payments/stripe'
+    end
+
     def provider_class
       self.class
     end
@@ -50,12 +60,10 @@ module SpreeStripe
     #
     # @return [Boolean]
     def only_webhook_registration_changed?
-      before, after = saved_change_to_preferences
-      return false unless before.is_a?(Hash) && after.is_a?(Hash)
-
-      changed = (before.keys | after.keys).reject { |key| before[key] == after[key] }
+      return false if previously_new_record?
 
-      changed.any? && changed.all? { |key| WEBHOOK_REGISTRATION_PREFERENCES.include?(key.to_sym) }
+      changed = previously_changed_preference_names
+      changed.any? && changed.all? { |key| WEBHOOK_REGISTRATION_PREFERENCES.include?(key) }
     end
 
     # Endpoints are registered per Stripe account, so a rotated key leaves the
@@ -67,10 +75,7 @@ module SpreeStripe
       # read as every key having changed.
       return false if previously_new_record?
 
-      # The preference macro's own reader rather than a hand-rolled diff: it
-      # reads the change through indifferent access, so it answers the same
-      # whether the serialized hash came back with symbol or string keys.
-      preferred_secret_key_previously_changed?
+      saved_change_to_preferred_secret_key?
     end
 
     def gateway_dashboard_payment_url(payment)
@@ -83,26 +88,26 @@ module SpreeStripe
     # is already confirmed client-side in the session flow, so this reads back the
     # intent rather than initiating a charge.
     #
-    # @param amount_in_cents [Integer]
+    # @param money [Spree::Money]
     # @param payment_source [Spree::PaymentSource, Spree::CreditCard]
     # @param gateway_options [Hash] Spree::Payment::GatewayOptions#to_hash
     # @return [Spree::PaymentResponse]
-    def authorize(amount_in_cents, payment_source, gateway_options = {})
-      handle_authorize_or_purchase(amount_in_cents, payment_source, gateway_options)
+    def authorize(money, payment_source, gateway_options = {})
+      handle_authorize_or_purchase(money, payment_source, gateway_options)
     end
 
     # @see #authorize — capture vs authorize is decided by the intent's capture
     #   method, so both resolve the same way.
-    def purchase(amount_in_cents, payment_source, gateway_options = {})
-      handle_authorize_or_purchase(amount_in_cents, payment_source, gateway_options)
+    def purchase(money, payment_source, gateway_options = {})
+      handle_authorize_or_purchase(money, payment_source, gateway_options)
     end
 
-    def capture(amount_in_cents, payment_intent_id, _gateway_options = {})
+    def capture(money, payment_intent_id, _gateway_options = {})
       protect_from_error do
         stripe_payment_intent = retrieve_payment_intent(payment_intent_id)
 
         response = if payment_intent_requires_capture?(stripe_payment_intent)
-                     capture_payment_intent(payment_intent_id, amount_in_cents)
+                     capture_payment_intent(payment_intent_id, SpreeStripe::Units.to_stripe(money, money.currency))
                    elsif stripe_payment_intent.status == 'succeeded'
                      stripe_payment_intent
                    else
@@ -113,10 +118,10 @@ module SpreeStripe
       end
     end
 
-    def credit(amount_in_cents, _source, payment_intent_id, _gateway_options = {})
+    def credit(money, _source, payment_intent_id, _gateway_options = {})
       protect_from_error do
         response = send_request do |opts|
-          Stripe::Refund.create({ amount: amount_in_cents, payment_intent: payment_intent_id }, opts)
+          Stripe::Refund.create({ amount: SpreeStripe::Units.to_stripe(money, money.currency), payment_intent: payment_intent_id }, opts)
         end
 
         success(response.id, response)
@@ -266,7 +271,7 @@ module SpreeStripe
 
     private
 
-    def handle_authorize_or_purchase(amount_in_cents, _payment_source, gateway_options)
+    def handle_authorize_or_purchase(_money, _payment_source, gateway_options)
       # Scoped through this gateway's own payments — a cart-owned payment
       # (checkout is still in flight) has no order to join through, and the
       # payment method already belongs to exactly one store. Found by the
@@ -302,14 +307,14 @@ module SpreeStripe
     def validate_secret_key
       Stripe::Refund.list({ limit: 0 }, api_options)
     rescue Stripe::AuthenticationError
-      errors.add(:base, :secret_key_invalid, message: Spree.t('stripe.errors.secret_key_invalid'))
+      errors.add(:base, :secret_key_invalid, message: I18n.t('spree.stripe.errors.secret_key_invalid'))
     rescue Stripe::PermissionError => e
       return unless e.error&.code == 'secret_key_required'
 
       errors.add(:base, :publishable_key_provided,
-                 message: Spree.t('stripe.errors.publishable_key_provided'))
+                 message: I18n.t('spree.stripe.errors.publishable_key_provided'))
     rescue Stripe::StripeError
-      errors.add(:base, :stripe_unavailable, message: Spree.t('stripe.errors.stripe_unavailable'))
+      errors.add(:base, :stripe_unavailable, message: I18n.t('spree.stripe.errors.stripe_unavailable'))
     end
 
     def build_customer_payload(order: nil, customer: nil)

data/app/models/spree_stripe/payment_sources/bank_transfer.rb

@@ -6,11 +6,11 @@ module SpreeStripe
       end
 
       def self.display_name
-        Spree.t(:bank_transfer)
+        I18n.t('spree.bank_transfer')
       end
 
       def name
-        Spree.t(:bank_transfer)
+        I18n.t('spree.bank_transfer')
       end
     end
   end

data/app/models/spree_stripe/payout_provider.rb

@@ -258,7 +258,7 @@ module SpreeStripe
       wanted = currency.to_s.downcase
       minor = balance.available.select { |entry| entry.currency == wanted }.sum(&:amount)
 
-      Spree::Money::Rounding.from_minor_units(minor, currency)
+      SpreeStripe::Units.from_stripe(minor, currency)
     rescue *AMBIGUOUS_ERRORS => e
       # The sweep must not read silence as "nothing to send" and settle a
       # smaller batch than the seller is owed, nor as "no limit" and ask for
@@ -290,8 +290,7 @@ module SpreeStripe
       return {} if balance_transaction.blank? || balance_transaction.try(:currency).blank?
 
       {
-        settled_amount: Spree::Money::Rounding.from_minor_units(balance_transaction.amount,
-                                                                balance_transaction.currency),
+        settled_amount: SpreeStripe::Units.from_stripe(balance_transaction.amount, balance_transaction.currency),
         settled_currency: balance_transaction.currency.upcase
       }
     end
@@ -322,7 +321,7 @@ module SpreeStripe
     end
 
     def minor_units(record)
-      Spree::Money::Rounding.to_minor_units(record.amount.abs, record.currency)
+      SpreeStripe::Units.to_stripe(record.amount.abs, record.currency, payout: true)
     end
 
     # Ties transfers paid from the platform balance to the checkout they

data/app/models/spree_stripe/units.rb

@@ -0,0 +1,52 @@
+module SpreeStripe
+  # Stripe's integer amounts. Mostly the currency's ISO minor unit, with
+  # Stripe's own exceptions (https://docs.stripe.com/currencies): its
+  # zero-decimal currencies are sent in whole units, and ISK and UGX, zero-decimal
+  # since, are still sent as two-decimal values ending in 00. Stripe also takes
+  # three-decimal currencies only in steps of 0.010, and pays out HUF and TWD
+  # only in whole units; an amount it would refuse raises here, naming the rule,
+  # rather than being rounded to a sum other than the one Spree records.
+  module Units
+    module_function
+
+    ZERO_DECIMAL = %w[BIF CLP DJF GNF JPY KMF KRW MGA PYG RWF VND VUV XAF XOF XPF].freeze
+    WHOLE_IN_HUNDREDTHS = %w[ISK UGX].freeze
+    THREE_DECIMAL = %w[BHD JOD KWD OMR TND].freeze
+    WHOLE_PAYOUTS = %w[HUF TWD].freeze
+
+    class UnsupportedAmount < Spree::Core::GatewayError; end
+
+    # @param amount [BigDecimal, Spree::Money]
+    # @param currency [String]
+    # @param payout [Boolean] a payout or transfer rather than a charge
+    # @return [Integer]
+    # @raise [UnsupportedAmount] when Stripe would refuse the amount
+    def to_stripe(amount, currency, payout: false)
+      amount = amount.to_d if amount.respond_to?(:to_d)
+      code = currency.to_s.upcase
+      return Spree::Money::Rounding.quantize(amount, 0).to_i if ZERO_DECIMAL.include?(code)
+      return Spree::Money::Rounding.quantize(amount, 0).to_i * 100 if WHOLE_IN_HUNDREDTHS.include?(code)
+
+      units = Spree::Money::Rounding.to_minor_units(amount, code)
+      if THREE_DECIMAL.include?(code) && (units % 10).nonzero?
+        raise UnsupportedAmount, "Stripe takes #{code} only in steps of 0.010, got #{amount.to_s('F')}"
+      end
+      if payout && WHOLE_PAYOUTS.include?(code) && (units % 100).nonzero?
+        raise UnsupportedAmount, "Stripe pays out #{code} only in whole units, got #{amount.to_s('F')}"
+      end
+
+      units
+    end
+
+    # @param units [Integer] as Stripe reports it
+    # @param currency [String]
+    # @return [BigDecimal]
+    def from_stripe(units, currency)
+      code = currency.to_s.upcase
+      return BigDecimal(units) if ZERO_DECIMAL.include?(code)
+      return BigDecimal(units) / 100 if WHOLE_IN_HUNDREDTHS.include?(code)
+
+      Spree::Money::Rounding.from_minor_units(units, code)
+    end
+  end
+end

data/config/locales/en.yml

@@ -7,6 +7,6 @@ en:
         publishable_key_provided: You have provided your publishable key instead of your secret key
         secret_key_invalid: Secret key is invalid
         stripe_unavailable: Something went wrong with Stripe. Try again later.
-      payment_could_not_be_processed: Your payment could not be processed. Please try again.
       payment_session_errors:
+        payment_in_progress: A payment for this checkout is already in progress.
         zero_amount: Payment session amount must be greater than zero

data/lib/spree_stripe/engine.rb

@@ -5,12 +5,6 @@ module SpreeStripe
     isolate_namespace Spree
     engine_name 'spree_stripe'
 
-    config.paths.add 'app/subscribers', eager_load: true
-
-    config.generators do |g|
-      g.test_framework :rspec
-    end
-
     # Core assigns the payment method registry in its own after_initialize, so
     # appending has to happen in a later one — engine callbacks run in load order.
     config.after_initialize do

data/lib/tasks/migrate_webhook_keys.rake

@@ -40,11 +40,14 @@ module SpreeStripe
           next
         end
 
+        # Through the preference writers, so the signing secret lands in the
+        # encrypted column; saved without callbacks, which would re-register
+        # the endpoint the secret belongs to.
+        gateway.preferred_webhook_endpoint_id = key.stripe_id
+        gateway.preferred_webhook_signing_secret = key.signing_secret
         gateway.update_columns(
-          preferences: gateway.preferences.merge(
-            webhook_endpoint_id: key.stripe_id,
-            webhook_signing_secret: key.signing_secret
-          ),
+          preferences: gateway.preferences,
+          secret_preferences: gateway.secret_preferences,
           updated_at: Time.current
         )
         migrated += 1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spree_stripe
 version: !ruby/object:Gem::Version
-  version: 6.0.0.beta4
+  version: 6.0.0.rc2
 platform: ruby
 authors:
 - Vendo Connect Inc.
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-24 00:00:00.000000000 Z
+date: 2026-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: spree_core
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.0.0.beta4
+        version: 6.0.0.rc2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 6.0.0.beta4
+        version: 6.0.0.rc2
 - !ruby/object:Gem::Dependency
   name: stripe
   requirement: !ruby/object:Gem::Requirement
@@ -89,6 +89,7 @@ files:
 - app/models/spree_stripe/payment_sources/przelewy24.rb
 - app/models/spree_stripe/payment_sources/sepa_debit.rb
 - app/models/spree_stripe/payout_provider.rb
+- app/models/spree_stripe/units.rb
 - app/presenters/spree_stripe/customer_presenter.rb
 - app/presenters/spree_stripe/statement_descriptor_suffix_presenter.rb
 - app/services/spree_stripe/create_gateway_webhooks.rb
@@ -110,9 +111,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/spree/spree/issues
-  changelog_uri: https://github.com/spree/spree/releases/tag/v6.0.0.beta4
+  changelog_uri: https://github.com/spree/spree/releases/tag/v6.0.0.rc2
   documentation_uri: https://docs.spreecommerce.org/
-  source_code_uri: https://github.com/spree/spree/tree/v6.0.0.beta4
+  source_code_uri: https://github.com/spree/spree/tree/v6.0.0.rc2
 post_install_message:
 rdoc_options: []
 require_paths: