pay 7.3.0 → 11.2.2

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

@@ -0,0 +1,129 @@
+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
+
+        # 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))
+        end
+      end
+
+      def api_record(**options)
+        @api_record ||= ::LemonSqueezy::Subscription.retrieve(id: processor_id)
+      rescue ::LemonSqueezy::Error => e
+        raise Pay::LemonSqueezy::Error, e
+      end
+
+      def portal_url
+        api_record.urls.customer_portal
+      end
+
+      def update_url
+        api_record.urls.update_payment_method
+      end
+
+      def cancel(**options)
+        return if canceled?
+        response = ::LemonSqueezy::Subscription.cancel(id: processor_id)
+        update(status: response.status, ends_at: response.ends_at)
+      rescue ::LemonSqueezy::Error => e
+        raise Pay::LemonSqueezy::Error, e
+      end
+
+      def cancel_now!(**options)
+        raise Pay::Error, "Lemon Squeezy does not support cancelling immediately through the API."
+      end
+
+      def change_quantity(quantity, **options)
+        subscription_item = api_record.first_subscription_item
+        ::LemonSqueezy::SubscriptionItem.update(id: subscription_item.id, quantity: quantity)
+        update(quantity: quantity)
+      rescue ::LemonSqueezy::Error => e
+        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)
+      rescue ::LemonSqueezy::Error => e
+        raise Pay::LemonSqueezy::Error, e
+      end
+
+      def resumable?
+        paused? || canceled?
+      end
+
+      def resume
+        unless resumable?
+          raise Error, "You can only resume paused or cancelled subscriptions"
+        end
+
+        if paused? && pause_starts_at? && Time.current < pause_starts_at
+          ::LemonSqueezy::Subscription.unpause(id: processor_id)
+        else
+          ::LemonSqueezy::Subscription.uncancel(id: processor_id)
+        end
+
+        update(ends_at: nil, status: :active, pause_starts_at: nil)
+      rescue ::LemonSqueezy::Error => e
+        raise Pay::LemonSqueezy::Error, e
+      end
+
+      # Lemon Squeezy requires both the Product ID and Variant ID.
+      # The Variant ID will be saved as the processor_plan
+      def swap(plan, **options)
+        raise Error, "A plan_id is required to swap a subscription" unless plan
+        raise Error, "A variant_id is required to swap a subscription" unless options[:variant_id]
+
+        ::LemonSqueezy::Subscription.change_plan id: processor_id, plan_id: plan, variant_id: options[:variant_id]
+
+        update(processor_plan: options[:variant_id], ends_at: nil, status: :active)
+      end
+    end
+  end
+end
+
+ActiveSupport.run_load_hooks :pay_lemon_squeezy_subscription, Pay::LemonSqueezy::Subscription

data/app/models/pay/merchant.rb

@@ -6,19 +6,10 @@ module Pay
 
     store_accessor :data, :onboarding_complete
 
-    delegate_missing_to :pay_processor
-
-    def self.pay_processor_for(name)
-      "Pay::#{name.to_s.classify}::Merchant".constantize
-    end
-
-    def pay_processor
-      return if processor.blank?
-      @pay_processor ||= self.class.pay_processor_for(processor).new(self)
-    end
-
     def onboarding_complete?
       ActiveModel::Type::Boolean.new.cast(data&.fetch("onboarding_complete")) || false
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_merchant, Pay::Merchant

data/{lib → app/models}/pay/paddle_billing/charge.rb

@@ -1,13 +1,7 @@
 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
+    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
@@ -54,15 +48,23 @@ module Pay
         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
+        if (pay_charge = find_by(customer: pay_customer, processor_id: object.id))
+          pay_charge.with_lock { pay_charge.update!(attrs) }
           pay_charge
         else
-          pay_customer.charges.create!(attrs.merge(processor_id: object.id))
+          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
         end
       end
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_paddle_billing_charge, Pay::PaddleBilling::Charge

data/{lib/pay/paddle_billing/billable.rb → app/models/pay/paddle_billing/customer.rb}

@@ -1,20 +1,12 @@
 module Pay
   module PaddleBilling
-    class Billable
-      attr_reader :pay_customer
+    class Customer < Pay::Customer
+      has_many :charges, dependent: :destroy, class_name: "Pay::PaddleBilling::Charge"
+      has_many :subscriptions, dependent: :destroy, class_name: "Pay::PaddleBilling::Subscription"
+      has_many :payment_methods, dependent: :destroy, class_name: "Pay::PaddleBilling::PaymentMethod"
+      has_one :default_payment_method, -> { where(default: true) }, class_name: "Pay::PaddleBilling::PaymentMethod"
 
-      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
+      def api_record_attributes
         {email: email, name: customer_name}
       end
 
@@ -24,13 +16,16 @@ module Pay
       # Creates a new Paddle::Customer using `email` and `customer_name` if empty processor_id
       #
       # Returns a Paddle::Customer object
-      def customer
+      def api_record
         if processor_id?
           ::Paddle::Customer.retrieve(id: processor_id)
+        elsif (pc = ::Paddle::Customer.list(email: email).data&.first)
+          update!(processor_id: pc.id)
+          pc
         else
-          sc = ::Paddle::Customer.create(email: email, name: customer_name)
-          pay_customer.update!(processor_id: sc.id)
-          sc
+          pc = ::Paddle::Customer.create(email: email, name: customer_name)
+          update!(processor_id: pc.id)
+          pc
         end
       rescue ::Paddle::Error => e
         raise Pay::PaddleBilling::Error, e
@@ -38,10 +33,9 @@ module Pay
 
       # 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)
+      def update_api_record(**attributes)
+        api_record unless processor_id?
+        ::Paddle::Customer.update(id: processor_id, **api_record_attributes.merge(attributes))
       end
 
       def charge(amount, options = {})
@@ -58,7 +52,7 @@ module Pay
           metadata: transaction.details.line_items&.first&.id
         }
 
-        charge = pay_customer.charges.find_or_initialize_by(processor_id: transaction.id)
+        charge = charges.find_or_initialize_by(processor_id: transaction.id)
         charge.update(attrs)
         charge
       rescue ::Paddle::Error => e
@@ -72,19 +66,10 @@ 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::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
+        Pay::PaddleBilling::PaymentMethod.sync(pay_customer: self)
       end
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_paddle_billing_customer, Pay::PaddleBilling::Customer

data/{lib → app/models}/pay/paddle_billing/payment_method.rb

@@ -1,10 +1,6 @@
 module Pay
   module PaddleBilling
-    class PaymentMethod
-      attr_reader :pay_payment_method
-
-      delegate :customer, :processor_id, to: :pay_payment_method
-
+    class PaymentMethod < Pay::PaymentMethod
       def self.sync_from_transaction(pay_customer:, transaction:)
         transaction = ::Paddle::Transaction.retrieve(id: transaction)
         return unless transaction.status == "completed"
@@ -12,10 +8,10 @@ module Pay
         sync(pay_customer: pay_customer, attributes: transaction.payments.first)
       end
 
-      def self.sync(pay_customer:, attributes:)
+      def self.sync(pay_customer:, attributes:, try: 0, retries: 1)
         details = attributes.method_details
         attrs = {
-          type: details.type.downcase
+          payment_method_type: details.type.downcase
         }
 
         case details.type.downcase
@@ -29,19 +25,23 @@ module Pay
         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
+        end
       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
+
+ActiveSupport.run_load_hooks :pay_paddle_billing_payment_method, Pay::PaddleBilling::PaymentMethod

data/{lib → app/models}/pay/paddle_billing/subscription.rb

@@ -1,33 +1,15 @@
 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
+    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
       end
 
-      def self.sync(subscription_id, object: nil, name: Pay.default_product_name)
+      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)
 
@@ -75,22 +57,24 @@ module Pay
         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
+        if (pay_subscription = find_by(customer: pay_customer, processor_id: subscription_id))
+          pay_subscription.with_lock { pay_subscription.update!(attributes) }
           pay_subscription
         else
-          pay_customer.subscriptions.create!(attributes.merge(name: name, processor_id: subscription_id))
+          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
         end
       end
 
-      def initialize(pay_subscription)
-        @pay_subscription = pay_subscription
-      end
-
-      def subscription(**options)
-        @paddle_billing_subscription ||= ::Paddle::Subscription.retrieve(id: processor_id, **options)
+      def api_record(**options)
+        @api_record ||= ::Paddle::Subscription.retrieve(id: processor_id, **options)
       end
 
       # Get a transaction to update payment method
@@ -105,9 +89,9 @@ module Pay
 
         response = ::Paddle::Subscription.cancel(
           id: processor_id,
-          effective_from: options.fetch(:effective_from, (paused? ? "immediately" : "next_billing_period"))
+          effective_from: options.fetch(:effective_from, paused? ? "immediately" : "next_billing_period")
         )
-        pay_subscription.update(
+        update(
           status: response.status,
           ends_at: response.scheduled_change&.effective_at || Time.current
         )
@@ -116,7 +100,7 @@ module Pay
       end
 
       def cancel_now!(**options)
-        cancel(options.merge(effective_from: "immediately"))
+        cancel(**options.merge(effective_from: "immediately"))
       rescue ::Paddle::Error => e
         raise Pay::PaddleBilling::Error, e
       end
@@ -127,7 +111,12 @@ module Pay
           quantity: quantity
         }]
 
-        ::Paddle::Subscription.update(id: processor_id, items: items, proration_billing_mode: "prorated_immediately")
+        ::Paddle::Subscription.update(
+          id: processor_id,
+          items: items,
+          proration_billing_mode: options.delete(:proration_billing_mode) || "prorated_immediately"
+        )
+        update(quantity: quantity)
       rescue ::Paddle::Error => e
         raise Pay::PaddleBilling::Error, e
       end
@@ -139,12 +128,12 @@ module Pay
       end
 
       def paused?
-        pay_subscription.status == "paused"
+        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)
+        update!(status: :paused, pause_starts_at: response.scheduled_change.effective_at)
       rescue ::Paddle::Error => e
         raise Pay::PaddleBilling::Error, e
       end
@@ -155,7 +144,7 @@ module Pay
 
       def resume
         unless resumable?
-          raise StandardError, "You can only resume paused subscriptions."
+          raise Error, "You can only resume paused subscriptions."
         end
 
         # Paddle Billing API only allows "resuming" subscriptions when they are paused
@@ -166,19 +155,25 @@ module Pay
           ::Paddle::Subscription.resume(id: processor_id, effective_from: "immediately")
         end
 
-        pay_subscription.update(status: :active, pause_starts_at: nil)
+        update(ends_at: nil, status: :active, pause_starts_at: nil)
       rescue ::Paddle::Error => e
         raise Pay::PaddleBilling::Error, e
       end
 
       def swap(plan, **options)
+        raise ArgumentError, "plan must be a string" unless plan.is_a?(String)
+
         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)
+        ::Paddle::Subscription.update(
+          id: processor_id,
+          items: items,
+          proration_billing_mode: options.delete(:proration_billing_mode) || "prorated_immediately"
+        )
+        update(processor_plan: plan, ends_at: nil, status: :active)
       end
 
       # Retries the latest invoice for a Past Due subscription
@@ -187,3 +182,5 @@ module Pay
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_paddle_billing_subscription, Pay::PaddleBilling::Subscription

data/{lib → app/models}/pay/paddle_classic/charge.rb

@@ -1,35 +1,32 @@
 module Pay
   module PaddleClassic
-    class Charge
-      attr_reader :pay_charge
+    class Charge < Pay::Charge
+      store_accessor :data, :paddle_receipt_url
 
-      delegate :processor_id, :customer, to: :pay_charge
-
-      def initialize(pay_charge)
-        @pay_charge = pay_charge
-      end
-
-      def charge
+      def api_record
         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
+      rescue ::Paddle::Classic::Error => e
         raise Pay::PaddleClassic::Error, e
       end
 
-      def refund!(amount_to_refund)
+      def refund!(amount_to_refund = nil)
         return unless customer.subscription
+        amount_to_refund ||= amount
+
         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 Error, "Payment not found" unless payments.total > 0
+
+        PaddleClassic.client.payments.refund(order_id: payments.data.last[:id], amount: amount_to_refund)
+        update(amount_refunded: amount_to_refund)
+      rescue ::Paddle::Classic::Error => e
         raise Pay::PaddleClassic::Error, e
       end
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_paddle_classic_charge, Pay::PaddleClassic::Charge

data/{lib/pay/paddle_classic/billable.rb → app/models/pay/paddle_classic/customer.rb}

@@ -1,29 +1,18 @@
 module Pay
   module PaddleClassic
-    class Billable
-      attr_reader :pay_customer
+    class Customer < Pay::Customer
+      has_many :charges, dependent: :destroy, class_name: "Pay::PaddleClassic::Charge"
+      has_many :subscriptions, dependent: :destroy, class_name: "Pay::PaddleClassic::Subscription"
+      has_many :payment_methods, dependent: :destroy, class_name: "Pay::PaddleClassic::PaymentMethod"
+      has_one :default_payment_method, -> { where(default: true) }, class_name: "Pay::PaddleClassic::PaymentMethod"
 
-      delegate :processor_id,
-        :processor_id?,
-        :email,
-        :customer_name,
-        :card_token,
-        to: :pay_customer
-
-      def initialize(pay_customer)
-        @pay_customer = pay_customer
-      end
-
-      def customer
-        # pass
+      def api_record
       end
 
-      def update_customer!
-        # pass
+      def update_api_record
       end
 
       def charge(amount, options = {})
-        subscription = pay_customer.subscription
         return unless subscription.processor_id
         raise Pay::Error, "A charge_name is required to create a one-time charge" if options[:charge_name].nil?
 
@@ -38,7 +27,7 @@ module Pay
         # Lookup subscription payment method details
         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 = charges.find_or_initialize_by(processor_id: response[:invoice_id])
         charge.update(attributes)
         charge
       rescue ::Paddle::Error => e
@@ -52,19 +41,10 @@ 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::PaddleClassic::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 = {})
-        PaddleClassic.client.users.list(subscription_id: subscription_id).data.try(:first)
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleClassic::Error, e
+        Pay::PaddleClassic::PaymentMethod.sync(pay_customer: self)
       end
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_paddle_classic_customer, Pay::PaddleClassic::Customer

data/{lib → app/models}/pay/paddle_classic/payment_method.rb

@@ -1,10 +1,6 @@
 module Pay
   module PaddleClassic
-    class PaymentMethod
-      attr_reader :pay_payment_method
-
-      delegate :customer, :processor_id, to: :pay_payment_method
-
+    class PaymentMethod < Pay::PaymentMethod
       # Paddle doesn't provide PaymentMethod IDs, so we have to lookup via the Customer
       def self.sync(pay_customer:, attributes: nil)
         return unless pay_customer.subscription
@@ -44,17 +40,13 @@ module Pay
         end
       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
+
+ActiveSupport.run_load_hooks :pay_paddle_classic_payment_method, Pay::PaddleClassic::PaymentMethod