spree_stripe 1.5.1 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 296413327864ba7d62dbcbe59c93f4b20bbe8ca0eaed1f0379ab30548da13412
-  data.tar.gz: 58bb81757cc9097d009fc3d0cb3733455ab0e22c5012a0310ca9e583da7bb744
+  metadata.gz: a10e7ebb4ff5cc5960d0ecb894cfc0e15ef4ed058bf2133fc412ca9fc4c95910
+  data.tar.gz: 49fd3295806ed476343813ac3ce3356d74054bf84db8ecf9f4ade86099f139c3
 SHA512:
-  metadata.gz: 4aca196555667bc988d69382638bd235450deb8a66da6680915476e771c3c745d32f0ce2300ba737863998ec012d8929144cd8792d8c1c121d92fdbf065fef80
-  data.tar.gz: 5ad609bed31583b62956e3be2517fc7b42a4a99beec2067cc4993ee4f771f38d2cb5040d477154cc0cc6132ea1a85ddddb200279ce404f6ec83de2ca56974b24
+  metadata.gz: 3ceff451db2064b42fe695aaa91b0ff7c2512fa455504ba459f84a1c788731fd490d85c3a950972a3a7942acaf9cce64a2d6d2de2ce0ace9d2bfccacccc95770
+  data.tar.gz: cd0aff0b871a315fd19b5529912ce431ab5c5c35657bab1853fd2548e80591f031f79ee81bab107f64da05f985bfad7271b288fc813a87d4a583935581ad66c0

data/Rakefile

@@ -21,5 +21,7 @@ task :test_app do
     install_storefront: true,
     install_admin: true
   )
+  system({ 'BUNDLE_GEMFILE' => File.expand_path('Gemfile', __dir__) }, 'rails g spree_posts:install')
   system({ 'BUNDLE_GEMFILE' => File.expand_path('Gemfile', __dir__) }, 'rails g spree_legacy_api_v2:install')
+  system({ 'BUNDLE_GEMFILE' => File.expand_path('Gemfile', __dir__) }, 'rails g spree_legacy_product_properties:install')
 end

data/app/jobs/spree_stripe/complete_order_from_session_job.rb

@@ -0,0 +1,12 @@
+module SpreeStripe
+  class CompleteOrderFromSessionJob < BaseJob
+    def perform(payment_session_id)
+      payment_session = Spree::PaymentSessions::Stripe.find(payment_session_id)
+
+      # PaymentSessions::Stripe duck-types as PaymentIntent
+      SpreeStripe::CompleteOrder.new(payment_intent: payment_session).call
+
+      payment_session.complete unless payment_session.completed?
+    end
+  end
+end

data/app/models/spree/payment_sessions/stripe.rb

@@ -0,0 +1,54 @@
+module Spree
+  class PaymentSessions::Stripe < PaymentSession
+    delegate :api_options, to: :payment_method
+
+    # Duck-type interface matching SpreeStripe::PaymentIntent
+    # This allows reuse of CompleteOrder and CreatePayment services
+    def stripe_id
+      external_id
+    end
+
+    def client_secret
+      external_data&.dig('client_secret')
+    end
+
+    def ephemeral_key_secret
+      external_data&.dig('ephemeral_key_secret')
+    end
+
+    def stripe_payment_intent
+      @stripe_payment_intent ||= payment_method.retrieve_payment_intent(external_id)
+    end
+
+    def stripe_charge
+      @stripe_charge ||= begin
+        latest_charge = stripe_payment_intent.latest_charge
+        latest_charge.present? ? payment_method.retrieve_charge(latest_charge) : nil
+      end
+    end
+
+    def accepted?
+      payment_method.payment_intent_accepted?(stripe_payment_intent)
+    end
+
+    def successful?
+      stripe_payment_intent.status == 'succeeded'
+    end
+
+    def charge_not_required?
+      payment_method.payment_intent_charge_not_required?(stripe_payment_intent)
+    end
+
+    def find_or_create_payment!(metadata = {})
+      return unless persisted?
+      return payment if payment.present?
+
+      SpreeStripe::CreatePayment.new(
+        order: order,
+        payment_intent: self,
+        gateway: payment_method,
+        amount: amount
+      ).call
+    end
+  end
+end

data/app/models/spree/payment_setup_sessions/stripe.rb

@@ -0,0 +1,21 @@
+module Spree
+  class PaymentSetupSessions::Stripe < PaymentSetupSession
+    delegate :api_options, to: :payment_method
+
+    def stripe_id
+      external_id
+    end
+
+    def client_secret
+      external_client_secret
+    end
+
+    def stripe_setup_intent
+      @stripe_setup_intent ||= payment_method.retrieve_setup_intent(external_id)
+    end
+
+    def successful?
+      stripe_setup_intent.status == 'succeeded'
+    end
+  end
+end

data/app/models/spree_stripe/custom_domain_decorator.rb

@@ -15,4 +15,6 @@ module SpreeStripe
   end
 end
 
-Spree::CustomDomain.prepend(SpreeStripe::CustomDomainDecorator)
+if defined?(Spree::CustomDomain)
+  Spree::CustomDomain.prepend(SpreeStripe::CustomDomainDecorator)
+end

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

@@ -0,0 +1,153 @@
+module SpreeStripe
+  class Gateway < ::Spree::Gateway
+    module PaymentIntents
+      extend ActiveSupport::Concern
+
+      DELAYED_NOTIFICATION_PAYMENT_METHOD_TYPES = %w[sepa_debit us_bank_account].freeze
+      BANK_PAYMENT_METHOD_TYPES = %w[customer_balance us_bank_account].freeze
+      MANUAL_CAPTURE_METHOD = 'manual'.freeze
+
+      included do
+        has_many :payment_intents, class_name: 'SpreeStripe::PaymentIntent', foreign_key: 'payment_method_id', dependent: :delete_all
+      end
+
+      def payment_intent_accepted?(payment_intent)
+        payment_intent.status.in?(payment_intent_accepted_statuses(payment_intent))
+      end
+
+      def payment_intent_delayed_notification?(payment_intent)
+        payment_method = payment_intent.payment_method
+        return false unless payment_method.respond_to?(:type)
+
+        payment_intent.payment_method.type.in?(DELAYED_NOTIFICATION_PAYMENT_METHOD_TYPES)
+      end
+
+      def payment_intent_charge_not_required?(payment_intent)
+        payment_intent_bank_payment_method?(payment_intent)
+      end
+
+      def payment_intent_bank_payment_method?(payment_intent)
+        payment_method = payment_intent.payment_method
+        return false unless payment_method.respond_to?(:type)
+
+        payment_intent.payment_method.type.in?(BANK_PAYMENT_METHOD_TYPES)
+      end
+
+      def payment_intent_requires_capture?(payment_intent)
+        payment_intent.status == 'requires_capture'
+      end
+
+      def payment_intent_manual_capture?(payment_intent)
+        payment_intent.respond_to?(:capture_method) && payment_intent.capture_method == MANUAL_CAPTURE_METHOD
+      end
+
+      # Creates a Stripe payment intent for the order
+      #
+      # @param amount_in_cents [Integer] the amount in cents
+      # @param order [Spree::Order] the order to create a payment intent for
+      # @param payment_method_id [String] Stripe payment method id to use, eg. a card token
+      # @param off_session [Boolean] whether the payment intent is off session
+      # @param customer_profile_id [String] Stripe customer profile id to use, eg.  cus_123
+      # @return [Spree::PaymentResponse] the response from the payment intent creation
+      def create_payment_intent(amount_in_cents, order, payment_method_id: nil, off_session: false, customer_profile_id: nil)
+        payload = SpreeStripe::PaymentIntentPresenter.new(
+          amount: amount_in_cents,
+          order: order,
+          customer: customer_profile_id || fetch_or_create_customer(order: order)&.profile_id,
+          payment_method_id: payment_method_id,
+          off_session: off_session,
+          capture_method: stripe_capture_method
+        ).call
+
+        protect_from_error do
+          response = send_request { |opts| Stripe::PaymentIntent.create(payload, opts) }
+
+          success(response.id, response)
+        end
+      end
+
+      # Updates a Stripe payment intent for the order
+      #
+      # @param payment_intent_id [String] Stripe payment intent id
+      # @param amount_in_cents [Integer] the amount in cents
+      # @param order [Spree::Order] the order to update the payment intent for
+      # @param payment_method_id [String] Stripe payment method id to use, eg. a card token
+      # @return [Spree::PaymentResponse] the response from the payment intent update
+      def update_payment_intent(payment_intent_id, amount_in_cents, order, payment_method_id = nil)
+        protect_from_error do
+          payload = SpreeStripe::PaymentIntentPresenter.new(
+            amount: amount_in_cents,
+            order: order,
+            customer: fetch_or_create_customer(order: order)&.profile_id,
+            payment_method_id: payment_method_id
+          ).call.slice(:amount, :currency, :payment_method, :shipping, :customer)
+
+          response = send_request { |opts| Stripe::PaymentIntent.update(payment_intent_id, payload, opts) }
+
+          success(response.id, response)
+        end
+      end
+
+      def retrieve_payment_intent(payment_intent_id)
+        send_request { |opts| Stripe::PaymentIntent.retrieve({ id: payment_intent_id, expand: ['payment_method'] }, opts) }
+      end
+
+      def confirm_payment_intent(payment_intent_id)
+        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) }
+      end
+
+      # Cancels a Stripe payment intent
+      #
+      # @param payment_intent_id [String] Stripe payment intent ID, eg. pi_123
+      def cancel_payment_intent(payment_intent_id)
+        send_request { |opts| Stripe::PaymentIntent.cancel(payment_intent_id, {}, opts) }
+      end
+
+      # Ensures a Stripe payment intent exists for Spree payment
+      #
+      # @param payment [Spree::Payment] the payment to ensure a payment intent exists for
+      # @param amount_in_cents [Integer] the amount in cents
+      # @param payment_source [Spree::CreditCard | Spree::PaymentSource] the payment source to use
+      # @return [Spree::Payment] the payment with the payment intent
+      def ensure_payment_intent_exists_for_payment(payment, amount_in_cents = nil, payment_source = nil)
+        return payment if payment.response_code.present?
+
+        amount_in_cents ||= payment.display_amount.cents
+        payment_source ||= payment.source
+
+        response = create_payment_intent(
+          amount_in_cents,
+          payment.order,
+          payment_method_id: payment_source.gateway_payment_profile_id,
+          off_session: true,
+          customer_profile_id: payment_source.gateway_customer_profile_id
+        )
+
+        payment.update_columns(
+          response_code: response.authorization,
+          updated_at: Time.current
+        )
+
+        payment
+      end
+
+      private
+
+      def stripe_capture_method
+        auto_capture? ? nil : MANUAL_CAPTURE_METHOD
+      end
+
+      def payment_intent_accepted_statuses(payment_intent)
+        statuses = %w[succeeded]
+        statuses << 'requires_capture' if payment_intent_manual_capture?(payment_intent)
+        statuses << 'processing' if payment_intent_delayed_notification?(payment_intent)
+        statuses << 'requires_action' if payment_intent_charge_not_required?(payment_intent)
+        statuses
+      end
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+module SpreeStripe
+  class Gateway < ::Spree::Gateway
+    module PaymentSessions
+      extend ActiveSupport::Concern
+
+      def session_required?
+        !SpreeStripe::Config[:use_legacy_payment_intents]
+      end
+
+      def payment_session_class
+        Spree::PaymentSessions::Stripe
+      end
+
+      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
+
+        return nil if amount_in_cents.zero?
+
+        customer = fetch_or_create_customer(order: order)
+        stripe_pm_id = external_data[:stripe_payment_method_id] || external_data['stripe_payment_method_id']
+
+        response = create_payment_intent(
+          amount_in_cents, order,
+          payment_method_id: stripe_pm_id,
+          customer_profile_id: customer&.profile_id
+        )
+
+        ephemeral_key_response = create_ephemeral_key(customer.profile_id) if customer.present?
+        ephemeral_key_secret = ephemeral_key_response&.params&.dig('secret')
+
+        payment_session_class.create!(
+          order: order,
+          payment_method: self,
+          amount: total,
+          currency: order.currency,
+          status: 'pending',
+          external_id: response.authorization,
+          customer: order.user,
+          customer_external_id: customer&.profile_id,
+          external_data: {
+            'client_secret' => response.params['client_secret'],
+            'ephemeral_key_secret' => ephemeral_key_secret,
+            'stripe_payment_method_id' => stripe_pm_id
+          }.compact
+        )
+      end
+
+      def update_payment_session(payment_session:, amount: nil, external_data: {})
+        attrs = {}
+        amount_in_cents = nil
+
+        if amount.present?
+          attrs[:amount] = amount
+          amount_in_cents = Spree::Money.new(amount, currency: payment_session.currency).cents
+        end
+
+        stripe_pm_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,
+          payment_session.order,
+          stripe_pm_id
+        )
+
+        if external_data.present?
+          attrs[:external_data] = (payment_session.external_data || {}).merge(external_data.stringify_keys)
+        end
+
+        payment_session.update!(attrs) if attrs.any?
+      end
+
+      # Completes a payment session by verifying with Stripe, creating the
+      # Payment record, and patching wallet address data.
+      #
+      # Does NOT complete the order — that is handled by Carts::Complete
+      # (called by the storefront or by the webhook handler).
+      def complete_payment_session(payment_session:, params: {})
+        stripe_pi = retrieve_payment_intent(payment_session.external_id)
+
+        if payment_intent_accepted?(stripe_pi)
+          payment_session.process if payment_session.can_process?
+
+          charge = payment_session.stripe_charge
+
+          # Patch wallet billing address (Apple Pay, Google Pay)
+          patch_wallet_address(payment_session.order, charge) if charge.present?
+
+          # Create the Payment record
+          payment_session.find_or_create_payment!
+
+          # `else` covers requires_capture (manual capture), processing (delayed-notification
+          # banks), and requires_action (bank transfer awaiting funds) — all auth-only states.
+          payment = payment_session.payment
+          if payment.present? && !payment.completed?
+            if payment_intent_successful?(stripe_pi)
+              payment.process!
+            else
+              payment.authorize!
+            end
+          end
+
+          payment_session.complete unless payment_session.completed?
+        else
+          payment_session.fail if payment_session.can_fail?
+        end
+      end
+
+      private
+
+      def payment_intent_successful?(stripe_pi)
+        stripe_pi.status == 'succeeded'
+      end
+
+      # Patches the order's billing address with data from the Stripe charge.
+      # Needed for quick checkout (Apple Pay/Google Pay) where the storefront
+      # doesn't have the billing address before payment confirmation.
+      def patch_wallet_address(order, charge)
+        return if charge.blank?
+
+        billing_details = charge.billing_details
+        address = billing_details.address
+
+        order.email ||= billing_details.email
+        order.save! if order.email_changed?
+
+        # Skip if billing address is already valid
+        return if order.bill_address.present? && order.bill_address.valid?
+
+        country_iso = address.country
+        country = (country_iso.present? && Spree::Country.by_iso(country_iso)) ||
+                  order.store.default_market&.default_country ||
+                  Spree::Country.by_iso('US')
+
+        order.bill_address ||= Spree::Address.new(country: country, user: order.user)
+        order.bill_address.quick_checkout = true
+
+        first_name = billing_details.name&.split(' ')&.first || order.ship_address&.first_name || order.user&.first_name
+        last_name = billing_details.name&.split(' ')&.last || order.ship_address&.last_name || order.user&.last_name
+
+        order.bill_address.first_name ||= first_name
+        order.bill_address.last_name ||= last_name
+        order.bill_address.phone ||= billing_details.phone
+        order.bill_address.address1 ||= address.line1
+        order.bill_address.address2 ||= address.line2
+        order.bill_address.city ||= address.city
+        order.bill_address.zipcode ||= address.postal_code
+
+        state_name = address.state
+        if country.states_required?
+          order.bill_address.state = country.states.find_all_by_name_or_abbr(state_name)&.first
+        else
+          order.bill_address.state_name = state_name
+        end
+        order.bill_address.state_name ||= state_name
+
+        if order.bill_address.invalid?
+          return if order.ship_address.blank?
+
+          order.bill_address = order.ship_address
+        end
+
+        order.bill_address.save! if order.bill_address&.changed?
+        order.save!
+
+        copy_bill_info_to_user(order) if order.user.present?
+      end
+
+      def copy_bill_info_to_user(order)
+        user = order.user
+        user.first_name ||= order.bill_address.first_name
+        user.last_name ||= order.bill_address.last_name
+        user.phone ||= order.bill_address.phone
+        user.bill_address_id ||= order.bill_address.id
+        user.save! if user.changed?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module SpreeStripe
+  class Gateway < ::Spree::Gateway
+    module PaymentSetupSessions
+      extend ActiveSupport::Concern
+
+      def setup_session_supported?
+        true
+      end
+
+      def payment_setup_session_class
+        Spree::PaymentSetupSessions::Stripe
+      end
+
+      def create_payment_setup_session(customer:, external_data: {})
+        gateway_customer = fetch_or_create_customer(user: customer)
+
+        setup_intent_response = create_setup_intent(gateway_customer.profile_id)
+        ephemeral_key_response = create_ephemeral_key(gateway_customer.profile_id)
+
+        payment_setup_session_class.create!(
+          customer: customer,
+          payment_method: self,
+          status: 'pending',
+          external_id: setup_intent_response.params['id'],
+          external_client_secret: setup_intent_response.authorization,
+          external_data: external_data.to_h.stringify_keys.merge(
+            'customer_id' => gateway_customer.profile_id,
+            'ephemeral_key_secret' => ephemeral_key_response&.params&.dig('secret')
+          ).compact
+        )
+      end
+
+      def complete_payment_setup_session(setup_session:, params: {})
+        stripe_setup_intent = retrieve_setup_intent(setup_session.external_id)
+
+        if stripe_setup_intent.status == 'succeeded'
+          setup_session.process if setup_session.can_process?
+
+          stripe_payment_method = stripe_setup_intent.payment_method
+
+          source = SpreeStripe::CreateSource.new(
+            stripe_payment_method_details: stripe_payment_method,
+            stripe_payment_method_id: stripe_payment_method.id,
+            stripe_billing_details: stripe_payment_method.billing_details,
+            gateway: self,
+            user: setup_session.customer
+          ).call
+
+          setup_session.payment_source = source
+          setup_session.complete unless setup_session.completed?
+        else
+          setup_session.fail if setup_session.can_fail?
+        end
+
+        setup_session
+      end
+
+      def retrieve_setup_intent(setup_intent_id)
+        send_request { |opts| Stripe::SetupIntent.retrieve({ id: setup_intent_id, expand: ['payment_method'] }, opts) }
+      end
+    end
+  end
+end