pay 9.0.1 → 10.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 351dfe4e2001a3d892ba872ca305a44c49fde456d78fa1aaebf505fe603d3bc1
-  data.tar.gz: a9bdd0f9c7b81325bba64cf63e610a520867678a51c6ea1c30c29a43b47c90e4
+  metadata.gz: 97c43263ab73cd849da8c65e8a4f1235aabb28b6f35c56c5441c077838374186
+  data.tar.gz: c0161223fdbd12eee31ef928639bba40e9af1a63e2e6cdeee3e2a69fce106de4
 SHA512:
-  metadata.gz: 9bf920b25c5c845e31aa639dfa725ae5e3beaa226892518bd6c025b7805cb70cb6e1c211e743204d9b5fea14b93c6506c5d58ec59725a189457b8db3dee97893
-  data.tar.gz: 1cdd1a4d26048b9683fc4a83df5f327c7ef4792b66b831ed0464dc9f035df9a8e72e35b8592cf19c103f56faa5b1777b2cee8b97e07f054a88b79b2bd177c3e0
+  metadata.gz: 1fd5fdc16c976d6d33e908210c54de32cdbfcea6e0d641b58eb5f6e52fb5ff217bb59ac6ae3bb7118f8e59f5f6bcc2f2bd88fd61736d01c9fff386ebf24937ef
+  data.tar.gz: ffee6759b0bae293ffadb173158a57bac35e9f10150a38846499e2ffe635380a64606847098303a9422addd23e7e372d08669929b973c4135df2f2f81a3a0d2c

data/app/models/pay/braintree/subscription.rb

@@ -131,8 +131,9 @@ module Pay
         end
 
         braintree_plan = find_braintree_plan(plan)
+        prorate = options.fetch(:prorate) { true }
 
-        if would_change_billing_frequency?(braintree_plan) && prorate?
+        if would_change_billing_frequency?(braintree_plan) && prorate
           swap_across_frequencies(braintree_plan)
           return
         end
@@ -143,7 +144,7 @@ module Pay
           never_expires: true,
           number_of_billing_cycles: nil,
           options: {
-            prorate_charges: prorate?
+            prorate_charges: prorate
           }
         })
         raise Error, "Braintree failed to swap plans: #{result.message}" unless result.success?

data/app/models/pay/charge.rb

@@ -23,20 +23,8 @@ module Pay
     store_accessor :data, :username # Venmo
     store_accessor :data, :bank
 
-    store_accessor :data, :amount_captured
-    store_accessor :data, :invoice_id
-    store_accessor :data, :payment_intent_id
-    store_accessor :data, :period_start
-    store_accessor :data, :period_end
-    store_accessor :data, :line_items
-    store_accessor :data, :subtotal # subtotal amount in cents
-    store_accessor :data, :tax # total tax amount in cents
-    store_accessor :data, :discounts # array of discount IDs applied to the Stripe Invoice
-    store_accessor :data, :total_discount_amounts # array of discount details
-    store_accessor :data, :total_tax_amounts # array of tax details for each jurisdiction
-    store_accessor :data, :credit_notes # array of credit notes for the Stripe Invoice
-    store_accessor :data, :refunds # array of refunds
-    store_accessor :data, :balance_transaction
+    store_accessor :data, :subtotal
+    store_accessor :data, :tax
 
     # Helpers for payment processors
     %w[braintree stripe paddle_billing paddle_classic lemon_squeezy fake_processor].each do |processor_name|
@@ -51,8 +39,9 @@ module Pay
       joins(:customer).find_by(processor_id: processor_id, pay_customers: {processor: processor})
     end
 
-    def captured?
-      amount_captured > 0
+    def sync!(**options)
+      self.class.sync(processor_id, **options)
+      reload
     end
 
     def refunded?
@@ -113,9 +102,5 @@ module Pay
         payment_method_type&.titleize
       end
     end
-
-    def line_items
-      Array.wrap(super)
-    end
   end
 end

data/app/models/pay/fake_processor/charge.rb

@@ -1,6 +1,10 @@
 module Pay
   module FakeProcessor
     class Charge < Pay::Charge
+      def self.sync(processor_id)
+        true
+      end
+
       def api_record
         self
       end

data/app/models/pay/lemon_squeezy/charge.rb

@@ -68,6 +68,16 @@ module Pay
         end
       end
 
+      def save
+        ls_type, ls_id = processor_id.split(":", 2)
+        case ls_type
+        when "order"
+          self.class.sync_order(ls_id)
+        when "subscription_invoice"
+          self.class.sync_subscription_invoice(ls_id)
+        end
+      end
+
       def api_record
         ls_type, ls_id = processor_id.split(":", 2)
         case ls_type

data/app/models/pay/paddle_billing/subscription.rb

@@ -1,6 +1,9 @@
 module Pay
   module PaddleBilling
     class Subscription < Pay::Subscription
+      store_accessor :data, :paddle_update_url
+      store_accessor :data, :paddle_cancel_url
+
       def self.sync_from_transaction(transaction_id)
         transaction = ::Paddle::Transaction.retrieve(id: transaction_id)
         sync(transaction.subscription_id) if transaction.subscription_id

data/app/models/pay/paddle_classic/subscription.rb

@@ -1,6 +1,9 @@
 module Pay
   module PaddleClassic
     class Subscription < Pay::Subscription
+      store_accessor :data, :paddle_update_url
+      store_accessor :data, :paddle_cancel_url
+
       def self.sync(subscription_id, object: nil, name: Pay.default_product_name)
         # Passthrough is not return from this API, so we can't use that
         object ||= PaddleClassic.client.users.list(subscription_id: subscription_id).data.try(:first)
@@ -128,7 +131,7 @@ module Pay
       def swap(plan, **options)
         raise ArgumentError, "plan must be a string" unless plan.is_a?(String)
 
-        attributes = {plan_id: plan, prorate: prorate}
+        attributes = {plan_id: plan, prorate: options.fetch(:prorate) { true }}
         attributes[:quantity] = quantity if quantity?
         PaddleClassic.client.users.update(subscription_id: processor_id, **attributes)
 

data/app/models/pay/stripe/charge.rb

@@ -1,11 +1,21 @@
 module Pay
   module Stripe
     class Charge < Pay::Charge
+      EXPAND = ["balance_transaction", "refunds"]
+
+      delegate :amount_captured, :payment_intent, to: :stripe_object
+
+      store_accessor :data, :stripe_invoice
       store_accessor :data, :stripe_receipt_url
 
+      def self.sync_payment_intent(id, stripe_account: nil)
+        payment_intent = ::Stripe::PaymentIntent.retrieve({id: id}, {stripe_account: stripe_account}.compact)
+        sync(payment_intent.latest_charge, stripe_account: stripe_account)
+      end
+
       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({id: charge_id, expand: ["balance_transaction", "invoice.total_discount_amounts.discount", "invoice.total_tax_amounts.tax_rate", "refunds"]}, {stripe_account: stripe_account}.compact)
+        object ||= ::Stripe::Charge.retrieve({id: charge_id, expand: EXPAND}, {stripe_account: stripe_account}.compact)
         if object.customer.blank?
           Rails.logger.debug "Stripe Charge #{object.id} does not have a customer"
           return
@@ -17,68 +27,34 @@ module Pay
           return
         end
 
-        refunds = []
-        object.refunds.auto_paging_each { |refund| refunds << refund }
-
         payment_method = object.payment_method_details.try(object.payment_method_details.type)
         attrs = {
+          object: object.to_hash,
           amount: object.amount,
-          amount_captured: object.amount_captured,
           amount_refunded: object.amount_refunded,
           application_fee_amount: object.application_fee_amount,
-          balance_transaction: object.balance_transaction,
           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,
-          discounts: [],
           exp_month: payment_method.try(:exp_month).to_s,
           exp_year: payment_method.try(:exp_year).to_s,
           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: [],
-          refunds: refunds.sort_by! { |r| r["created"] }
+          stripe_receipt_url: object.receipt_url
         }
 
         # Associate charge with subscription if we can
-        if object.invoice
-          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)
+        invoice_payments = ::Stripe::InvoicePayment.list({payment: {type: :payment_intent, payment_intent: object.payment_intent}, status: :paid, expand: ["data.invoice.total_discount_amounts.discount"]}, {stripe_account: stripe_account}.compact)
+        if invoice_payments.any? && (invoice = invoice_payments.first.invoice)
+          attrs[:stripe_invoice] = invoice.to_hash
           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)
-            }
+          attrs[:tax] = invoice.total - invoice.total_excluding_tax.to_i
+          if (subscription = invoice.parent.try(:subscription_details).try(:subscription))
+            attrs[:subscription] = pay_customer.subscriptions.find_by(processor_id: subscription)
           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
@@ -90,16 +66,14 @@ module Pay
         end
       rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique
         try += 1
-        if try <= retries
-          sleep 0.1
-          retry
-        else
-          raise
-        end
+        raise unless try <= retries
+
+        sleep 0.1
+        retry
       end
 
       def api_record
-        ::Stripe::Charge.retrieve({id: processor_id, expand: ["customer", "invoice.subscription"]}, stripe_options)
+        ::Stripe::Charge.retrieve({id: processor_id, expand: EXPAND}, stripe_options)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -116,7 +90,7 @@ module Pay
       def refund!(amount_to_refund, **options)
         amount_to_refund ||= amount
 
-        if invoice_id.present?
+        if stripe_invoice.present?
           description = options.delete(:description) || I18n.t("pay.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))
@@ -130,8 +104,9 @@ module Pay
 
       # 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)
+        raise Pay::Stripe::Error, "no Stripe Invoice on Pay::Charge" if stripe_invoice.blank?
+
+        ::Stripe::CreditNote.create({invoice: stripe_invoice.id}.merge(options), stripe_options)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -141,13 +116,28 @@ module Pay
       # 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)
+        raise Pay::Stripe::Error, "no payment_intent on charge" unless payment_intent.present?
+
+        ::Stripe::PaymentIntent.capture(payment_intent, options, stripe_options)
         self.class.sync(processor_id)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
+      def captured?
+        amount_captured > 0
+      end
+
+      def stripe_invoice
+        if (value = data.dig("stripe_invoice"))
+          ::Stripe::Invoice.construct_from(value)
+        end
+      end
+
+      def stripe_object
+        ::Stripe::Charge.construct_from(object) if object?
+      end
+
       private
 
       # Options for Stripe requests

data/app/models/pay/stripe/customer.rb

@@ -58,8 +58,7 @@ module Pay
       def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
         quantity = options.delete(:quantity)
         opts = {
-          expand: ["pending_setup_intent", "latest_invoice.payment_intent", "latest_invoice.charge"],
-          items: [plan: plan, quantity: quantity]
+          items: [price: plan, quantity: quantity]
         }.merge(options)
 
         # Load the Stripe customer to verify it exists and update payment method if needed
@@ -73,7 +72,8 @@ module Pay
 
         # No trial, payment method requires SCA
         if options[:payment_behavior].to_s != "default_incomplete" && subscription.incomplete?
-          Pay::Payment.new(stripe_sub.latest_invoice.payment_intent).validate
+          payment_intent_id = stripe_sub.latest_invoice.payments.first.payment.payment_intent
+          Pay::Payment.from_id(payment_intent_id).validate
         end
 
         subscription

data/app/models/pay/stripe/subscription.rb

@@ -23,6 +23,7 @@ module Pay
         end
 
         attributes = {
+          object: object.to_hash,
           application_fee_percent: object.application_fee_percent,
           created_at: Time.at(object.created),
           processor_plan: object.items.first.price.id,
@@ -30,12 +31,11 @@ module Pay
           status: object.status,
           stripe_account: pay_customer.stripe_account,
           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),
-          current_period_start: (object.current_period_start ? Time.at(object.current_period_start) : nil),
-          current_period_end: (object.current_period_end ? Time.at(object.current_period_end) : nil)
+          current_period_start: (object.items.first.current_period_start ? Time.at(object.items.first.current_period_start) : nil),
+          current_period_end: (object.items.first.current_period_end ? Time.at(object.items.first.current_period_end) : nil)
         }
 
         # Subscriptions that have ended should have their trial ended at the
@@ -49,13 +49,9 @@ module Pay
           attributes[:trial_ends_at] = Time.at(trial_ended_at)
         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)
+          next if attributes[:metered]
+          attributes[:metered] = true if subscription_item.price.try(:recurring).try(:usage_type) == "metered"
         end
 
         attributes[:ends_at] = if object.ended_at
@@ -66,7 +62,7 @@ module Pay
           Time.at(object.cancel_at)
         elsif object.cancel_at_period_end
           # Subscriptions cancelling in the future
-          Time.at(object.current_period_end)
+          Time.at(object.items.first.current_period_end)
         end
 
         # Sync payment method if directly attached to subscription
@@ -87,7 +83,7 @@ module Pay
           # Any other pause status (or no pause at all) should have nil for start
           if pay_subscription.pause_behavior != attributes[:pause_behavior]
             attributes[:pause_starts_at] = if attributes[:pause_behavior] == "void"
-              Time.at(object.current_period_end)
+              Time.at(object.items.first.current_period_end)
             end
           end
 
@@ -102,8 +98,11 @@ module Pay
         pay_subscription.api_record = 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, stripe_account: pay_subscription.stripe_account)
+        if (invoice = object.try(:latest_invoice))
+          Array(invoice.try(:payments)).each do |invoice_payment|
+            next unless invoice_payment.status == "paid"
+            Pay::Stripe::Charge.sync_payment_intent(invoice_payment.payment.payment_intent, stripe_account: pay_subscription.stripe_account)
+          end
         end
 
         pay_subscription
@@ -121,23 +120,27 @@ module Pay
       def self.expand_options
         {
           expand: [
+            "discounts",
             "default_payment_method",
             "pending_setup_intent",
-            "latest_invoice.payment_intent",
-            "latest_invoice.charge",
-            "latest_invoice.total_discount_amounts.discount",
-            "latest_invoice.total_tax_amounts.tax_rate"
+            "latest_invoice.confirmation_secret",
+            "latest_invoice.payments",
+            "latest_invoice.total_discount_amounts.discount"
           ]
         }
       end
 
+      def stripe_object
+        ::Stripe::Subscription.construct_from(object)
+      end
+
       def api_record(**options)
         @api_record ||= ::Stripe::Subscription.retrieve(options.with_defaults(id: processor_id).merge(expand_options), {stripe_account: stripe_account}.compact)
       end
 
       # Returns a SetupIntent or PaymentIntent client secret for the subscription
       def client_secret
-        api_record&.pending_setup_intent&.client_secret || api_record&.latest_invoice&.payment_intent&.client_secret
+        api_record&.pending_setup_intent&.client_secret || api_record&.latest_invoice&.confirmation_secret&.client_secret
       end
 
       # Sets the default_payment_method on a subscription
@@ -160,7 +163,7 @@ module Pay
           cancel_now!
         else
           @api_record = ::Stripe::Subscription.update(processor_id, {cancel_at_period_end: true}.merge(expand_options), stripe_options)
-          update(ends_at: (on_trial? ? trial_ends_at : Time.at(@api_record.current_period_end)))
+          update(ends_at: (on_trial? ? trial_ends_at : Time.at(@api_record.items.first.current_period_end)))
         end
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
@@ -184,7 +187,7 @@ module Pay
       # 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.delete(:subscription_item_id) || subscription_items&.first&.dig("id")
+        subscription_item_id = options.delete(:subscription_item_id) || subscription_items&.first&.id
         if subscription_item_id
           ::Stripe::SubscriptionItem.update(subscription_item_id, options.merge(quantity: quantity), stripe_options)
           @api_record = nil
@@ -234,7 +237,7 @@ module Pay
         update(
           pause_behavior: behavior,
           pause_resumes_at: (@api_record.pause_collection&.resumes_at ? Time.at(@api_record.pause_collection&.resumes_at) : nil),
-          pause_starts_at: ((behavior == "void") ? Time.at(@api_record.current_period_end) : nil)
+          pause_starts_at: ((behavior == "void") ? Time.at(@api_record.items.first.current_period_end) : nil)
         )
       end
 
@@ -277,6 +280,7 @@ module Pay
       def swap(plan, **options)
         raise ArgumentError, "plan must be a string" unless plan.is_a?(String)
 
+        prorate = options.fetch(:prorate) { true }
         proration_behavior = options.delete(:proration_behavior) || (prorate ? "always_invoice" : "none")
 
         @api_record = ::Stripe::Subscription.update(
@@ -292,8 +296,8 @@ module Pay
         )
 
         # Validate that swap was successful and handle SCA if needed
-        if (payment_intent = @api_record.latest_invoice.payment_intent)
-          Pay::Payment.new(payment_intent).validate
+        if (payment_intent_id = @api_record.latest_invoice.payments.first.payment.payment_intent)
+          Pay::Payment.from_id(payment_intent_id).validate
         end
 
         sync!(object: @api_record)
@@ -301,33 +305,19 @@ module Pay
         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.delete(:subscription_item_id) || metered_subscription_item&.dig("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.delete(:subscription_item_id) || metered_subscription_item&.dig("id")
-        ::Stripe::SubscriptionItem.list_usage_record_summaries(subscription_item_id, options, stripe_options)
+      def subscription_items
+        stripe_object.items
       end
 
       # Returns the first metered subscription item
       def metered_subscription_item
-        subscription_items.find do |subscription_item|
-          subscription_item.dig("price", "recurring", "usage_type") == "metered"
+        subscription_items.auto_paging_each do |subscription_item|
+          return subscription_item if subscription_item.price.try(:recurring).try(:usage_type) == "metered"
         end
       end
 
-      # Returns an upcoming invoice for a subscription
-      def upcoming_invoice(**options)
-        ::Stripe::Invoice.upcoming(options.merge(subscription: processor_id), stripe_options)
+      def preview_invoice(**options)
+        ::Stripe::Invoice.create_preview(options.merge(subscription: processor_id), stripe_options)
       end
 
       # Retries the latest invoice for a Past Due subscription and attempts to pay it

data/app/models/pay/subscription.rb

@@ -27,12 +27,6 @@ module Pay
     # Callbacks
     before_destroy :cancel_if_active
 
-    store_accessor :data, :paddle_update_url
-    store_accessor :data, :paddle_cancel_url
-    store_accessor :data, :subscription_items
-
-    attribute :prorate, :boolean, default: true
-
     # Validations
     validates :name, presence: true
     validates :processor_id, presence: true, uniqueness: {scope: :customer_id, case_sensitive: true}
@@ -58,10 +52,6 @@ module Pay
       reload
     end
 
-    def no_prorate
-      self.prorate = false
-    end
-
     def skip_trial
       self.trial_ends_at = nil
     end

data/config/locales/en.yml

@@ -24,6 +24,7 @@ en:
       subtotal: "Subtotal"
       discount: "Discount"
       tax: "Tax"
+      total: "Total excluding tax"
       total: "Total"
       unit_price: "Unit Price"
       percent_discount: "%{name} (%{percent}% off)"

data/db/migrate/20250415151129_add_object_to_pay_models.rb

@@ -0,0 +1,7 @@
+class AddObjectToPayModels < ActiveRecord::Migration[6.0]
+  def change
+    add_column :pay_charges, :object, Pay::Adapter.json_column_type
+    add_column :pay_customers, :object, Pay::Adapter.json_column_type
+    add_column :pay_subscriptions, :object, Pay::Adapter.json_column_type
+  end
+end

data/lib/pay/receipts.rb

@@ -31,17 +31,13 @@ module Pay
         ]
       ]
 
-      # Unit price is stored with the line item
-      # Negative amounts shouldn't display quantity
-      # Sort by line_items by period_end? oldest to newest
-      if line_items.any?
-        line_items.each do |li|
-          items << [li["description"], li["quantity"], Pay::Currency.format(li["unit_amount"], currency: currency), Pay::Currency.format(li["amount"], currency: currency)]
-
-          Array.wrap(li["discounts"]).each do |discount_id|
-            if (discount = total_discount_amounts.find { |d| d.dig("discount", "id") == discount_id })
-              items << [discount_description(discount), nil, nil, Pay::Currency.format(-discount["amount"], currency: currency)]
-            end
+      if stripe_invoice
+        stripe_invoice.lines.auto_paging_each do |line|
+          items << [line.description, line.quantity, Pay::Currency.format(line.pricing.unit_amount_decimal, currency: line.currency), Pay::Currency.format(line.amount, currency: line.currency)]
+
+          line.discounts.each do |discount_id|
+            discount = stripe_invoice.total_discount_amounts.find { |d| d.discount.id == discount_id }
+            items << [discount_description(discount), nil, nil, Pay::Currency.format(-discount.amount, currency: currency)]
           end
         end
       else
@@ -49,42 +45,47 @@ module Pay
       end
 
       # If no subtotal, we will display the total
-      items << [nil, nil, I18n.t("pay.line_items.subtotal"), Pay::Currency.format(subtotal || amount, currency: currency)]
+      items << [nil, nil, I18n.t("pay.line_items.subtotal"), Pay::Currency.format(stripe_invoice&.subtotal || amount, currency: currency)]
 
       # Discounts on the invoice
-      Array.wrap(discounts).each do |discount_id|
-        if (discount = total_discount_amounts.find { |d| d.dig("discount", "id") == discount_id })
-          items << [nil, nil, discount_description(discount), Pay::Currency.format(-discount["amount"], currency: currency)]
-        end
+      stripe_invoice&.discounts&.each do |discount_id|
+        discount = stripe_invoice.total_discount_amounts.find { |d| d.discount.id == discount_id }
+        items << [nil, nil, discount_description(discount), Pay::Currency.format(-discount.amount, currency: currency)]
+      end
+
+      # Total excluding tax
+      if stripe_invoice
+        items << [nil, nil, I18n.t("pay.line_items.total"), Pay::Currency.format(stripe_invoice.total_excluding_tax, currency: currency)]
       end
 
       # Tax rates
-      Array.wrap(total_tax_amounts).each do |tax_amount|
-        next if tax_amount["amount"].zero?
-        items << [nil, nil, tax_description(tax_amount), Pay::Currency.format(tax_amount["amount"], currency: currency)]
+      stripe_invoice&.total_taxes&.each do |tax|
+        next if tax.amount.zero?
+        # tax_rate = ::Stripe::TaxRate.retrieve(tax.tax_rate_details.tax_rate)
+        items << [nil, nil, I18n.t("pay.line_items.tax"), Pay::Currency.format(tax.amount, currency: currency)]
       end
 
+      # Total
       items << [nil, nil, I18n.t("pay.line_items.total"), Pay::Currency.format(amount, currency: currency)]
       items
     end
 
     def discount_description(discount)
-      coupon = discount.dig("discount", "coupon")
-      name = coupon.dig("name")
+      coupon = discount.discount.coupon
+      name = coupon.name
 
-      if (percent = coupon["percent_off"])
+      if (percent = coupon.percent_off)
         I18n.t("pay.line_items.percent_discount", name: name, percent: ActiveSupport::NumberHelper.number_to_rounded(percent, strip_insignificant_zeros: true))
       else
-        I18n.t("pay.line_items.amount_discount", name: name, amount: Pay::Currency.format(coupon["amount_off"], currency: coupon["currency"]))
+        I18n.t("pay.line_items.amount_discount", name: name, amount: Pay::Currency.format(coupon.amount_off, currency: coupon.currency))
       end
     end
 
-    def tax_description(tax_amount)
-      tax_rate = tax_amount["tax_rate"]
-      percent = "#{ActiveSupport::NumberHelper.number_to_rounded(tax_rate["percentage"], strip_insignificant_zeros: true)}%"
-      percent += " inclusive" if tax_rate["inclusive"]
-      "#{tax_rate["display_name"]} - #{tax_rate["jurisdiction"]} (#{percent})"
-    end
+    # def tax_description(tax_rate)
+    #   percent = "#{ActiveSupport::NumberHelper.number_to_rounded(tax_rate.percentage, strip_insignificant_zeros: true)}%"
+    #   percent += " inclusive" if tax_rate.inclusive
+    #   "#{tax_rate.display_name} - #{tax_rate.jurisdiction} (#{percent})"
+    # end
 
     def receipt_line_items
       line_items = pdf_line_items
@@ -94,15 +95,15 @@ module Pay
 
       if refunded?
         # If we have a list of individual refunds, add each entry
-        if refunds&.any?
-          refunds.each do |refund|
-            next unless refund["status"] == "succeeded"
-            refunded_at = Time.at(refund["created"]).to_date
-            line_items << [nil, nil, I18n.t("pay.receipt.refunded_on", date: I18n.l(refunded_at, format: :long)), Pay::Currency.format(refund["amount"], currency: refund["currency"])]
-          end
-        else
-          line_items << [nil, nil, I18n.t("pay.receipt.refunded"), Pay::Currency.format(amount_refunded, currency: currency)]
-        end
+        # if refunds&.any?
+        #   refunds.each do |refund|
+        #     next unless refund["status"] == "succeeded"
+        #     refunded_at = Time.at(refund["created"]).to_date
+        #     line_items << [nil, nil, I18n.t("pay.receipt.refunded_on", date: I18n.l(refunded_at, format: :long)), Pay::Currency.format(refund["amount"], currency: refund["currency"])]
+        #   end
+        # else
+        line_items << [nil, nil, I18n.t("pay.receipt.refunded"), Pay::Currency.format(amount_refunded, currency: currency)]
+        # end
       end
 
       line_items

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

@@ -11,6 +11,18 @@ module Pay
 
           stripe_customer = pay_customer.api_record
 
+          attributes = {
+            object: stripe_customer.to_hash
+          }
+
+          # Sync invoice credit balance and currency
+          if stripe_customer.invoice_credit_balance.present?
+            attributes[:invoice_credit_balance] = stripe_customer.invoice_credit_balance
+            attributes[:currency] = stripe_customer.currency
+          end
+
+          pay_customer.update(attributes)
+
           # Sync default card
           if (payment_method_id = stripe_customer.invoice_settings.default_payment_method)
             Pay::Stripe::PaymentMethod.sync(payment_method_id, stripe_account: event.try(:account))
@@ -19,14 +31,6 @@ module Pay
             # No default payment method set
             pay_customer.payment_methods.update_all(default: false)
           end
-
-          # Sync invoice credit balance and currency
-          if stripe_customer.invoice_credit_balance.present?
-            pay_customer.update(
-              invoice_credit_balance: stripe_customer.invoice_credit_balance,
-              currency: stripe_customer.currency
-            )
-          end
         end
       end
     end

data/lib/pay/stripe.rb

@@ -1,7 +1,6 @@
 module Pay
   module Stripe
     class Error < Pay::Error
-      delegate :message, to: :cause
     end
 
     module Webhooks
@@ -27,7 +26,7 @@ module Pay
 
     extend Env
 
-    REQUIRED_VERSION = "~> 13"
+    REQUIRED_VERSION = "~> 15"
 
     # A list of database model names that include Pay
     # Used for safely looking up models with client_reference_id

data/lib/pay/version.rb

@@ -1,3 +1,3 @@
 module Pay
-  VERSION = "9.0.1"
+  VERSION = "10.0.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pay
 version: !ruby/object:Gem::Version
-  version: 9.0.1
+  version: 10.0.1
 platform: ruby
 authors:
 - Jason Charnes
@@ -9,7 +9,7 @@ authors:
 - Collin Jilbert
 bindir: bin
 cert_chain: []
-date: 2025-03-27 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 7.0.0
 description: Stripe, Paddle, and Braintree payments for Ruby on Rails apps
 email:
 - jason@thecharnes.com
@@ -99,6 +99,7 @@ files:
 - config/locales/en.yml
 - config/routes.rb
 - db/migrate/1_create_pay_tables.rb
+- db/migrate/20250415151129_add_object_to_pay_models.rb
 - db/migrate/2_add_pay_sti_columns.rb
 - lib/generators/pay/email_views_generator.rb
 - lib/generators/pay/views_generator.rb
@@ -178,7 +179,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.6
+rubygems_version: 3.6.8
 specification_version: 4
 summary: Payments engine for Ruby on Rails
 test_files: []