pay 6.8.1 → 7.0.0

data/lib/pay/paddle_billing/subscription.rb

@@ -0,0 +1,185 @@
+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/paddle_billing/webhooks/subscription.rb

@@ -0,0 +1,11 @@
+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/paddle_billing/webhooks/transaction_completed.rb

@@ -0,0 +1,11 @@
+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/paddle_billing.rb

@@ -0,0 +1,58 @@
+module Pay
+  module PaddleBilling
+    autoload :Billable, "pay/paddle_billing/billable"
+    autoload :Charge, "pay/paddle_billing/charge"
+    autoload :Error, "pay/paddle_billing/error"
+    autoload :PaymentMethod, "pay/paddle_billing/payment_method"
+    autoload :Subscription, "pay/paddle_billing/subscription"
+
+    module Webhooks
+      autoload :Subscription, "pay/paddle_billing/webhooks/subscription"
+      autoload :TransactionCompleted, "pay/paddle_billing/webhooks/transaction_completed"
+    end
+
+    extend Env
+
+    def self.enabled?
+      return false unless Pay.enabled_processors.include?(:paddle_billing) && defined?(::Paddle)
+
+      Pay::Engine.version_matches?(required: "~> 2.1", current: ::Paddle::VERSION) || (raise "[Pay] paddle gem must be version ~> 2.1")
+    end
+
+    def self.setup
+      ::Paddle.config.environment = environment
+      ::Paddle.config.api_key = api_key
+    end
+
+    def self.environment
+      find_value_by_name(:paddle_billing, :environment) || "production"
+    end
+
+    def self.client_token
+      find_value_by_name(:paddle_billing, :client_token)
+    end
+
+    def self.api_key
+      find_value_by_name(:paddle_billing, :api_key)
+    end
+
+    def self.signing_secret
+      find_value_by_name(:paddle_billing, :signing_secret)
+    end
+
+    def self.configure_webhooks
+      Pay::Webhooks.configure do |events|
+        events.subscribe "paddle_billing.subscription.activated", Pay::PaddleBilling::Webhooks::Subscription.new
+        events.subscribe "paddle_billing.subscription.canceled", Pay::PaddleBilling::Webhooks::Subscription.new
+        events.subscribe "paddle_billing.subscription.created", Pay::PaddleBilling::Webhooks::Subscription.new
+        events.subscribe "paddle_billing.subscription.imported", Pay::PaddleBilling::Webhooks::Subscription.new
+        events.subscribe "paddle_billing.subscription.past_due", Pay::PaddleBilling::Webhooks::Subscription.new
+        events.subscribe "paddle_billing.subscription.paused", Pay::PaddleBilling::Webhooks::Subscription.new
+        events.subscribe "paddle_billing.subscription.resumed", Pay::PaddleBilling::Webhooks::Subscription.new
+        events.subscribe "paddle_billing.subscription.trialing", Pay::PaddleBilling::Webhooks::Subscription.new
+        events.subscribe "paddle_billing.subscription.updated", Pay::PaddleBilling::Webhooks::Subscription.new
+        events.subscribe "paddle_billing.transaction.completed", Pay::PaddleBilling::Webhooks::TransactionCompleted.new
+      end
+    end
+  end
+end

data/lib/pay/{paddle → paddle_classic}/billable.rb

@@ -1,5 +1,5 @@
 module Pay
-  module Paddle
+  module PaddleClassic
     class Billable
       attr_reader :pay_customer
 
@@ -27,7 +27,7 @@ module Pay
         return unless subscription.processor_id
         raise Pay::Error, "A charge_name is required to create a one-time charge" if options[:charge_name].nil?
 
-        response = PaddlePay::Subscription::Charge.create(subscription.processor_id, amount.to_f / 100, options[:charge_name], options)
+        response = PaddleClassic.client.charges.create(subscription_id: subscription.processor_id, amount: amount.to_f / 100, charge_name: options[:charge_name])
 
         attributes = {
           amount: (response[:amount].to_f * 100).to_i,
@@ -36,13 +36,13 @@ module Pay
         }
 
         # Lookup subscription payment method details
-        attributes.merge! Pay::Paddle::PaymentMethod.payment_method_details_for(subscription_id: subscription.processor_id)
+        attributes.merge! Pay::PaddleClassic::PaymentMethod.payment_method_details_for(subscription_id: subscription.processor_id)
 
         charge = pay_customer.charges.find_or_initialize_by(processor_id: response[:invoice_id])
         charge.update(attributes)
         charge
-      rescue ::PaddlePay::PaddlePayError => e
-        raise Pay::Paddle::Error, e
+      rescue ::Paddle::Error => e
+        raise Pay::PaddleClassic::Error, e
       end
 
       def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
@@ -52,7 +52,7 @@ module Pay
       # 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::Paddle::PaymentMethod.sync(pay_customer: pay_customer)
+        Pay::PaddleClassic::PaymentMethod.sync(pay_customer: pay_customer)
       end
 
       def trial_end_date(subscription)
@@ -61,10 +61,9 @@ module Pay
       end
 
       def processor_subscription(subscription_id, options = {})
-        hash = PaddlePay::Subscription::User.list({subscription_id: subscription_id}, options).try(:first)
-        OpenStruct.new(hash)
-      rescue ::PaddlePay::PaddlePayError => e
-        raise Pay::Paddle::Error, e
+        PaddleClassic.client.users.list(subscription_id: subscription_id).data.try(:first)
+      rescue ::Paddle::Error => e
+        raise Pay::PaddleClassic::Error, e
       end
     end
   end

data/lib/pay/paddle_classic/charge.rb

@@ -0,0 +1,35 @@
+module Pay
+  module PaddleClassic
+    class Charge
+      attr_reader :pay_charge
+
+      delegate :processor_id, :customer, to: :pay_charge
+
+      def initialize(pay_charge)
+        @pay_charge = pay_charge
+      end
+
+      def charge
+        return unless customer.subscription
+        payments = PaddleClassic.client.payments.list(subscription_id: customer.subscription.processor_id)
+        charges = payments.data.select { |p| p[:id].to_s == processor_id }
+        charges.try(:first)
+      rescue ::Paddle::Error => e
+        raise Pay::PaddleClassic::Error, e
+      end
+
+      def refund!(amount_to_refund)
+        return unless customer.subscription
+        payments = PaddleClassic.client.payments.list(subscription_id: customer.subscription.processor_id, is_paid: 1)
+        if payments.total > 0
+          PaddleClassic.client.payments.refund(order_id: payments.data.last[:id], amount: amount_to_refund)
+          pay_charge.update(amount_refunded: amount_to_refund)
+        else
+          raise Error, "Payment not found"
+        end
+      rescue ::Paddle::Error => e
+        raise Pay::PaddleClassic::Error, e
+      end
+    end
+  end
+end

data/lib/pay/paddle_classic/error.rb

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

data/lib/pay/{paddle → paddle_classic}/payment_method.rb

@@ -1,5 +1,5 @@
 module Pay
-  module Paddle
+  module PaddleClassic
     class PaymentMethod
       attr_reader :pay_payment_method
 
@@ -17,12 +17,12 @@ module Pay
 
         payment_method.update!(attributes)
         payment_method
-      rescue ::PaddlePay::PaddlePayError => e
-        raise Pay::Paddle::Error, e
+      rescue ::Paddle::Error => e
+        raise Pay::PaddleClassic::Error, e
       end
 
       def self.payment_method_details_for(subscription_id:)
-        subscription_user = PaddlePay::Subscription::User.list({subscription_id: subscription_id}).try(:first)
+        subscription_user = PaddleClassic.client.users.list(subscription_id: subscription_id).data.try(:first)
         payment_information = subscription_user ? subscription_user[:payment_information] : {}
 
         case payment_information[:payment_method]&.downcase

data/lib/pay/{paddle → paddle_classic}/subscription.rb

@@ -1,5 +1,5 @@
 module Pay
-  module Paddle
+  module PaddleClassic
     class Subscription
       attr_reader :pay_subscription
 
@@ -24,14 +24,14 @@ module Pay
 
       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 ||= OpenStruct.new PaddlePay::Subscription::User.list({subscription_id: subscription_id}).try(:first)
+        object ||= PaddleClassic.client.users.list(subscription_id: subscription_id).data.try(:first)
 
-        pay_customer = Pay::Customer.find_by(processor: :paddle, processor_id: object.user_id)
+        pay_customer = Pay::Customer.find_by(processor: :paddle_classic, processor_id: object.user_id)
 
         # If passthrough exists (only on webhooks) we can use it to create the Pay::Customer
         if pay_customer.nil? && object.passthrough
-          owner = Pay::Paddle.owner_from_passthrough(object.passthrough)
-          pay_customer = owner&.set_payment_processor(:paddle, processor_id: object.user_id)
+          owner = Pay::PaddleClassic.owner_from_passthrough(object.passthrough)
+          pay_customer = owner&.set_payment_processor(:paddle_classic, processor_id: object.user_id)
         end
 
         return unless pay_customer
@@ -40,7 +40,7 @@ module Pay
           paddle_cancel_url: object.cancel_url,
           paddle_update_url: object.update_url,
           processor_plan: object.plan_id || object.subscription_plan_id,
-          quantity: object.quantity,
+          quantity: object.quantity || 1,
           status: object.state || object.status
         }
 
@@ -70,38 +70,45 @@ module Pay
       end
 
       def subscription(**options)
-        hash = PaddlePay::Subscription::User.list({subscription_id: processor_id}, options).try(:first)
-        OpenStruct.new(hash)
-      rescue ::PaddlePay::PaddlePayError => e
-        raise Pay::Paddle::Error, e
+        PaddleClassic.client.users.list(subscription_id: processor_id).data.try(:first)
+      rescue ::Paddle::Error => e
+        raise Pay::PaddleClassic::Error, e
       end
 
+      # Paddle subscriptions are canceled immediately, however we still want to give the user access to the end of the period they paid for
       def cancel(**options)
+        return if canceled?
+
         ends_at = if on_trial?
           trial_ends_at
         elsif paused?
           pause_starts_at
         else
-          processor_subscription.next_payment&.fetch(:date) || Time.current
+          Time.parse(processor_subscription.next_payment.date)
         end
 
-        PaddlePay::Subscription::User.cancel(processor_id)
-        pay_subscription.update(status: :canceled, ends_at: ends_at)
+        PaddleClassic.client.users.cancel(subscription_id: processor_id)
+        pay_subscription.update(
+          status: (ends_at.future? ? :active : :canceled),
+          ends_at: ends_at
+        )
 
         # Remove payment methods since customer cannot be reused after cancelling
         Pay::PaymentMethod.where(customer_id: pay_subscription.customer_id).destroy_all
-      rescue ::PaddlePay::PaddlePayError => e
-        raise Pay::Paddle::Error, e
+      rescue ::Paddle::Error => e
+        raise Pay::PaddleClassic::Error, e
       end
 
       def cancel_now!(**options)
-        PaddlePay::Subscription::User.cancel(processor_id)
+        return if canceled?
+
+        PaddleClassic.client.users.cancel(subscription_id: processor_id)
         pay_subscription.update(status: :canceled, ends_at: Time.current)
 
         # Remove payment methods since customer cannot be reused after cancelling
         Pay::PaymentMethod.where(customer_id: pay_subscription.customer_id).destroy_all
-      rescue ::PaddlePay::PaddlePayError => e
-        raise Pay::Paddle::Error, e
+      rescue ::Paddle::Error => e
+        raise Pay::PaddleClassic::Error, e
       end
 
       def change_quantity(quantity, **options)
@@ -119,23 +126,25 @@ module Pay
       end
 
       def pause
-        attributes = {pause: true}
-        response = PaddlePay::Subscription::User.update(processor_id, attributes)
+        response = PaddleClassic.client.users.pause(subscription_id: processor_id)
         pay_subscription.update(status: :paused, pause_starts_at: Time.zone.parse(response.dig(:next_payment, :date)))
-      rescue ::PaddlePay::PaddlePayError => e
-        raise Pay::Paddle::Error, e
+      rescue ::Paddle::Error => e
+        raise Pay::PaddleClassic::Error, e
+      end
+
+      def resumable?
+        paused?
       end
 
       def resume
-        unless paused?
+        unless resumable?
           raise StandardError, "You can only resume paused subscriptions."
         end
 
-        attributes = {pause: false}
-        PaddlePay::Subscription::User.update(processor_id, attributes)
+        PaddleClassic.client.users.unpause(subscription_id: processor_id)
         pay_subscription.update(status: :active, pause_starts_at: nil)
-      rescue ::PaddlePay::PaddlePayError => e
-        raise Pay::Paddle::Error, e
+      rescue ::Paddle::Error => e
+        raise Pay::PaddleClassic::Error, e
       end
 
       def swap(plan, **options)
@@ -143,11 +152,11 @@ module Pay
 
         attributes = {plan_id: plan, prorate: prorate}
         attributes[:quantity] = quantity if quantity?
-        PaddlePay::Subscription::User.update(processor_id, attributes)
+        PaddleClassic.client.users.update(subscription_id: processor_id, **attributes)
 
         pay_subscription.update(processor_plan: plan, ends_at: nil, status: :active)
-      rescue ::PaddlePay::PaddlePayError => e
-        raise Pay::Paddle::Error, e
+      rescue ::Paddle::Error => e
+        raise Pay::PaddleClassic::Error, e
       end
 
       # Retries the latest invoice for a Past Due subscription

data/lib/pay/{paddle → paddle_classic}/webhooks/signature_verifier.rb

@@ -3,14 +3,14 @@ require "json"
 require "openssl"
 
 module Pay
-  module Paddle
+  module PaddleClassic
     module Webhooks
       class SignatureVerifier
         def initialize(data)
           @data = data
-          @public_key_file = Pay::Paddle.public_key_file
-          @public_key = Pay::Paddle.public_key
-          @public_key_base64 = Pay::Paddle.public_key_base64
+          @public_key_file = Pay::PaddleClassic.public_key_file
+          @public_key = Pay::PaddleClassic.public_key
+          @public_key_base64 = Pay::PaddleClassic.public_key_base64
         end
 
         def verify

data/lib/pay/{paddle → paddle_classic}/webhooks/subscription_cancelled.rb

@@ -1,23 +1,24 @@
 module Pay
-  module Paddle
+  module PaddleClassic
     module Webhooks
       class SubscriptionCancelled
         def call(event)
-          pay_subscription = Pay::Subscription.find_by_processor_and_id(:paddle, event.subscription_id)
+          pay_subscription = Pay::Subscription.find_by_processor_and_id(:paddle_classic, event.subscription_id)
 
           # We couldn't find the subscription for some reason, maybe it's from another service
           return if pay_subscription.nil?
 
           # User canceled subscriptions have an ends_at
           # Automatically cancelled subscriptions need this value set
+          # Paddle subscriptions are canceled immediately, however we still want to give the user access to the end of the period they paid for
           ends_at = Time.zone.parse(event.cancellation_effective_date)
           pay_subscription.update!(
-            status: :canceled,
+            status: (ends_at.future? ? :active : :canceled),
             trial_ends_at: (ends_at if pay_subscription.trial_ends_at?),
             ends_at: ends_at
           )
 
-          # Paddle doesn't allow reusing customers, so we should remove their payment methods
+          # Paddle classic doesn't allow reusing customers, so we should remove their payment methods
           Pay::PaymentMethod.where(customer_id: pay_subscription.customer_id).destroy_all
         end
       end

data/lib/pay/{paddle → paddle_classic}/webhooks/subscription_created.rb

@@ -1,9 +1,9 @@
 module Pay
-  module Paddle
+  module PaddleClassic
     module Webhooks
       class SubscriptionCreated
         def call(event)
-          Pay::Paddle::Subscription.sync(event.subscription_id, object: event)
+          Pay::PaddleClassic::Subscription.sync(event.subscription_id, object: event)
         end
       end
     end

data/lib/pay/{paddle → paddle_classic}/webhooks/subscription_payment_refunded.rb

@@ -1,9 +1,9 @@
 module Pay
-  module Paddle
+  module PaddleClassic
     module Webhooks
       class SubscriptionPaymentRefunded
         def call(event)
-          pay_charge = Pay::Charge.find_by_processor_and_id(:paddle, event.subscription_payment_id)
+          pay_charge = Pay::Charge.find_by_processor_and_id(:paddle_classic, event.subscription_payment_id)
           return unless pay_charge.present?
 
           pay_charge.update!(amount_refunded: (event.gross_refund.to_f * 100).to_i)

data/lib/pay/{paddle → paddle_classic}/webhooks/subscription_payment_succeeded.rb

@@ -1,13 +1,13 @@
 module Pay
-  module Paddle
+  module PaddleClassic
     module Webhooks
       class SubscriptionPaymentSucceeded
         def call(event)
-          pay_customer = Pay::Customer.find_by(processor: :paddle, processor_id: event.user_id)
+          pay_customer = Pay::Customer.find_by(processor: :paddle_classic, processor_id: event.user_id)
 
           if pay_customer.nil?
-            owner = Pay::Paddle.owner_from_passthrough(event.passthrough)
-            pay_customer = owner&.set_payment_processor :paddle, processor_id: event.user_id
+            owner = Pay::PaddleClassic.owner_from_passthrough(event.passthrough)
+            pay_customer = owner&.set_payment_processor :paddle_classic, processor_id: event.user_id
           end
 
           if pay_customer.nil?
@@ -22,7 +22,7 @@ module Pay
         end
 
         def create_charge(pay_customer, event)
-          payment_method_details = Pay::Paddle::PaymentMethod.payment_method_details_for(subscription_id: event.subscription_id)
+          payment_method_details = Pay::PaddleClassic::PaymentMethod.payment_method_details_for(subscription_id: event.subscription_id)
 
           attributes = {
             amount: (event.sale_gross.to_f * 100).to_i,
@@ -30,14 +30,14 @@ module Pay
             currency: event.currency,
             paddle_receipt_url: event.receipt_url,
             subscription: pay_customer.subscriptions.find_by(processor_id: event.subscription_id),
-            metadata: Pay::Paddle.parse_passthrough(event.passthrough).except("owner_sgid")
+            metadata: Pay::PaddleClassic.parse_passthrough(event.passthrough).except("owner_sgid")
           }.merge(payment_method_details)
 
           pay_charge = pay_customer.charges.find_or_initialize_by(processor_id: event.subscription_payment_id)
           pay_charge.update!(attributes)
 
           # Update customer's payment method
-          Pay::Paddle::PaymentMethod.sync(pay_customer: pay_customer, attributes: payment_method_details)
+          Pay::PaddleClassic::PaymentMethod.sync(pay_customer: pay_customer, attributes: payment_method_details)
 
           pay_charge
         end

data/lib/pay/{paddle → paddle_classic}/webhooks/subscription_updated.rb

@@ -1,9 +1,9 @@
 module Pay
-  module Paddle
+  module PaddleClassic
     module Webhooks
       class SubscriptionUpdated
         def call(event)
-          pay_subscription = Pay::Subscription.find_by_processor_and_id(:paddle, event["subscription_id"])
+          pay_subscription = Pay::Subscription.find_by_processor_and_id(:paddle_classic, event["subscription_id"])
 
           return if pay_subscription.nil?