pay 7.1.0 → 7.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 731897282e09b738950bdef4b213ef808bc39cae0bbc84c43840de743e9611f4
-  data.tar.gz: 44624d892463cf3e40206fba9c812005ff4e8fab13642ed932d966c3ec02dafb
+  metadata.gz: 5976a641a8e7a7eafa74d343fa1bdb2ab4c1b07d234d44e1efafba5b9b34b34d
+  data.tar.gz: 57f00237ae29f1a611f714f473a05de859277cdc5bb515741cefa5f75426b393
 SHA512:
-  metadata.gz: d4d24fca5a2619c32d5b0a6e45b2ca5ca20654719bca47bcc377799716e4aeb54a2059fe05ea522db24394ce366c6181fb0ba4051065d1a0039f48236ff48dca
-  data.tar.gz: 5131748acaed2da28332e6d853b66b086c1354eafc7880669ae291cec664bbed35dfa194e7ddcb4060097e42fc18f5c0e2e5f69cf1a4fe7c40501926f2b208ea
+  metadata.gz: '0396532d1af2f80400facc5f6294d7b2f6bcbeab373d004a241e05eb8213a4c91c09ae3fd28655501fec298cfb75520c8506ce697629f41e21cfc961cb76b7bc'
+  data.tar.gz: 6e0a26efaf1eb11347ab34c2eac50a25ed59d4f6b9b8eaa11707eb6f3b0d72d4708c3dcb399cbf915999343fd35625397c00c800f90853634db8da00c24643a7

data/app/models/pay/charge.rb

@@ -45,7 +45,7 @@ module Pay
 
     # Helpers for payment processors
     %w[braintree stripe paddle_billing paddle_classic fake_processor].each do |processor_name|
-      define_method "#{processor_name}?" do
+      define_method :"#{processor_name}?" do
         customer.processor == processor_name
       end
 

data/app/models/pay/customer.rb

@@ -28,7 +28,7 @@ module Pay
     %w[stripe braintree paddle_billing paddle_classic fake_processor].each do |processor_name|
       scope processor_name, -> { where(processor: processor_name) }
 
-      define_method "#{processor_name}?" do
+      define_method :"#{processor_name}?" do
         processor == processor_name
       end
     end

data/app/models/pay/subscription.rb

@@ -44,7 +44,7 @@ module Pay
 
     # Helper methods for payment processors
     %w[braintree stripe paddle_billing paddle_classic fake_processor].each do |processor_name|
-      define_method "#{processor_name}?" do
+      define_method :"#{processor_name}?" do
         customer.processor == processor_name
       end
 

data/lib/pay/braintree/billable.rb

@@ -265,7 +265,7 @@ module Pay
           end
 
           # Retrieve payment method details from transaction
-          payment_method = transaction.send("#{attribute_name}_details")
+          payment_method = transaction.send(:"#{attribute_name}_details")
 
           {
             payment_method_type: :card,

data/lib/pay/paddle_billing/subscription.rb

@@ -59,6 +59,10 @@ module Pay
           attributes[:trial_ends_at] = Time.parse(object.next_billed_at)
         when "paused"
           attributes[:pause_starts_at] = Time.parse(object.paused_at)
+        when "active", "past_due"
+          attributes[:trial_ends_at] = nil
+          attributes[:pause_starts_at] = nil
+          attributes[:ends_at] = nil
         end
 
         case object.scheduled_change&.action

data/lib/pay/paddle_classic/subscription.rb

@@ -44,12 +44,15 @@ module Pay
           status: object.state || object.status
         }
 
-        # If paused or delete while on trial, set ends_at to match
         case attributes[:status]
         when "trialing"
           attributes[:trial_ends_at] = Time.zone.parse(object.next_bill_date)
           attributes[:ends_at] = nil
+        when "active", "past_due"
+          attributes[:trial_ends_at] = nil
+          attributes[:ends_at] = nil
         when "paused", "deleted"
+          # If paused or delete while on trial, set ends_at to match
           attributes[:trial_ends_at] = nil
           attributes[:ends_at] = Time.zone.parse(object.next_bill_date)
         end

data/lib/pay/stripe/charge.rb

@@ -29,7 +29,7 @@ module Pay
         refunds = []
         object.refunds.auto_paging_each { |refund| refunds << refund }
 
-        payment_method = object.payment_method_details.send(object.payment_method_details.type)
+        payment_method = object.payment_method_details.try(object.payment_method_details.type)
         attrs = {
           amount: object.amount,
           amount_captured: object.amount_captured,

data/lib/pay/stripe/payment_method.rb

@@ -60,7 +60,7 @@ module Pay
 
       # Extracts payment method details from a Stripe::PaymentMethod object
       def self.extract_attributes(payment_method)
-        details = payment_method.send(payment_method.type)
+        details = payment_method.try(payment_method.type)
 
         {
           payment_method_type: payment_method.type,

data/lib/pay/stripe/subscription.rb

@@ -342,13 +342,13 @@ module Pay
       # 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, metered_subscription_item&.dig("id"))
+        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.fetch(:subscription_item_id, metered_subscription_item&.dig("id"))
+        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)
       end
 

data/lib/pay/version.rb

@@ -1,3 +1,3 @@
 module Pay
-  VERSION = "7.1.0"
+  VERSION = "7.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pay
 version: !ruby/object:Gem::Version
-  version: 7.1.0
+  version: 7.1.1
 platform: ruby
 authors:
 - Jason Charnes
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-06 00:00:00.000000000 Z
+date: 2024-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -104,14 +104,6 @@ files:
 - lib/pay/fake_processor/merchant.rb
 - lib/pay/fake_processor/payment_method.rb
 - lib/pay/fake_processor/subscription.rb
-- lib/pay/lemon_squeezy.rb
-- lib/pay/lemon_squeezy/billable.rb
-- lib/pay/lemon_squeezy/charge.rb
-- lib/pay/lemon_squeezy/error.rb
-- lib/pay/lemon_squeezy/payment_method.rb
-- lib/pay/lemon_squeezy/subscription.rb
-- lib/pay/lemon_squeezy/webhooks/subscription.rb
-- lib/pay/lemon_squeezy/webhooks/transaction_completed.rb
 - lib/pay/nano_id.rb
 - lib/pay/paddle_billing.rb
 - lib/pay/paddle_billing/billable.rb
@@ -184,7 +176,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Payments engine for Ruby on Rails

data/lib/pay/lemon_squeezy/billable.rb

@@ -1,90 +0,0 @@
-module Pay
-  module PaddleBilling
-    class Billable
-      attr_reader :pay_customer
-
-      delegate :processor_id,
-        :processor_id?,
-        :email,
-        :customer_name,
-        :card_token,
-        to: :pay_customer
-
-      def initialize(pay_customer)
-        @pay_customer = pay_customer
-      end
-
-      def customer_attributes
-        {email: email, name: customer_name}
-      end
-
-      # Retrieves a Paddle::Customer object
-      #
-      # Finds an existing Paddle::Customer if processor_id exists
-      # Creates a new Paddle::Customer using `email` and `customer_name` if empty processor_id
-      #
-      # Returns a Paddle::Customer object
-      def customer
-        if processor_id?
-          ::Paddle::Customer.retrieve(id: processor_id)
-        else
-          sc = ::Paddle::Customer.create(email: email, name: customer_name)
-          pay_customer.update!(processor_id: sc.id)
-          sc
-        end
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      # Syncs name and email to Paddle::Customer
-      # You can also pass in other attributes that will be merged into the default attributes
-      def update_customer!(**attributes)
-        customer unless processor_id?
-        attrs = customer_attributes.merge(attributes)
-        ::Paddle::Customer.update(id: processor_id, **attrs)
-      end
-
-      def charge(amount, options = {})
-        return Pay::Error unless options
-
-        items = options[:items]
-        opts = options.except(:items).merge(customer_id: processor_id)
-        transaction = ::Paddle::Transaction.create(items: items, **opts)
-
-        attrs = {
-          amount: transaction.details.totals.grand_total,
-          created_at: transaction.created_at,
-          currency: transaction.currency_code,
-          metadata: transaction.details.line_items&.first&.id
-        }
-
-        charge = pay_customer.charges.find_or_initialize_by(processor_id: transaction.id)
-        charge.update(attrs)
-        charge
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
-        # pass
-      end
-
-      # Paddle does not use payment method tokens. The method signature has it here
-      # to have a uniform API with the other payment processors.
-      def add_payment_method(token = nil, default: true)
-        Pay::PaddleBilling::PaymentMethod.sync(pay_customer: pay_customer)
-      end
-
-      def trial_end_date(subscription)
-        return unless subscription.state == "trialing"
-        Time.zone.parse(subscription.next_payment[:date]).end_of_day
-      end
-
-      def processor_subscription(subscription_id, options = {})
-        ::Paddle::Subscription.retrieve(id: subscription_id, **options)
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-    end
-  end
-end

data/lib/pay/lemon_squeezy/charge.rb

@@ -1,68 +0,0 @@
-module Pay
-  module PaddleBilling
-    class Charge
-      attr_reader :pay_charge
-
-      delegate :processor_id, :customer, to: :pay_charge
-
-      def initialize(pay_charge)
-        @pay_charge = pay_charge
-      end
-
-      def self.sync(charge_id, object: nil, try: 0, retries: 1)
-        # Skip loading the latest charge details from the API if we already have it
-        object ||= ::Paddle::Transaction.retrieve(id: charge_id)
-
-        # Ignore transactions that aren't completed
-        return unless object.status == "completed"
-
-        # Ignore charges without a Customer
-        return if object.customer_id.blank?
-
-        pay_customer = Pay::Customer.find_by(processor: :paddle_billing, processor_id: object.customer_id)
-        return unless pay_customer
-
-        # Ignore transactions that are payment method changes
-        # But update the customer's payment method
-        if object.origin == "subscription_payment_method_change"
-          Pay::PaddleBilling::PaymentMethod.sync(pay_customer: pay_customer, attributes: object.payments.first)
-          return
-        end
-
-        attrs = {
-          amount: object.details.totals.grand_total,
-          created_at: object.created_at,
-          currency: object.currency_code,
-          metadata: object.details.line_items&.first&.id,
-          subscription: pay_customer.subscriptions.find_by(processor_id: object.subscription_id)
-        }
-
-        if object.payment
-          case object.payment.method_details.type.downcase
-          when "card"
-            attrs[:payment_method_type] = "card"
-            attrs[:brand] = details.card.type
-            attrs[:exp_month] = details.card.expiry_month
-            attrs[:exp_year] = details.card.expiry_year
-            attrs[:last4] = details.card.last4
-          when "paypal"
-            attrs[:payment_method_type] = "paypal"
-          end
-
-          # Update customer's payment method
-          Pay::PaddleBilling::PaymentMethod.sync(pay_customer: pay_customer, attributes: object.payments.first)
-        end
-
-        # Update or create the charge
-        if (pay_charge = pay_customer.charges.find_by(processor_id: object.id))
-          pay_charge.with_lock do
-            pay_charge.update!(attrs)
-          end
-          pay_charge
-        else
-          pay_customer.charges.create!(attrs.merge(processor_id: object.id))
-        end
-      end
-    end
-  end
-end

data/lib/pay/lemon_squeezy/error.rb

@@ -1,7 +0,0 @@
-module Pay
-  module PaddleBilling
-    class Error < Pay::Error
-      delegate :message, to: :cause
-    end
-  end
-end

data/lib/pay/lemon_squeezy/payment_method.rb

@@ -1,40 +0,0 @@
-module Pay
-  module PaddleBilling
-    class PaymentMethod
-      attr_reader :pay_payment_method
-
-      delegate :customer, :processor_id, to: :pay_payment_method
-
-      def self.sync(pay_customer:, attributes:)
-        details = attributes.method_details
-        attrs = {
-          type: details.type.downcase
-        }
-
-        case details.type.downcase
-        when "card"
-          attrs[:brand] = details.card.type
-          attrs[:last4] = details.card.last4
-          attrs[:exp_month] = details.card.expiry_month
-          attrs[:exp_year] = details.card.expiry_year
-        end
-
-        payment_method = pay_customer.payment_methods.find_or_initialize_by(processor_id: attributes.stored_payment_method_id)
-        payment_method.update!(attrs)
-        payment_method
-      end
-
-      def initialize(pay_payment_method)
-        @pay_payment_method = pay_payment_method
-      end
-
-      # Sets payment method as default
-      def make_default!
-      end
-
-      # Remove payment method
-      def detach
-      end
-    end
-  end
-end

data/lib/pay/lemon_squeezy/subscription.rb

@@ -1,185 +0,0 @@
-module Pay
-  module PaddleBilling
-    class Subscription
-      attr_reader :pay_subscription
-
-      delegate :active?,
-        :canceled?,
-        :on_grace_period?,
-        :on_trial?,
-        :ends_at,
-        :name,
-        :owner,
-        :pause_starts_at,
-        :pause_starts_at?,
-        :processor_id,
-        :processor_plan,
-        :processor_subscription,
-        :prorate,
-        :prorate?,
-        :quantity,
-        :quantity?,
-        :trial_ends_at,
-        to: :pay_subscription
-
-      def self.sync_from_transaction(transaction_id)
-        transaction = ::Paddle::Transaction.retrieve(id: transaction_id)
-        sync(transaction.subscription_id) if transaction.subscription_id
-      end
-
-      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 ||= ::Paddle::Subscription.retrieve(id: subscription_id)
-
-        pay_customer = Pay::Customer.find_by(processor: :paddle_billing, processor_id: object.customer_id)
-        return unless pay_customer
-
-        attributes = {
-          current_period_end: object.current_billing_period&.ends_at,
-          current_period_start: object.current_billing_period&.starts_at,
-          ends_at: (object.canceled_at ? Time.parse(object.canceled_at) : nil),
-          metadata: object.custom_data,
-          paddle_cancel_url: object.management_urls&.cancel,
-          paddle_update_url: object.management_urls&.update_payment_method,
-          pause_starts_at: (object.paused_at ? Time.parse(object.paused_at) : nil),
-          status: object.status
-        }
-
-        if object.items&.first
-          item = object.items.first
-          attributes[:processor_plan] = item.price.id
-          attributes[:quantity] = item.quantity
-        end
-
-        case attributes[:status]
-        when "canceled"
-          # Remove payment methods since customer cannot be reused after cancelling
-          Pay::PaymentMethod.where(customer_id: object.customer_id).destroy_all
-        when "trialing"
-          attributes[:trial_ends_at] = Time.parse(object.next_billed_at)
-        when "paused"
-          attributes[:pause_starts_at] = Time.parse(object.paused_at)
-        end
-
-        case object.scheduled_change&.action
-        when "cancel"
-          attributes[:ends_at] = Time.parse(object.scheduled_change.effective_at)
-        when "pause"
-          attributes[:pause_starts_at] = Time.parse(object.scheduled_change.effective_at)
-        when "resume"
-          attributes[:pause_resumes_at] = Time.parse(object.scheduled_change.effective_at)
-        end
-
-        # Update or create the subscription
-        if (pay_subscription = pay_customer.subscriptions.find_by(processor_id: subscription_id))
-          pay_subscription.with_lock do
-            pay_subscription.update!(attributes)
-          end
-          pay_subscription
-        else
-          pay_customer.subscriptions.create!(attributes.merge(name: name, processor_id: subscription_id))
-        end
-      end
-
-      def initialize(pay_subscription)
-        @pay_subscription = pay_subscription
-      end
-
-      def subscription(**options)
-        @paddle_billing_subscription ||= ::Paddle::Subscription.retrieve(id: processor_id, **options)
-      end
-
-      # Get a transaction to update payment method
-      def payment_method_transaction
-        ::Paddle::Subscription.get_transaction(id: processor_id)
-      end
-
-      # If a subscription is paused, cancel immediately
-      # Otherwise, cancel at period end
-      def cancel(**options)
-        return if canceled?
-
-        response = ::Paddle::Subscription.cancel(
-          id: processor_id,
-          effective_from: options.fetch(:effective_from, (paused? ? "immediately" : "next_billing_period"))
-        )
-        pay_subscription.update(
-          status: response.status,
-          ends_at: response.scheduled_change.effective_at
-        )
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      def cancel_now!(**options)
-        cancel(options.merge(effective_from: "immediately"))
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      def change_quantity(quantity, **options)
-        items = [{
-          price_id: processor_plan,
-          quantity: quantity
-        }]
-
-        ::Paddle::Subscription.update(id: processor_id, items: items, proration_billing_mode: "prorated_immediately")
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      # A subscription could be set to cancel or pause in the future
-      # It is considered on grace period until the cancel or pause time begins
-      def on_grace_period?
-        (canceled? && Time.current < ends_at) || (paused? && pause_starts_at? && Time.current < pause_starts_at)
-      end
-
-      def paused?
-        pay_subscription.status == "paused"
-      end
-
-      def pause
-        response = ::Paddle::Subscription.pause(id: processor_id)
-        pay_subscription.update!(status: :paused, pause_starts_at: response.scheduled_change.effective_at)
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      def resumable?
-        paused?
-      end
-
-      def resume
-        unless resumable?
-          raise StandardError, "You can only resume paused subscriptions."
-        end
-
-        # Paddle Billing API only allows "resuming" subscriptions when they are paused
-        # So cancel the scheduled change if it is in the future
-        if paused? && pause_starts_at? && Time.current < pause_starts_at
-          ::Paddle::Subscription.update(id: processor_id, scheduled_change: nil)
-        else
-          ::Paddle::Subscription.resume(id: processor_id, effective_from: "immediately")
-        end
-
-        pay_subscription.update(status: :active, pause_starts_at: nil)
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      def swap(plan, **options)
-        items = [{
-          price_id: plan,
-          quantity: quantity || 1
-        }]
-
-        ::Paddle::Subscription.update(id: processor_id, items: items, proration_billing_mode: "prorated_immediately")
-        pay_subscription.update(processor_plan: plan, ends_at: nil, status: :active)
-      end
-
-      # Retries the latest invoice for a Past Due subscription
-      def retry_failed_payment
-      end
-    end
-  end
-end

data/lib/pay/lemon_squeezy/webhooks/subscription.rb

@@ -1,11 +0,0 @@
-module Pay
-  module PaddleBilling
-    module Webhooks
-      class Subscription
-        def call(event)
-          Pay::PaddleBilling::Subscription.sync(event.id, object: event)
-        end
-      end
-    end
-  end
-end

data/lib/pay/lemon_squeezy/webhooks/transaction_completed.rb

@@ -1,11 +0,0 @@
-module Pay
-  module PaddleBilling
-    module Webhooks
-      class TransactionCompleted
-        def call(event)
-          Pay::PaddleBilling::Charge.sync(event.id)
-        end
-      end
-    end
-  end
-end

data/lib/pay/lemon_squeezy.rb

@@ -1,138 +0,0 @@
-module Pay
-  module LemonSqueezy
-    autoload :Billable, "pay/stripe/billable"
-    autoload :Charge, "pay/stripe/charge"
-    autoload :Error, "pay/stripe/error"
-    autoload :Merchant, "pay/stripe/merchant"
-    autoload :PaymentMethod, "pay/stripe/payment_method"
-    autoload :Subscription, "pay/stripe/subscription"
-
-    module Webhooks
-      autoload :AccountUpdated, "pay/stripe/webhooks/account_updated"
-      autoload :ChargeRefunded, "pay/stripe/webhooks/charge_refunded"
-      autoload :ChargeSucceeded, "pay/stripe/webhooks/charge_succeeded"
-      autoload :CheckoutSessionCompleted, "pay/stripe/webhooks/checkout_session_completed"
-      autoload :CheckoutSessionAsyncPaymentSucceeded, "pay/stripe/webhooks/checkout_session_async_payment_succeeded"
-      autoload :CustomerDeleted, "pay/stripe/webhooks/customer_deleted"
-      autoload :CustomerUpdated, "pay/stripe/webhooks/customer_updated"
-      autoload :PaymentActionRequired, "pay/stripe/webhooks/payment_action_required"
-      autoload :PaymentFailed, "pay/stripe/webhooks/payment_failed"
-      autoload :PaymentIntentSucceeded, "pay/stripe/webhooks/payment_intent_succeeded"
-      autoload :PaymentMethodAttached, "pay/stripe/webhooks/payment_method_attached"
-      autoload :PaymentMethodDetached, "pay/stripe/webhooks/payment_method_detached"
-      autoload :PaymentMethodUpdated, "pay/stripe/webhooks/payment_method_updated"
-      autoload :SubscriptionCreated, "pay/stripe/webhooks/subscription_created"
-      autoload :SubscriptionDeleted, "pay/stripe/webhooks/subscription_deleted"
-      autoload :SubscriptionRenewing, "pay/stripe/webhooks/subscription_renewing"
-      autoload :SubscriptionUpdated, "pay/stripe/webhooks/subscription_updated"
-      autoload :SubscriptionTrialWillEnd, "pay/stripe/webhooks/subscription_trial_will_end"
-    end
-
-    extend Env
-
-    REQUIRED_VERSION = "~> 1"
-
-    def self.enabled?
-      return false unless Pay.enabled_processors.include?(:lemonsqueezy) && defined?(::Lemonzsqueezy)
-
-      Pay::Engine.version_matches?(required: REQUIRED_VERSION, current: ::Lemonsqueezy::VERSION) || (raise "[Pay] lemonsqueezy gem must be version #{REQUIRED_VERSION}")
-    end
-
-    def self.setup
-      ::Stripe.api_key = private_key
-
-      # Used by Stripe to identify Pay for support
-      ::Stripe.set_app_info("PayRails", partner_id: "pp_partner_IqhY0UExnJYLxg", version: Pay::VERSION, url: "https://github.com/pay-rails/pay")
-
-      # Automatically retry requests that fail
-      # This automatically includes idempotency keys in the request to guarantee that retires are safe
-      # https://github.com/stripe/stripe-ruby#configuring-automatic-retries
-      ::Stripe.max_network_retries = 2
-    end
-
-    def self.public_key
-      find_value_by_name(:stripe, :public_key)
-    end
-
-    def self.private_key
-      find_value_by_name(:stripe, :private_key)
-    end
-
-    def self.signing_secret
-      find_value_by_name(:stripe, :signing_secret)
-    end
-
-    def self.configure_webhooks
-      Pay::Webhooks.configure do |events|
-        # Listen to the charge event to make sure we get non-subscription
-        # purchases as well. Invoice is only for subscriptions and manual creation
-        # so it does not include individual charges.
-        events.subscribe "stripe.charge.succeeded", Pay::Stripe::Webhooks::ChargeSucceeded.new
-        events.subscribe "stripe.charge.refunded", Pay::Stripe::Webhooks::ChargeRefunded.new
-
-        events.subscribe "stripe.payment_intent.succeeded", Pay::Stripe::Webhooks::PaymentIntentSucceeded.new
-
-        # Warn user of upcoming charges for their subscription. This is handy for
-        # notifying annual users their subscription will renew shortly.
-        # This probably should be ignored for monthly subscriptions.
-        events.subscribe "stripe.invoice.upcoming", Pay::Stripe::Webhooks::SubscriptionRenewing.new
-
-        # Payment action is required to process an invoice
-        events.subscribe "stripe.invoice.payment_action_required", Pay::Stripe::Webhooks::PaymentActionRequired.new
-
-        # If an invoice payment fails, we want to notify the user via email to update their payment details
-        events.subscribe "stripe.invoice.payment_failed", Pay::Stripe::Webhooks::PaymentFailed.new
-
-        # If a subscription is manually created on Stripe, we want to sync
-        events.subscribe "stripe.customer.subscription.created", Pay::Stripe::Webhooks::SubscriptionCreated.new
-
-        # If the plan, quantity, or trial ending date is updated on Stripe, we want to sync
-        events.subscribe "stripe.customer.subscription.updated", Pay::Stripe::Webhooks::SubscriptionUpdated.new
-
-        # When a customers subscription is canceled, we want to update our records
-        events.subscribe "stripe.customer.subscription.deleted", Pay::Stripe::Webhooks::SubscriptionDeleted.new
-
-        # When a customers subscription trial period is 3 days from ending or ended immediately this event is fired
-        events.subscribe "stripe.customer.subscription.trial_will_end", Pay::Stripe::Webhooks::SubscriptionTrialWillEnd.new
-
-        # Monitor changes for customer's default card changing and invoice credit updates
-        events.subscribe "stripe.customer.updated", Pay::Stripe::Webhooks::CustomerUpdated.new
-
-        # If a customer was deleted in Stripe, their subscriptions should be cancelled
-        events.subscribe "stripe.customer.deleted", Pay::Stripe::Webhooks::CustomerDeleted.new
-
-        # If a customer's payment source was deleted in Stripe, we should update as well
-        events.subscribe "stripe.payment_method.attached", Pay::Stripe::Webhooks::PaymentMethodAttached.new
-        events.subscribe "stripe.payment_method.updated", Pay::Stripe::Webhooks::PaymentMethodUpdated.new
-        events.subscribe "stripe.payment_method.card_automatically_updated", Pay::Stripe::Webhooks::PaymentMethodUpdated.new
-        events.subscribe "stripe.payment_method.detached", Pay::Stripe::Webhooks::PaymentMethodDetached.new
-
-        # If an account is updated in stripe, we should update it as well
-        events.subscribe "stripe.account.updated", Pay::Stripe::Webhooks::AccountUpdated.new
-
-        # Handle subscriptions in Stripe Checkout Sessions
-        events.subscribe "stripe.checkout.session.completed", Pay::Stripe::Webhooks::CheckoutSessionCompleted.new
-        events.subscribe "stripe.checkout.session.async_payment_succeeded", Pay::Stripe::Webhooks::CheckoutSessionAsyncPaymentSucceeded.new
-      end
-    end
-
-    def self.to_client_reference_id(record)
-      raise ArgumentError, "#{record.class.name} does not include Pay. Allowed models: #{model_names.to_a.join(", ")}" unless model_names.include?(record.class.name)
-      [record.class.name, record.id].join("_")
-    end
-
-    def self.find_by_client_reference_id(client_reference_id)
-      # If there is a client reference ID, make sure we have a Pay::Customer record
-      # client_reference_id should be in the format of "User/1"
-      model_name, id = client_reference_id.split("_", 2)
-
-      # Only allow model names that use Pay
-      return unless model_names.include?(model_name)
-
-      model_name.constantize.find(id)
-    rescue ActiveRecord::RecordNotFound
-      Rails.logger.error "[Pay] Unable to locate record with: #{client_reference_id}"
-      nil
-    end
-  end
-end