pay 7.3.0 → 8.0.0

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

@@ -1,32 +1,23 @@
 module Pay
   module FakeProcessor
-    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
-        pay_customer.update!(processor_id: NanoId.generate) unless processor_id?
-        pay_customer
+    class Customer < Pay::Customer
+      has_many :charges, dependent: :destroy, class_name: "Pay::FakeProcessor::Charge"
+      has_many :subscriptions, dependent: :destroy, class_name: "Pay::FakeProcessor::Subscription"
+      has_many :payment_methods, dependent: :destroy, class_name: "Pay::FakeProcessor::PaymentMethod"
+      has_one :default_payment_method, -> { where(default: true) }, class_name: "Pay::FakeProcessor::PaymentMethod"
+
+      def api_record
+        update!(processor_id: NanoId.generate) unless processor_id?
+        self
       end
 
-      def update_customer!(**attributes)
-        # return customer to fake an update
-        customer
+      def update_api_record(**attributes)
+        self
       end
 
       def charge(amount, options = {})
         # Make to generate a processor_id
-        customer
+        api_record
 
         valid_attributes = options.slice(*Pay::Charge.attribute_names.map(&:to_sym))
         attributes = {
@@ -40,12 +31,12 @@ module Pay
             exp_year: Date.today.year
           }
         }.deep_merge(valid_attributes)
-        pay_customer.charges.create!(attributes)
+        charges.create!(attributes)
       end
 
       def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
         # Make to generate a processor_id
-        customer
+        api_record
         attributes = options.merge(
           processor_id: NanoId.generate,
           name: name,
@@ -60,17 +51,17 @@ module Pay
 
         attributes.delete(:promotion_code)
 
-        pay_customer.subscriptions.create!(attributes)
+        subscriptions.create!(attributes)
       end
 
       def add_payment_method(payment_method_id, default: false)
         # Make to generate a processor_id
-        customer
+        api_record
 
-        pay_payment_method = pay_customer.payment_methods.create!(
+        pay_payment_method = payment_methods.create!(
           processor_id: NanoId.generate,
           default: default,
-          type: :card,
+          payment_method_type: :card,
           data: {
             brand: "Fake",
             last4: 1234,
@@ -80,20 +71,12 @@ module Pay
         )
 
         if default
-          pay_customer.payment_methods.where.not(id: pay_payment_method.id).update_all(default: false)
-          pay_customer.reload_default_payment_method
+          payment_methods.where.not(id: pay_payment_method.id).update_all(default: false)
+          reload_default_payment_method
         end
 
         pay_payment_method
       end
-
-      def processor_subscription(subscription_id, options = {})
-        pay_customer.subscriptions.find_by(processor_id: subscription_id)
-      end
-
-      def trial_end_date(subscription)
-        Date.today
-      end
     end
   end
 end

data/{lib → app/models}/pay/fake_processor/merchant.rb

@@ -1,16 +1,9 @@
 module Pay
   module FakeProcessor
-    class Merchant
-      attr_reader :pay_merchant
-      delegate :processor_id, to: :pay_merchant
-
-      def initialize(pay_merchant)
-        @pay_merchant = pay_merchant
-      end
-
+    class Merchant < Pay::Merchant
       def create_account(**options)
         fake_account = Struct.new(:id).new("fake_account_id")
-        pay_merchant.update(processor_id: fake_account.id)
+        update(processor_id: fake_account.id)
         fake_account
       end
 

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

@@ -0,0 +1,11 @@
+module Pay
+  module FakeProcessor
+    class PaymentMethod < Pay::PaymentMethod
+      def make_default!
+      end
+
+      def detach
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module Pay
+  module FakeProcessor
+    class Subscription < Pay::Subscription
+      def api_record(**options)
+        self
+      end
+
+      # With trial, sets end to trial end (mimicing Stripe)
+      # Without trial, sets can ends_at to end of month
+      def cancel(**options)
+        return if canceled?
+        update(ends_at: (on_trial? ? trial_ends_at : Time.current.end_of_month))
+      end
+
+      def cancel_now!(**options)
+        return if canceled?
+
+        ends_at = Time.current
+        update(
+          status: :canceled,
+          trial_ends_at: (ends_at if trial_ends_at?),
+          ends_at: ends_at
+        )
+      end
+
+      def paused?
+        status == "paused"
+      end
+
+      def pause
+        update(status: :paused, trial_ends_at: Time.current)
+      end
+
+      def resumable?
+        on_grace_period? || paused?
+      end
+
+      def resume
+        unless resumable?
+          raise StandardError, "You can only resume subscriptions within their grace period."
+        end
+
+        update(status: :active, trial_ends_at: nil, ends_at: nil)
+      end
+
+      def swap(plan, **options)
+        update(processor_plan: plan, ends_at: nil, status: :active)
+      end
+
+      def change_quantity(quantity, **options)
+        update(quantity: quantity)
+      end
+
+      # Retries the latest invoice for a Past Due subscription
+      def retry_failed_payment
+        update(status: :active)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Pay
+  module LemonSqueezy
+    class Charge < Pay::Charge
+      # LemonSqueezy uses Order for one-time payments and Order + Subscription + SubscriptionInvoice for subscriptions
+
+      def self.sync_order(order_id, object: nil, try: 0, retries: 1)
+        object ||= ::LemonSqueezy::Order.retrieve(id: order_id)
+
+        pay_customer = Pay::Customer.find_by(type: "Pay::LemonSqueezy::Customer", processor_id: object.customer_id)
+        return unless pay_customer
+
+        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)
+        }
+
+        # 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
+      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::Customer.find_by(type: "Pay::LemonSqueezy::Customer", processor_id: object.customer_id)
+        return unless pay_customer
+
+        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)
+        }
+
+        # Update customer's payment method
+        Pay::LemonSqueezy::PaymentMethod.sync(pay_customer: pay_customer, attributes: object)
+
+        # 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
+      end
+
+      def api_record
+        ls_type, ls_id = processor_id.split(":", 2)
+        case ls_type
+        when "order"
+          ::LemonSqueezy::Order.retrieve(id: ls_id)
+        when "subscription_invoice"
+          ::LemonSqueezy::SubscriptionInvoice.retrieve(id: ls_id)
+        end
+      rescue ::LemonSqueezy::Error => e
+        raise Pay::LemonSqueezy::Error, e
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module Pay
+  module LemonSqueezy
+    class Customer < Pay::Customer
+      include Pay::Routing
+
+      has_many :charges, dependent: :destroy, class_name: "Pay::LemonSqueezy::Charge"
+      has_many :subscriptions, dependent: :destroy, class_name: "Pay::LemonSqueezy::Subscription"
+      has_many :payment_methods, dependent: :destroy, class_name: "Pay::LemonSqueezy::PaymentMethod"
+      has_one :default_payment_method, -> { where(default: true) }, class_name: "Pay::LemonSqueezy::PaymentMethod"
+
+      def api_record_attributes
+        {email: email, name: customer_name}
+      end
+
+      # Retrieves a LemonSqueezy::Customer object
+      #
+      # Finds an existing LemonSqueezy::Customer if processor_id exists
+      # Creates a new LemonSqueezy::Customer using `email` and `customer_name` if empty processor_id
+      #
+      # Returns a LemonSqueezy::Customer object
+      def api_record
+        if processor_id?
+          ::LemonSqueezy::Customer.retrieve(id: processor_id)
+        elsif (lsc = ::LemonSqueezy::Customer.list(store_id: Pay::LemonSqueezy.store_id, email: email).data.first)
+          update!(processor_id: lsc.id)
+          lsc
+        else
+          lsc = ::LemonSqueezy::Customer.create(store_id: Pay::LemonSqueezy.store_id, **api_record_attributes)
+          update!(processor_id: lsc.id)
+          lsc
+        end
+      rescue ::LemonSqueezy::Error => e
+        raise Pay::LemonSqueezy::Error, e
+      end
+
+      # Syncs name and email to LemonSqueezy::Customer
+      # You can also pass in other attributes that will be merged into the default attributes
+      def update_api_record(**attributes)
+        api_record unless processor_id?
+        ::LemonSqueezy::Customer.update(id: processor_id, **api_record_attributes.merge(attributes))
+      end
+
+      def charge(amount, options = {})
+        raise Pay::Error, "LemonSqueezy does not support one-off charges"
+      end
+
+      def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
+      end
+
+      def add_payment_method(token = nil, default: true)
+      end
+
+      # checkout(variant_id: "1234")
+      # checkout(variant_id: "1234", product_options: {redirect_url: redirect_url})
+      def checkout(**options)
+        api_record unless processor_id?
+
+        options[:store_id] = Pay::LemonSqueezy.store_id
+        options[:product_options] ||= {}
+        options[:product_options][:redirect_url] = merge_order_id_param(options.dig(:product_options, :redirect_url) || root_url)
+
+        ::LemonSqueezy::Checkout.create(**options)
+      end
+
+      def portal_url
+        api_record.urls.customer_portal
+      end
+
+      private
+
+      def merge_order_id_param(url)
+        uri = URI.parse(url)
+        uri.query = URI.encode_www_form(URI.decode_www_form(uri.query.to_s).to_h.merge("lemon_squeezy_order_id" => "[order_id]").to_a)
+        uri.to_s.gsub("%5Border_id%5D", "[order_id]")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Pay
+  module LemonSqueezy
+    class PaymentMethod < Pay::PaymentMethod
+      def self.sync(pay_customer:, attributes:)
+        return unless pay_customer.subscription
+
+        payment_method = pay_customer.default_payment_method || pay_customer.build_default_payment_method
+        payment_method.processor_id ||= NanoId.generate
+
+        attrs = {
+          payment_method_type: "card",
+          brand: attributes.card_brand,
+          last4: attributes.card_last_four
+        }
+
+        payment_method.update!(attrs)
+        payment_method
+      end
+
+      def make_default!
+      end
+
+      def detach
+      end
+    end
+  end
+end

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 = pay_customer.subscriptions.find_by(processor_id: object.id))
+          pay_subscription.with_lock do
+            pay_subscription.update!(attributes)
+          end
+          pay_subscription
+        else
+          pay_customer.subscriptions.create!(attributes.merge(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 StandardError, "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 StandardError, "A plan_id is required to swap a subscription" unless plan
+        raise StandardError, "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

data/app/models/pay/merchant.rb

@@ -6,17 +6,6 @@ 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

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

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: sc.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,18 +66,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::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

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"
@@ -15,7 +11,7 @@ module Pay
       def self.sync(pay_customer:, attributes:)
         details = attributes.method_details
         attrs = {
-          type: details.type.downcase
+          payment_method_type: details.type.downcase
         }
 
         case details.type.downcase
@@ -31,15 +27,9 @@ module Pay
         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