pay 11.7.2 → 12.0.0

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

@@ -1,80 +1,82 @@
 module Pay
   module LemonSqueezy
     class Charge < Pay::Charge
+      extend Pay::Sync
+
       # LemonSqueezy uses Order for one-time payments and Order + Subscription + SubscriptionInvoice for subscriptions
+      # Charges are stored with a "order:123" or "subscription_invoice:123" processor_id so both can be synced by ID
 
-      def self.sync_order(order_id, object: nil, try: 0, retries: 1)
-        object ||= ::LemonSqueezy::Order.retrieve(id: order_id)
+      def self.sync(processor_id, object: nil)
+        type, id = processor_id.split(":", 2)
+        case type
+        when "order"
+          sync_order(id, object: object)
+        when "subscription_invoice"
+          sync_subscription_invoice(id, object: object)
+        end
+      end
 
-        pay_customer = Pay::LemonSqueezy::Customer.find_by(processor_id: object.customer_id)
-        return unless pay_customer
+      def self.sync_order(order_id, object: nil)
+        sync_with_retries do
+          order = object || ::LemonSqueezy::Order.retrieve(id: order_id)
+          return unless (pay_customer = find_pay_customer(order.customer_id))
 
-        processor_id = "order:#{object.id}"
-        attributes = {
-          processor_id: processor_id,
-          currency: object.currency,
-          subtotal: object.subtotal,
-          tax: object.tax,
-          amount: object.total,
-          amount_refunded: object.refunded_amount,
-          created_at: (object.created_at ? Time.parse(object.created_at) : nil),
-          updated_at: (object.updated_at ? Time.parse(object.updated_at) : nil)
-        }
+          processor_id = "order:#{order.id}"
+          attributes = {
+            processor_id: processor_id,
+            currency: order.currency,
+            subtotal: order.subtotal,
+            tax: order.tax,
+            amount: order.total,
+            amount_refunded: order.refunded_amount,
+            created_at: (order.created_at ? Time.parse(order.created_at) : nil),
+            updated_at: (order.updated_at ? Time.parse(order.updated_at) : nil)
+          }
 
-        # Update or create the charge
-        if (pay_charge = find_by(customer: pay_customer, processor_id: processor_id))
-          pay_charge.with_lock { pay_charge.update!(attributes) }
-          pay_charge
-        else
-          create!(attributes.merge(customer: pay_customer, processor_id: processor_id))
+          # Update or create the charge
+          if (pay_charge = find_by(customer: pay_customer, processor_id: processor_id))
+            pay_charge.with_lock { pay_charge.update!(attributes) }
+            pay_charge
+          else
+            create!(attributes.merge(customer: pay_customer, processor_id: processor_id))
+          end
         end
       end
 
       def self.sync_subscription_invoice(subscription_invoice_id, object: nil)
-        # Skip loading the latest subscription invoice details from the API if we already have it
-        object ||= ::LemonSqueezy::SubscriptionInvoice.retrieve(id: subscription_invoice_id)
-
-        pay_customer = Pay::LemonSqueezy::Customer.find_by(processor_id: object.customer_id)
-        return unless pay_customer
+        sync_with_retries do
+          invoice = object || ::LemonSqueezy::SubscriptionInvoice.retrieve(id: subscription_invoice_id)
+          return unless (pay_customer = find_pay_customer(invoice.customer_id))
 
-        processor_id = "subscription_invoice:#{object.id}"
-        subscription = Pay::LemonSqueezy::Subscription.find_by(processor_id: object.subscription_id)
-        attributes = {
-          processor_id: processor_id,
-          currency: object.currency,
-          amount: object.total,
-          amount_refunded: object.refunded_amount,
-          subtotal: object.subtotal,
-          tax: object.tax,
-          subscription: subscription,
-          payment_method_type: ("card" if object.card_brand.present?),
-          brand: object.card_brand,
-          last4: object.card_last_four,
-          created_at: (object.created_at ? Time.parse(object.created_at) : nil),
-          updated_at: (object.updated_at ? Time.parse(object.updated_at) : nil)
-        }
+          processor_id = "subscription_invoice:#{invoice.id}"
+          subscription = Pay::LemonSqueezy::Subscription.find_by(processor_id: invoice.subscription_id)
+          attributes = {
+            processor_id: processor_id,
+            currency: invoice.currency,
+            amount: invoice.total,
+            amount_refunded: invoice.refunded_amount,
+            subtotal: invoice.subtotal,
+            tax: invoice.tax,
+            subscription: subscription,
+            payment_method_type: ("card" if invoice.card_brand.present?),
+            brand: invoice.card_brand,
+            last4: invoice.card_last_four,
+            created_at: (invoice.created_at ? Time.parse(invoice.created_at) : nil),
+            updated_at: (invoice.updated_at ? Time.parse(invoice.updated_at) : nil)
+          }
 
-        # Update customer's payment method
-        Pay::LemonSqueezy::PaymentMethod.sync(pay_customer: pay_customer, attributes: object)
+          # Update customer's payment method
+          Pay::LemonSqueezy::PaymentMethod.sync(pay_customer: pay_customer, attributes: invoice)
 
-        # Update or create the charge
-        if (pay_charge = pay_customer.charges.find_by(processor_id: processor_id))
-          pay_charge.with_lock do
-            pay_charge.update!(attributes)
+          # Update or create the charge
+          if (pay_charge = pay_customer.charges.find_by(processor_id: processor_id))
+            pay_charge.with_lock do
+              pay_charge.update!(attributes)
+            end
+            pay_charge
+          else
+            pay_customer.charges.create!(attributes.merge(processor_id: processor_id))
           end
-          pay_charge
-        else
-          pay_customer.charges.create!(attributes.merge(processor_id: processor_id))
-        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
 

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

@@ -41,7 +41,7 @@ module Pay
       end
 
       def charge(amount, options = {})
-        raise Pay::Error, "LemonSqueezy does not support one-off charges"
+        raise Pay::NotSupportedError, "Lemon Squeezy does not support one-off charges"
       end
 
       def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)

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

@@ -1,43 +1,46 @@
 module Pay
   module LemonSqueezy
     class Subscription < Pay::Subscription
-      def self.sync(subscription_id, object: nil, name: Pay.default_product_name)
-        object ||= ::LemonSqueezy::Subscription.retrieve(id: subscription_id)
-
-        pay_customer = Pay::Customer.find_by(processor: :lemon_squeezy, processor_id: object.customer_id)
-        return unless pay_customer
-
-        attributes = {
-          current_period_end: object.renews_at,
-          ends_at: (object.ends_at ? Time.parse(object.ends_at) : nil),
-          pause_starts_at: (object.pause&.resumes_at ? Time.parse(object.pause.resumes_at) : nil),
-          status: object.status,
-          processor_plan: object.first_subscription_item.price_id,
-          quantity: object.first_subscription_item.quantity,
-          created_at: (object.created_at ? Time.parse(object.created_at) : nil),
-          updated_at: (object.updated_at ? Time.parse(object.updated_at) : nil)
-        }
-
-        case attributes[:status]
-        when "cancelled"
-          # Remove payment methods since customer cannot be reused after cancelling
-          Pay::PaymentMethod.where(customer_id: object.customer_id).destroy_all
-        when "on_trial"
-          attributes[:trial_ends_at] = Time.parse(object.trial_ends_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
+      extend Pay::Sync
 
-        # Update or create the subscription
-        if (pay_subscription = find_by(customer: pay_customer, processor_id: object.id))
-          pay_subscription.with_lock { pay_subscription.update!(attributes) }
-          pay_subscription
-        else
-          create!(attributes.merge(customer: pay_customer, name: name, processor_id: object.id))
+      # Lemon Squeezy statuses that Pay spells differently
+      STATUSES = {"on_trial" => "trialing", "cancelled" => "canceled"}.freeze
+
+      def self.sync(subscription_id, object: nil, name: Pay.default_product_name)
+        sync_with_retries do
+          subscription = object || ::LemonSqueezy::Subscription.retrieve(id: subscription_id)
+          return unless (pay_customer = find_pay_customer(subscription.customer_id))
+
+          attributes = {
+            current_period_end: subscription.renews_at,
+            ends_at: (subscription.ends_at ? Time.parse(subscription.ends_at) : nil),
+            pause_resumes_at: (subscription.pause&.resumes_at ? Time.parse(subscription.pause.resumes_at) : nil),
+            status: STATUSES.fetch(subscription.status, subscription.status),
+            processor_plan: subscription.first_subscription_item.price_id,
+            quantity: subscription.first_subscription_item.quantity,
+            created_at: (subscription.created_at ? Time.parse(subscription.created_at) : nil),
+            updated_at: (subscription.updated_at ? Time.parse(subscription.updated_at) : nil)
+          }
+
+          case attributes[:status]
+          when "canceled"
+            # Remove payment methods since customer cannot be reused after cancelling
+            pay_customer.payment_methods.destroy_all
+          when "trialing"
+            attributes[:trial_ends_at] = Time.parse(subscription.trial_ends_at)
+          when "active", "past_due"
+            attributes[:trial_ends_at] = nil
+            attributes[:pause_resumes_at] = nil
+            attributes[:ends_at] = nil
+          end
+
+          # Update or create the subscription
+          if (pay_subscription = find_by(customer: pay_customer, processor_id: subscription.id))
+            pay_subscription.with_lock { pay_subscription.update!(attributes) }
+            pay_subscription
+          else
+            create!(attributes.merge(customer: pay_customer, name: name, processor_id: subscription.id))
+          end
         end
       end
 
@@ -64,7 +67,7 @@ module Pay
       end
 
       def cancel_now!(**options)
-        raise Pay::Error, "Lemon Squeezy does not support cancelling immediately through the API."
+        raise Pay::NotSupportedError, "Lemon Squeezy does not support cancelling immediately through the API"
       end
 
       def change_quantity(quantity, **options)
@@ -75,19 +78,13 @@ module Pay
         raise Pay::LemonSqueezy::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?
         status == "paused"
       end
 
       def pause(**options)
         response = ::LemonSqueezy::Subscription.pause(id: processor_id, **options)
-        update!(status: :paused, pause_starts_at: response.pause&.resumes_at)
+        update!(status: :paused, pause_resumes_at: response.pause&.resumes_at)
       rescue ::LemonSqueezy::Error => e
         raise Pay::LemonSqueezy::Error, e
       end
@@ -101,13 +98,13 @@ module Pay
           raise Error, "You can only resume paused or cancelled subscriptions"
         end
 
-        if paused? && pause_starts_at? && Time.current < pause_starts_at
+        if paused?
           ::LemonSqueezy::Subscription.unpause(id: processor_id)
         else
           ::LemonSqueezy::Subscription.uncancel(id: processor_id)
         end
 
-        update(ends_at: nil, status: :active, pause_starts_at: nil)
+        update(ends_at: nil, status: :active, pause_resumes_at: nil)
       rescue ::LemonSqueezy::Error => e
         raise Pay::LemonSqueezy::Error, e
       end

data/app/models/pay/merchant.rb

@@ -7,7 +7,7 @@ module Pay
     store_accessor :data, :onboarding_complete
 
     def onboarding_complete?
-      ActiveModel::Type::Boolean.new.cast(data&.fetch("onboarding_complete")) || false
+      ActiveModel::Type::Boolean.new.cast(onboarding_complete) || false
     end
   end
 end

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

@@ -1,66 +1,56 @@
 module Pay
   module PaddleBilling
     class Charge < Pay::Charge
-      store_accessor :data, :paddle_receipt_url
-
-      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"
+      extend Pay::Sync
 
-        # 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
+      store_accessor :data, :paddle_receipt_url
 
-        # 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
+      def self.sync(charge_id, object: nil)
+        sync_with_retries do
+          transaction = object || ::Paddle::Transaction.retrieve(id: charge_id)
 
-        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)
-        }
+          # Ignore transactions that aren't completed
+          return unless transaction.status == "completed"
+          return unless (pay_customer = find_pay_customer(transaction.customer_id))
 
-        if (details = Array.wrap(object.payments).first&.method_details)
-          case 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"
+          # Ignore transactions that are payment method changes
+          # But update the customer's payment method
+          if transaction.origin == "subscription_payment_method_change"
+            Pay::PaddleBilling::PaymentMethod.sync(pay_customer: pay_customer, attributes: transaction.payments.first)
+            return
           end
 
-          # Update customer's payment method
-          Pay::PaddleBilling::PaymentMethod.sync(pay_customer: pay_customer, attributes: object.payments.first)
-        end
+          attrs = {
+            amount: transaction.details.totals.grand_total,
+            created_at: transaction.created_at,
+            currency: transaction.currency_code,
+            metadata: transaction.details.line_items&.first&.id,
+            subscription: pay_customer.subscriptions.find_by(processor_id: transaction.subscription_id)
+          }
+
+          if (details = Array.wrap(transaction.payments).first&.method_details)
+            case 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: transaction.payments.first)
+          end
 
-        # Update or create the charge
-        if (pay_charge = find_by(customer: pay_customer, processor_id: object.id))
-          pay_charge.with_lock { pay_charge.update!(attrs) }
-          pay_charge
-        else
-          create!(attrs.merge(customer: pay_customer, processor_id: object.id))
-        end
-      rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique
-        try += 1
-        if try <= retries
-          sleep 0.1
-          retry
-        else
-          raise
+          # Update or create the charge
+          if (pay_charge = find_by(customer: pay_customer, processor_id: transaction.id))
+            pay_charge.with_lock { pay_charge.update!(attrs) }
+            pay_charge
+          else
+            create!(attrs.merge(customer: pay_customer, processor_id: transaction.id))
+          end
         end
       end
     end

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

@@ -60,7 +60,7 @@ module Pay
       end
 
       def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
-        # pass
+        raise Pay::NotSupportedError, "Paddle Billing subscriptions are created with Paddle Checkout and synced from webhooks"
       end
 
       # Paddle does not use payment method tokens. The method signature has it here

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

@@ -1,6 +1,8 @@
 module Pay
   module PaddleBilling
     class PaymentMethod < Pay::PaymentMethod
+      extend Pay::Sync
+
       def self.sync_from_transaction(pay_customer:, transaction:)
         transaction = ::Paddle::Transaction.retrieve(id: transaction)
         return unless transaction.status == "completed"
@@ -8,30 +10,24 @@ module Pay
         sync(pay_customer: pay_customer, attributes: transaction.payments.first)
       end
 
-      def self.sync(pay_customer:, attributes:, try: 0, retries: 1)
-        details = attributes.method_details
-        attrs = {
-          payment_method_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
+      def self.sync(pay_customer:, attributes:)
+        sync_with_retries do
+          details = attributes.method_details
+          attrs = {
+            payment_method_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.payment_method_id)
-        payment_method.update!(attrs)
-        payment_method
-      rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique
-        try += 1
-        if try <= retries
-          sleep 0.1
-          retry
-        else
-          raise
+          payment_method = pay_customer.payment_methods.find_or_initialize_by(processor_id: attributes.payment_method_id)
+          payment_method.update!(attrs)
+          payment_method
         end
       end
 

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

@@ -1,75 +1,68 @@
 module Pay
   module PaddleBilling
     class Subscription < Pay::Subscription
+      extend Pay::Sync
+
       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
+        Pay.deprecator.warn "Pay::PaddleBilling::Subscription.sync_from_transaction is deprecated, use Pay::PaddleBilling.sync_transaction instead"
+        Pay::PaddleBilling.sync_transaction(transaction_id)
       end
 
-      def self.sync(subscription_id, object: nil, name: Pay.default_product_name, try: 0, retries: 1)
-        # 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) if object.next_billed_at
-        when "paused"
-          attributes[:pause_starts_at] = Time.parse(object.paused_at) if 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
-        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 = find_by(customer: pay_customer, processor_id: subscription_id))
-          pay_subscription.with_lock { pay_subscription.update!(attributes) }
-          pay_subscription
-        else
-          create!(attributes.merge(customer: pay_customer, name: name, processor_id: subscription_id))
-        end
-      rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique
-        try += 1
-        if try <= retries
-          sleep 0.1
-          retry
-        else
-          raise
+      def self.sync(subscription_id, object: nil, name: Pay.default_product_name)
+        sync_with_retries do
+          subscription = object || ::Paddle::Subscription.retrieve(id: subscription_id)
+          return unless (pay_customer = find_pay_customer(subscription.customer_id))
+
+          attributes = {
+            current_period_end: subscription.current_billing_period&.ends_at,
+            current_period_start: subscription.current_billing_period&.starts_at,
+            ends_at: (subscription.canceled_at ? Time.parse(subscription.canceled_at) : nil),
+            metadata: subscription.custom_data,
+            paddle_cancel_url: subscription.management_urls&.cancel,
+            paddle_update_url: subscription.management_urls&.update_payment_method,
+            pause_starts_at: (subscription.paused_at ? Time.parse(subscription.paused_at) : nil),
+            status: subscription.status
+          }
+
+          if subscription.items&.first
+            item = subscription.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_customer.payment_methods.destroy_all
+          when "trialing"
+            attributes[:trial_ends_at] = Time.parse(subscription.next_billed_at) if subscription.next_billed_at
+          when "paused"
+            attributes[:pause_starts_at] = Time.parse(subscription.paused_at) if subscription.paused_at
+          when "active", "past_due"
+            attributes[:trial_ends_at] = nil
+            attributes[:pause_starts_at] = nil
+            attributes[:ends_at] = nil
+          end
+
+          case subscription.scheduled_change&.action
+          when "cancel"
+            attributes[:ends_at] = Time.parse(subscription.scheduled_change.effective_at)
+          when "pause"
+            attributes[:pause_starts_at] = Time.parse(subscription.scheduled_change.effective_at)
+          when "resume"
+            attributes[:pause_resumes_at] = Time.parse(subscription.scheduled_change.effective_at)
+          end
+
+          # Update or create the subscription
+          if (pay_subscription = find_by(customer: pay_customer, processor_id: subscription_id))
+            pay_subscription.with_lock { pay_subscription.update!(attributes) }
+            pay_subscription
+          else
+            create!(attributes.merge(customer: pay_customer, name: name, processor_id: subscription_id))
+          end
         end
       end
 
@@ -175,10 +168,6 @@ module Pay
         )
         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/app/models/pay/paddle_classic/customer.rb

@@ -35,7 +35,7 @@ module Pay
       end
 
       def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
-        # pass
+        raise Pay::NotSupportedError, "Paddle Classic subscriptions are created with Paddle Checkout and synced from webhooks"
       end
 
       # Paddle does not use payment method tokens. The method signature has it here