pay 3.0.24 → 4.0.2

data/lib/pay/stripe/billable.rb

@@ -22,11 +22,36 @@ module Pay
         @pay_customer = pay_customer
       end
 
+      # Returns a hash of attributes for the Stripe::Customer object
+      def customer_attributes
+        owner = pay_customer.owner
+
+        attributes = case owner.class.pay_stripe_customer_attributes
+        when Symbol
+          owner.send(owner.class.pay_stripe_customer_attributes, pay_customer)
+        when Proc
+          owner.class.pay_stripe_customer_attributes.call(pay_customer)
+        end
+
+        # Guard against attributes being returned nil
+        attributes ||= {}
+
+        {email: email, name: customer_name}.merge(attributes)
+      end
+
+      # Retrieves a Stripe::Customer object
+      #
+      # Finds an existing Stripe::Customer if processor_id exists
+      # Creates a new Stripe::Customer using `customer_attributes` if empty processor_id
+      #
+      # Updates the default payment method automatically if a payment_method_token is set
+      #
+      # Returns a Stripe::Customer object
       def customer
         stripe_customer = if processor_id?
-          ::Stripe::Customer.retrieve({id: processor_id}, stripe_options)
+          ::Stripe::Customer.retrieve({id: processor_id, expand: ["tax"]}, stripe_options)
         else
-          sc = ::Stripe::Customer.create({email: email, name: customer_name}, stripe_options)
+          sc = ::Stripe::Customer.create(customer_attributes.merge(expand: ["tax"]), stripe_options)
           pay_customer.update!(processor_id: sc.id, stripe_account: stripe_account)
           sc
         end
@@ -45,9 +70,14 @@ module Pay
       end
 
       # Syncs name and email to Stripe::Customer
-      def update_customer!
-        return unless processor_id?
-        ::Stripe::Customer.update(processor_id, {name: customer_name, email: email}, stripe_options)
+      # You can also pass in other attributes that will be merged into the default attributes
+      def update_customer!(**attributes)
+        customer unless processor_id?
+        ::Stripe::Customer.update(
+          processor_id,
+          customer_attributes.merge(attributes),
+          stripe_options
+        )
       end
 
       def charge(amount, options = {})
@@ -57,7 +87,6 @@ module Pay
         args = {
           amount: amount,
           confirm: true,
-          confirmation_method: :automatic,
           currency: "usd",
           customer: processor_id,
           payment_method: payment_method&.processor_id
@@ -73,7 +102,7 @@ module Pay
       end
 
       def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
-        quantity = options.delete(:quantity) || 1
+        quantity = options.delete(:quantity)
         opts = {
           expand: ["pending_setup_intent", "latest_invoice.payment_intent", "latest_invoice.charge.invoice"],
           items: [plan: plan, quantity: quantity],
@@ -87,13 +116,13 @@ module Pay
         opts[:customer] = customer.id
 
         # Create subscription on Stripe
-        stripe_sub = ::Stripe::Subscription.create(opts, stripe_options)
+        stripe_sub = ::Stripe::Subscription.create(opts.merge(Pay::Stripe::Subscription.expand_options), stripe_options)
 
         # Save Pay::Subscription
         subscription = Pay::Stripe::Subscription.sync(stripe_sub.id, object: stripe_sub, name: name)
 
         # No trial, payment method requires SCA
-        if subscription.incomplete?
+        if options[:payment_behavior].to_s != "default_incomplete" && subscription.incomplete?
           Pay::Payment.new(stripe_sub.latest_invoice.payment_intent).validate
         end
 
@@ -125,19 +154,16 @@ module Pay
 
         attributes = Pay::Stripe::PaymentMethod.extract_attributes(payment_method).merge(default: default)
 
-        pay_customer.payment_methods.update_all(default: false) if default
+        # Ignore the payment method if it's already in the database
+        pay_customer.payment_methods.where.not(id: pay_payment_method.id).update_all(default: false) if default
         pay_payment_method.update!(attributes)
 
         # Reload the Rails association
-        pay_customer.reload_default_payment_method if default
+        pay_customer.reload_default_payment_method
 
         pay_payment_method
       end
 
-      def update_email!
-        ::Stripe::Customer.update(processor_id, {email: email, name: customer_name}, stripe_options)
-      end
-
       def processor_subscription(subscription_id, options = {})
         ::Stripe::Subscription.retrieve(options.merge(id: subscription_id), stripe_options)
       end
@@ -151,8 +177,11 @@ module Pay
         ::Stripe::Invoice.upcoming({customer: processor_id}, stripe_options)
       end
 
-      def create_setup_intent
-        ::Stripe::SetupIntent.create({customer: processor_id, usage: :off_session}, stripe_options)
+      def create_setup_intent(options = {})
+        ::Stripe::SetupIntent.create({
+          customer: processor_id,
+          usage: :off_session
+        }.merge(options), stripe_options)
       end
 
       def trial_end_date(stripe_sub)
@@ -184,7 +213,6 @@ module Pay
         customer unless processor_id?
         args = {
           customer: processor_id,
-          payment_method_types: ["card"],
           mode: "payment",
           # These placeholder URLs will be replaced in a following step.
           success_url: merge_session_id_param(options.delete(:success_url) || root_url),
@@ -239,6 +267,10 @@ module Pay
         ::Stripe::BillingPortal::Session.create(args.merge(options), stripe_options)
       end
 
+      def authorize(amount, options = {})
+        charge(amount, options.merge(capture_method: :manual))
+      end
+
       private
 
       # Options for Stripe requests

data/lib/pay/stripe/charge.rb

@@ -3,11 +3,21 @@ module Pay
     class Charge
       attr_reader :pay_charge
 
-      delegate :processor_id, :stripe_account, to: :pay_charge
+      delegate :amount,
+        :amount_captured,
+        :invoice_id,
+        :line_items,
+        :payment_intent_id,
+        :processor_id,
+        :stripe_account,
+        to: :pay_charge
 
       def self.sync(charge_id, object: nil, stripe_account: nil, try: 0, retries: 1)
         # Skip loading the latest charge details from the API if we already have it
-        object ||= ::Stripe::Charge.retrieve(charge_id, {stripe_account: stripe_account}.compact)
+        object ||= ::Stripe::Charge.retrieve({id: charge_id, expand: ["invoice.total_discount_amounts.discount", "invoice.total_tax_amounts.tax_rate"]}, {stripe_account: stripe_account}.compact)
+
+        # Ignore charges without a Customer
+        return if object.customer.blank?
 
         pay_customer = Pay::Customer.find_by(processor: :stripe, processor_id: object.customer)
         return unless pay_customer
@@ -15,24 +25,61 @@ module Pay
         payment_method = object.payment_method_details.send(object.payment_method_details.type)
         attrs = {
           amount: object.amount,
+          amount_captured: object.amount_captured,
           amount_refunded: object.amount_refunded,
           application_fee_amount: object.application_fee_amount,
+          bank: payment_method.try(:bank_name) || payment_method.try(:bank), # eps, fpx, ideal, p24, acss_debit, etc
+          brand: payment_method.try(:brand)&.capitalize,
           created_at: Time.at(object.created),
           currency: object.currency,
-          stripe_account: pay_customer.stripe_account,
-          metadata: object.metadata,
-          payment_method_type: object.payment_method_details.type,
-          brand: payment_method.try(:brand)&.capitalize,
-          last4: payment_method.try(:last4).to_s,
+          discounts: [],
           exp_month: payment_method.try(:exp_month).to_s,
           exp_year: payment_method.try(:exp_year).to_s,
-          bank: payment_method.try(:bank_name) || payment_method.try(:bank) # eps, fpx, ideal, p24, acss_debit, etc
+          last4: payment_method.try(:last4).to_s,
+          line_items: [],
+          metadata: object.metadata,
+          payment_intent_id: object.payment_intent,
+          payment_method_type: object.payment_method_details.type,
+          stripe_account: pay_customer.stripe_account,
+          stripe_receipt_url: object.receipt_url,
+          total_tax_amounts: []
         }
 
         # Associate charge with subscription if we can
         if object.invoice
-          invoice = (object.invoice.is_a?(::Stripe::Invoice) ? object.invoice : ::Stripe::Invoice.retrieve(object.invoice, {stripe_account: stripe_account}.compact))
+          invoice = (object.invoice.is_a?(::Stripe::Invoice) ? object.invoice : ::Stripe::Invoice.retrieve({id: object.invoice, expand: ["total_discount_amounts.discount", "total_tax_amounts.tax_rate"]}, {stripe_account: stripe_account}.compact))
+          attrs[:invoice_id] = invoice.id
           attrs[:subscription] = pay_customer.subscriptions.find_by(processor_id: invoice.subscription)
+
+          attrs[:period_start] = Time.at(invoice.period_start)
+          attrs[:period_end] = Time.at(invoice.period_end)
+          attrs[:subtotal] = invoice.subtotal
+          attrs[:tax] = invoice.tax
+          attrs[:discounts] = invoice.discounts
+          attrs[:total_tax_amounts] = invoice.total_tax_amounts.map(&:to_hash)
+          attrs[:total_discount_amounts] = invoice.total_discount_amounts.map(&:to_hash)
+
+          invoice.lines.auto_paging_each do |line_item|
+            # Currency is tied to the charge, so storing it would be duplication
+            attrs[:line_items] << {
+              id: line_item.id,
+              description: line_item.description,
+              price_id: line_item.price&.id,
+              quantity: line_item.quantity,
+              unit_amount: line_item.price&.unit_amount,
+              amount: line_item.amount,
+              discounts: line_item.discounts,
+              tax_amounts: line_item.tax_amounts,
+              proration: line_item.proration,
+              period_start: Time.at(line_item.period.start),
+              period_end: Time.at(line_item.period.end)
+            }
+          end
+
+        # Charges without invoices
+        else
+          attrs[:period_start] = Time.at(object.created)
+          attrs[:period_end] = Time.at(object.created)
         end
 
         # Update or create the charge
@@ -64,14 +111,49 @@ module Pay
         raise Pay::Stripe::Error, e
       end
 
+      # Issues a CreditNote if there's an invoice, otherwise uses a Refund
+      # This allows Tax to be handled properly
+      #
+      # https://stripe.com/docs/api/credit_notes/create
       # https://stripe.com/docs/api/refunds/create
       #
       # refund!
       # refund!(5_00)
       # refund!(5_00, refund_application_fee: true)
       def refund!(amount_to_refund, **options)
-        ::Stripe::Refund.create(options.merge(charge: processor_id, amount: amount_to_refund), stripe_options)
-        pay_charge.update(amount_refunded: amount_to_refund)
+        if invoice_id.present?
+          description = options.delete(:description) || I18n.t("refund")
+          lines = [{type: :custom_line_item, description: description, quantity: 1, unit_amount: amount_to_refund}]
+          credit_note!(**options.merge(refund_amount: amount_to_refund, lines: lines))
+        else
+          ::Stripe::Refund.create(options.merge(charge: processor_id, amount: amount_to_refund), stripe_options)
+        end
+        pay_charge.update!(amount_refunded: pay_charge.amount_refunded + amount_to_refund)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
+      end
+
+      # Adds a credit note to a Stripe Invoice
+      def credit_note!(**options)
+        raise Pay::Stripe::Error, "no Stripe invoice_id on Pay::Charge" if invoice_id.blank?
+        ::Stripe::CreditNote.create({invoice: invoice_id}.merge(options), stripe_options)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
+      end
+
+      def credit_notes(**options)
+        raise Pay::Stripe::Error, "no Stripe invoice_id on Pay::Charge" if invoice_id.blank?
+        ::Stripe::CreditNote.list({invoice: invoice_id}.merge(options), stripe_options)
+      end
+
+      # https://stripe.com/docs/payments/capture-later
+      #
+      # capture
+      # capture(amount_to_capture: 15_00)
+      def capture(**options)
+        raise Pay::Stripe::Error, "no payment_intent_id on charge" unless payment_intent_id.present?
+        ::Stripe::PaymentIntent.capture(payment_intent_id, options, stripe_options)
+        self.class.sync(processor_id)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end

data/lib/pay/stripe/merchant.rb

@@ -38,7 +38,7 @@ module Pay
           refresh_url: refresh_url,
           return_url: return_url,
           type: type
-        })
+        }.merge(options))
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end

data/lib/pay/stripe/subscription.rb

@@ -1,6 +1,7 @@
 module Pay
   module Stripe
     class Subscription
+      attr_accessor :stripe_subscription
       attr_reader :pay_subscription
 
       delegate :active?,
@@ -16,26 +17,46 @@ module Pay
         :quantity,
         :quantity?,
         :stripe_account,
+        :subscription_items,
         :trial_ends_at,
+        :pause_behavior,
+        :pause_resumes_at,
         to: :pay_subscription
 
-      def self.sync(subscription_id, object: nil, name: Pay.default_product_name, stripe_account: nil, try: 0, retries: 1)
+      def self.sync(subscription_id, object: nil, name: nil, stripe_account: nil, try: 0, retries: 1)
         # Skip loading the latest subscription details from the API if we already have it
-        object ||= ::Stripe::Subscription.retrieve({id: subscription_id, expand: ["pending_setup_intent", "latest_invoice.payment_intent", "latest_invoice.charge.invoice"]}, {stripe_account: stripe_account}.compact)
+        object ||= ::Stripe::Subscription.retrieve({id: subscription_id}.merge(expand_options), {stripe_account: stripe_account}.compact)
 
         pay_customer = Pay::Customer.find_by(processor: :stripe, processor_id: object.customer)
         return unless pay_customer
 
         attributes = {
           application_fee_percent: object.application_fee_percent,
-          processor_plan: object.plan.id,
-          quantity: object.quantity,
+          processor_plan: object.items.first.price.id,
+          quantity: object.items.first.try(:quantity) || 0,
           status: object.status,
           stripe_account: pay_customer.stripe_account,
-          trial_ends_at: (object.trial_end ? Time.at(object.trial_end) : nil),
-          metadata: object.metadata
+          metadata: object.metadata,
+          subscription_items: [],
+          metered: false,
+          pause_behavior: object.pause_collection&.behavior,
+          pause_resumes_at: (object.pause_collection&.resumes_at ? Time.at(object.pause_collection&.resumes_at) : nil)
         }
 
+        # Subscriptions that have ended should have their trial ended at the same time
+        if object.trial_end
+          attributes[:trial_ends_at] = Time.at(object.ended_at || object.trial_end)
+        end
+
+        # Record subscription items to db
+        object.items.auto_paging_each do |subscription_item|
+          if !attributes[:metered] && (subscription_item.to_hash.dig(:price, :recurring, :usage_type) == "metered")
+            attributes[:metered] = true
+          end
+
+          attributes[:subscription_items] << subscription_item.to_hash.slice(:id, :price, :metadata, :quantity)
+        end
+
         attributes[:ends_at] = if object.ended_at
           # Fully cancelled subscription
           Time.at(object.ended_at)
@@ -52,9 +73,15 @@ module Pay
         if pay_subscription
           pay_subscription.with_lock { pay_subscription.update!(attributes) }
         else
+          # Allow setting the subscription name in metadata, otherwise use the default
+          name ||= object.metadata["pay_name"] || Pay.default_product_name
+
           pay_subscription = pay_customer.subscriptions.create!(attributes.merge(name: name, processor_id: object.id))
         end
 
+        # Cache the Stripe subscription on the Pay::Subscription that we return
+        pay_subscription.stripe_subscription = object
+
         # Sync the latest charge if we already have it loaded (like during subscrbe), otherwise, let webhooks take care of creating it
         if (charge = object.try(:latest_invoice).try(:charge)) && charge.try(:status) == "succeeded"
           Pay::Stripe::Charge.sync(charge.id, object: charge)
@@ -71,32 +98,61 @@ module Pay
         end
       end
 
+      # Common expand options for all requests that create, retrieve, or update a Stripe Subscription
+      def self.expand_options
+        {expand: ["pending_setup_intent", "latest_invoice.payment_intent", "latest_invoice.charge.invoice"]}
+      end
+
       def initialize(pay_subscription)
         @pay_subscription = pay_subscription
       end
 
       def subscription(**options)
         options[:id] = processor_id
-        options[:expand] ||= ["pending_setup_intent", "latest_invoice.payment_intent", "latest_invoice.charge.invoice"]
-        ::Stripe::Subscription.retrieve(options, {stripe_account: stripe_account}.compact)
+        @stripe_subscription ||= ::Stripe::Subscription.retrieve(options.merge(expand_options), {stripe_account: stripe_account}.compact)
       end
 
-      def cancel
-        stripe_sub = ::Stripe::Subscription.update(processor_id, {cancel_at_period_end: true}, stripe_options)
-        pay_subscription.update(ends_at: (on_trial? ? trial_ends_at : Time.at(stripe_sub.current_period_end)))
+      def reload!
+        @stripe_subscription = nil
+      end
+
+      # Returns a SetupIntent or PaymentIntent client secret for the subscription
+      def client_secret
+        stripe_sub = subscription
+        stripe_sub&.pending_setup_intent&.client_secret || stripe_sub&.latest_invoice&.payment_intent&.client_secret
+      end
+
+      def cancel(**options)
+        @stripe_subscription = ::Stripe::Subscription.update(processor_id, {cancel_at_period_end: true}.merge(expand_options), stripe_options)
+        pay_subscription.update(ends_at: (on_trial? ? trial_ends_at : Time.at(@stripe_subscription.current_period_end)))
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
-      def cancel_now!
-        ::Stripe::Subscription.delete(processor_id, {}, stripe_options)
+      # Cancels a subscription immediately
+      #
+      # cancel_now!(prorate: true)
+      # cancel_now!(invoice_now: true)
+      def cancel_now!(**options)
+        @stripe_subscription = ::Stripe::Subscription.delete(processor_id, options.merge(expand_options), stripe_options)
         pay_subscription.update(ends_at: Time.current, status: :canceled)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
-      def change_quantity(quantity)
-        ::Stripe::Subscription.update(processor_id, {quantity: quantity}, stripe_options)
+      # This updates a SubscriptionItem's quantity in Stripe
+      #
+      # For a subscription with a single item, we can update the subscription directly if no SubscriptionItem ID is available
+      # Otherwise a SubscriptionItem ID is required so Stripe knows which entry to update
+      def change_quantity(quantity, **options)
+        subscription_item_id = options.fetch(:subscription_item_id, subscription_items.first["id"])
+        if subscription_item_id
+          ::Stripe::SubscriptionItem.update(subscription_item_id, options.merge(quantity: quantity), stripe_options)
+          @stripe_subscription = nil
+        else
+          @stripe_subscription = ::Stripe::Subscription.update(processor_id, options.merge(quantity: quantity).merge(expand_options), stripe_options)
+        end
+        true
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -106,27 +162,47 @@ module Pay
       end
 
       def paused?
-        false
+        pause_behavior.present?
       end
 
-      def pause
-        raise NotImplementedError, "Stripe does not support pausing subscriptions"
+      # Pauses a Stripe subscription
+      #
+      # pause(behavior: "mark_uncollectible")
+      # pause(behavior: "keep_as_draft")
+      # pause(behavior: "void")
+      # pause(behavior: "mark_uncollectible", resumes_at: 1.month.from_now)
+      def pause(**options)
+        attributes = {pause_collection: options.reverse_merge(behavior: "mark_uncollectible")}
+        @stripe_subscription = ::Stripe::Subscription.update(processor_id, attributes.merge(expand_options), stripe_options)
+        pay_subscription.update(
+          pause_behavior: @stripe_subscription.pause_collection&.behavior,
+          pause_resumes_at: (@stripe_subscription.pause_collection&.resumes_at ? Time.at(@stripe_subscription.pause_collection&.resumes_at) : nil)
+        )
+      end
+
+      def unpause
+        @stripe_subscription = ::Stripe::Subscription.update(processor_id, {pause_collection: nil}.merge(expand_options), stripe_options)
+        pay_subscription.update(pause_behavior: nil, pause_resumes_at: nil)
       end
 
       def resume
-        unless on_grace_period?
+        unless on_grace_period? || paused?
           raise StandardError, "You can only resume subscriptions within their grace period."
         end
 
-        ::Stripe::Subscription.update(
-          processor_id,
-          {
-            plan: processor_plan,
-            trial_end: (on_trial? ? trial_ends_at.to_i : "now"),
-            cancel_at_period_end: false
-          },
-          stripe_options
-        )
+        if paused?
+          unpause
+        else
+          @stripe_subscription = ::Stripe::Subscription.update(
+            processor_id,
+            {
+              plan: processor_plan,
+              trial_end: (on_trial? ? trial_ends_at.to_i : "now"),
+              cancel_at_period_end: false
+            }.merge(expand_options),
+            stripe_options
+          )
+        end
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -134,7 +210,7 @@ module Pay
       def swap(plan)
         raise ArgumentError, "plan must be a string" unless plan.is_a?(String)
 
-        ::Stripe::Subscription.update(
+        @stripe_subscription = ::Stripe::Subscription.update(
           processor_id,
           {
             cancel_at_period_end: false,
@@ -142,19 +218,45 @@ module Pay
             proration_behavior: (prorate ? "create_prorations" : "none"),
             trial_end: (on_trial? ? trial_ends_at.to_i : "now"),
             quantity: quantity
-          },
+          }.merge(expand_options),
           stripe_options
         )
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
+      # Creates a metered billing usage record
+      #
+      # Uses the first subscription_item ID unless `subscription_item_id: "si_1234"` is passed
+      #
+      # create_usage_record(quantity: 4, action: :increment)
+      # create_usage_record(subscription_item_id: "si_1234", quantity: 100, action: :set)
+      def create_usage_record(**options)
+        subscription_item_id = options.fetch(:subscription_item_id, subscription_items.first["id"])
+        ::Stripe::SubscriptionItem.create_usage_record(subscription_item_id, options, stripe_options)
+      end
+
+      # Returns usage record summaries for a subscription item
+      def usage_record_summaries(**options)
+        subscription_item_id = options.fetch(:subscription_item_id, subscription_items.first["id"])
+        ::Stripe::SubscriptionItem.list_usage_record_summaries(subscription_item_id, options, stripe_options)
+      end
+
+      # Returns an upcoming invoice for a subscription
+      def upcoming_invoice(**options)
+        ::Stripe::Invoice.upcoming(options.merge(subscription: processor_id), stripe_options)
+      end
+
       private
 
       # Options for Stripe requests
       def stripe_options
         {stripe_account: stripe_account}.compact
       end
+
+      def expand_options
+        self.class.expand_options
+      end
     end
   end
 end

data/lib/pay/stripe/webhooks/charge_refunded.rb

@@ -5,8 +5,8 @@ module Pay
         def call(event)
           pay_charge = Pay::Stripe::Charge.sync(event.data.object.id, stripe_account: event.try(:account))
 
-          if pay_charge && Pay.send_emails
-            Pay::UserMailer.with(pay_customer: pay_charge.customer, charge: pay_charge).refund.deliver_later
+          if pay_charge && Pay.send_email?(:refund, pay_charge)
+            Pay.mailer.with(pay_customer: pay_charge.customer, pay_charge: pay_charge).refund.deliver_later
           end
         end
       end

data/lib/pay/stripe/webhooks/charge_succeeded.rb

@@ -5,8 +5,8 @@ module Pay
         def call(event)
           pay_charge = Pay::Stripe::Charge.sync(event.data.object.id, stripe_account: event.try(:account))
 
-          if pay_charge && Pay.send_emails
-            Pay::UserMailer.with(pay_customer: pay_charge.customer, charge: pay_charge).receipt.deliver_later
+          if pay_charge && Pay.send_email?(:receipt, pay_charge)
+            Pay.mailer.with(pay_customer: pay_charge.customer, pay_charge: pay_charge).receipt.deliver_later
           end
         end
       end

data/lib/pay/stripe/webhooks/checkout_session_async_payment_succeeded.rb

@@ -1,14 +1,7 @@
 module Pay
   module Stripe
     module Webhooks
-      class CheckoutSessionAsyncPaymentSucceeded
-        def call(event)
-          # TODO: Also handle payment intents
-
-          if event.data.object.subscription
-            Pay::Stripe::Subscription.sync(event.data.object.subscription, stripe_account: event.try(:account))
-          end
-        end
+      class CheckoutSessionAsyncPaymentSucceeded < CheckoutSessionCompleted
       end
     end
   end

data/lib/pay/stripe/webhooks/checkout_session_completed.rb

@@ -5,10 +5,29 @@ module Pay
         def call(event)
           # TODO: Also handle payment intents
 
-          if event.data.object.subscription
-            Pay::Stripe::Subscription.sync(event.data.object.subscription, stripe_account: event.try(:account))
+          locate_owner(event.data.object)
+
+          if (payment_intent_id = event.data.object.payment_intent)
+            payment_intent = ::Stripe::PaymentIntent.retrieve(payment_intent_id, {stripe_account: event.try(:account)}.compact)
+            payment_intent.charges.each do |charge|
+              Pay::Stripe::Charge.sync(charge.id, stripe_account: event.try(:account))
+            end
+          end
+
+          if (subscription_id = event.data.object.subscription)
+            Pay::Stripe::Subscription.sync(subscription_id, stripe_account: event.try(:account))
           end
         end
+
+        def locate_owner(object)
+          return if object.client_reference_id.nil?
+
+          # If there is a client reference ID, make sure we have a Pay::Customer record
+          owner = GlobalID::Locator.locate_signed(object.client_reference_id)
+          owner&.add_payment_processor(:stripe, processor_id: object.customer)
+        rescue
+          Rails.logger.debug "[Pay] Unable to locate record with SGID: #{object.client_reference_id}"
+        end
       end
     end
   end

data/lib/pay/stripe/webhooks/payment_action_required.rb

@@ -8,14 +8,14 @@ module Pay
 
           object = event.data.object
 
-          subscription = Pay::Subscription.find_by_processor_and_id(:stripe, object.subscription)
-          return if subscription.nil?
+          pay_subscription = Pay::Subscription.find_by_processor_and_id(:stripe, object.subscription)
+          return if pay_subscription.nil?
 
-          if Pay.send_emails
-            Pay::UserMailer.with(
-              pay_customer: subscription.customer,
+          if Pay.send_email?(:payment_action_required, pay_subscription)
+            Pay.mailer.with(
+              pay_customer: pay_subscription.customer,
               payment_intent_id: event.data.object.payment_intent,
-              subscription: subscription
+              pay_subscription: pay_subscription
             ).payment_action_required.deliver_later
           end
         end