pay 7.3.0 → 11.2.2

data/app/models/pay/charge.rb

@@ -1,7 +1,5 @@
 module Pay
   class Charge < Pay::ApplicationRecord
-    self.inheritance_column = nil
-
     # Associations
     belongs_to :customer
     belongs_to :subscription, optional: true
@@ -15,9 +13,7 @@ module Pay
     validates :amount, presence: true
     validates :processor_id, presence: true, uniqueness: {scope: :customer_id, case_sensitive: true}
 
-    # Store the payment method kind (card, paypal, etc)
-    store_accessor :data, :paddle_receipt_url
-    store_accessor :data, :stripe_receipt_url
+    delegate :owner, to: :customer
 
     # Payment method attributes
     store_accessor :data, :payment_method_type # card, paypal, sepa, etc
@@ -29,22 +25,11 @@ module Pay
     store_accessor :data, :username # Venmo
     store_accessor :data, :bank
 
-    store_accessor :data, :amount_captured
-    store_accessor :data, :invoice_id
-    store_accessor :data, :payment_intent_id
-    store_accessor :data, :period_start
-    store_accessor :data, :period_end
-    store_accessor :data, :line_items
-    store_accessor :data, :subtotal # subtotal amount in cents
-    store_accessor :data, :tax # total tax amount in cents
-    store_accessor :data, :discounts # array of discount IDs applied to the Stripe Invoice
-    store_accessor :data, :total_discount_amounts # array of discount details
-    store_accessor :data, :total_tax_amounts # array of tax details for each jurisdiction
-    store_accessor :data, :credit_notes # array of credit notes for the Stripe Invoice
-    store_accessor :data, :refunds # array of refunds
+    store_accessor :data, :subtotal
+    store_accessor :data, :tax
 
     # Helpers for payment processors
-    %w[braintree stripe paddle_billing paddle_classic fake_processor].each do |processor_name|
+    %w[braintree stripe paddle_billing paddle_classic lemon_squeezy fake_processor].each do |processor_name|
       define_method :"#{processor_name}?" do
         customer.processor == processor_name
       end
@@ -52,31 +37,13 @@ module Pay
       scope processor_name, -> { joins(:customer).where(pay_customers: {processor: processor_name}) }
     end
 
-    delegate :capture, :credit_note!, :credit_notes, to: :payment_processor
-
     def self.find_by_processor_and_id(processor, processor_id)
       joins(:customer).find_by(processor_id: processor_id, pay_customers: {processor: processor})
     end
 
-    def self.pay_processor_for(name)
-      "Pay::#{name.to_s.classify}::Charge".constantize
-    end
-
-    def payment_processor
-      @payment_processor ||= self.class.pay_processor_for(customer.processor).new(self)
-    end
-
-    def processor_charge
-      payment_processor.charge
-    end
-
-    def captured?
-      amount_captured > 0
-    end
-
-    def refund!(refund_amount = nil)
-      refund_amount ||= amount
-      payment_processor.refund!(refund_amount)
+    def sync!(**options)
+      self.class.sync(processor_id, **options)
+      reload
     end
 
     def refunded?
@@ -104,7 +71,13 @@ module Pay
       when "card"
         "#{brand.titleize} (**** **** **** #{last4})"
       when "paypal"
-        "#{brand} (#{email})"
+        # Sometimes brand and email are missing (Stripe)
+        brand ||= "PayPal"
+        if email.present?
+          brand + " (#{email})"
+        else
+          brand
+        end
 
       # Braintree
       when "venmo"
@@ -131,9 +104,7 @@ module Pay
         payment_method_type&.titleize
       end
     end
-
-    def line_items
-      Array.wrap(super)
-    end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_charge, Pay::Charge

data/app/models/pay/customer.rb

@@ -13,8 +13,6 @@ module Pay
     validates :processor, presence: true
     validates :processor_id, allow_blank: true, uniqueness: {scope: :processor, case_sensitive: true}
 
-    attribute :payment_method_token, :string
-
     # Account(s) for marketplace payments
     store_accessor :data, :braintree_account
 
@@ -22,10 +20,9 @@ module Pay
     store_accessor :data, :invoice_credit_balance
     store_accessor :data, :currency
 
-    delegate :email, to: :owner
-    delegate_missing_to :pay_processor
+    delegate :email, to: :owner, allow_nil: true
 
-    %w[stripe braintree paddle_billing paddle_classic fake_processor].each do |processor_name|
+    %w[stripe braintree paddle_billing paddle_classic lemon_squeezy fake_processor].each do |processor_name|
       scope processor_name, -> { where(processor: processor_name) }
 
       define_method :"#{processor_name}?" do
@@ -33,15 +30,6 @@ module Pay
       end
     end
 
-    def self.pay_processor_for(name)
-      "Pay::#{name.to_s.classify}::Billable".constantize
-    end
-
-    def pay_processor
-      return if processor.blank?
-      @pay_processor ||= self.class.pay_processor_for(processor).new(self)
-    end
-
     def update_payment_method(payment_method_id)
       add_payment_method(payment_method_id, default: true)
     end
@@ -51,8 +39,7 @@ module Pay
     end
 
     def subscribed?(name: Pay.default_product_name, processor_plan: nil)
-      query = {name: name, processor_plan: processor_plan}.compact
-      subscriptions.active.where(query).exists?
+      subscriptions.active.where({name: name, processor_plan: processor_plan}.compact).exists?
     end
 
     def on_trial?(name: Pay.default_product_name, plan: nil)
@@ -101,3 +88,5 @@ module Pay
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_customer, Pay::Customer

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

@@ -0,0 +1,19 @@
+module Pay
+  module FakeProcessor
+    class Charge < Pay::Charge
+      def self.sync(processor_id)
+        true
+      end
+
+      def api_record
+        self
+      end
+
+      def refund!(amount_to_refund = nil)
+        update(amount_refunded: amount_to_refund || amount)
+      end
+    end
+  end
+end
+
+ActiveSupport.run_load_hooks :pay_fake_processor_charge, Pay::FakeProcessor::Charge

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,
@@ -58,19 +49,24 @@ module Pay
           attributes[:trial_ends_at] = trial_period_days.to_i.days.from_now
         end
 
-        attributes.delete(:promotion_code)
+        # Ignore any keys that aren't attribute names
+        attributes.deep_stringify_keys!.slice!(*subscriptions.attribute_names)
+
+        subscriptions.create!(attributes)
+      end
 
-        pay_customer.subscriptions.create!(attributes)
+      def sync_subscriptions(**options)
+        []
       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 +76,14 @@ 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
+
+ActiveSupport.run_load_hooks :pay_fake_processor_customer, Pay::FakeProcessor::Customer

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
 
@@ -24,3 +17,5 @@ module Pay
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_fake_processor_merchant, Pay::FakeProcessor::Merchant

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

@@ -0,0 +1,13 @@
+module Pay
+  module FakeProcessor
+    class PaymentMethod < Pay::PaymentMethod
+      def make_default!
+      end
+
+      def detach
+      end
+    end
+  end
+end
+
+ActiveSupport.run_load_hooks :pay_fake_processor_payment_method, Pay::FakeProcessor::PaymentMethod

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

@@ -0,0 +1,70 @@
+module Pay
+  module FakeProcessor
+    class Subscription < Pay::Subscription
+      def self.sync(processor_id, **options)
+        # Bypass sync operation for FakeProcessor
+      end
+
+      def api_record(**options)
+        self
+      end
+
+      # With trial, sets end to trial end (mimicking 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?
+        if data&.has_key?("resumable")
+          data["resumable"]
+        else
+          on_grace_period? || paused?
+        end
+      end
+
+      def resume
+        unless resumable?
+          raise Error, "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
+
+ActiveSupport.run_load_hooks :pay_fake_processor_subscription, Pay::FakeProcessor::Subscription

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

@@ -0,0 +1,96 @@
+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 = 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
+
+      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 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
+
+      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
+
+ActiveSupport.run_load_hooks :pay_lemon_squeezy_charge, Pay::LemonSqueezy::Charge

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

@@ -0,0 +1,80 @@
+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
+
+ActiveSupport.run_load_hooks :pay_lemon_squeezy_customer, Pay::LemonSqueezy::Customer

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

@@ -0,0 +1,29 @@
+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
+
+ActiveSupport.run_load_hooks :pay_lemon_squeezy_payment_method, Pay::LemonSqueezy::PaymentMethod