pay 7.3.0 → 8.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ec013c6c05d0e8027b628258882c9bac3a01f7942e9654cc52582643cf57629
-  data.tar.gz: 75bcbbfcd8b63bb0f73e97b4a4da41335923f5f3af2e8577fc1f2aa94baa8542
+  metadata.gz: 5fe510d1e6a11611a8cd4678e965e1051f6e69ad6c404f55c3fa96312dfff51a
+  data.tar.gz: 54b73170c35476916fd17dc4ca11a7bc5d117888a04385e0947ef26dfd069e8f
 SHA512:
-  metadata.gz: dd2822689a009a126f016365182312e4555098ba40b429e16c1dc41b76902a4fd18da06e3465b25cf17e0bf53371adf147bfd3c72e2c9186ce965de304f403e4
-  data.tar.gz: 1ad32b2e21be33e58ffb855dec4275cdff66d036a1728f2573d54d61a2937c6aa6c4602cb59f1dc53bea2edcd4fac46f89efcb91a5ea22443669087569959e5b
+  metadata.gz: b55b7a23acd69d6f1a795805ba707f3cdbbceca636359ea509419a7a547764e048ce3c36c82f58b0fd34a97e2dac0561b76266ae42b7d62f39d6d9ce38f25944
+  data.tar.gz: ed7f92af40c8bfe066668a8c20212df7c316eb237db7091a5d44ca60e728c037e12d5e846ec6e4b87b3087cf22733568f101ceda2132ff945367b9245a46975a

data/README.md

@@ -23,6 +23,7 @@ Our supported payment processors are:
 - Stripe ([SCA Compatible](https://stripe.com/docs/strong-customer-authentication) using API version `2022-11-15`)
 - Paddle (SCA Compatible & supports PayPal)
 - Braintree (supports PayPal)
+- Lemon Squeezy (supports PayPal)
 - [Fake Processor](docs/fake_processor/1_overview.md) (used for generic trials without cards, free subscriptions, testing, etc)
 
 Want to add a new payment provider? Contributions are welcome.
@@ -45,6 +46,7 @@ Want to add a new payment provider? Contributions are welcome.
   * [Stripe](docs/stripe/1_overview.md)
   * [Braintree](docs/braintree/1_overview.md)
   * [Paddle](docs/paddle_billing/1_overview.md)
+  * [Lemon Squeezy](docs/lemon_squeezy/1_overview.md)
   * [Fake Processor](docs/fake_processor/1_overview.md)
 * **Marketplaces**
   * [Stripe Connect](docs/marketplaces/stripe_connect.md)

data/app/controllers/pay/webhooks/lemon_squeezy_controller.rb

@@ -0,0 +1,45 @@
+module Pay
+  module Webhooks
+    class LemonSqueezyController < Pay::ApplicationController
+      if Rails.application.config.action_controller.default_protect_from_forgery
+        skip_before_action :verify_authenticity_token
+      end
+
+      def create
+        if valid_signature?(request.headers["X-Signature"])
+          queue_event(verify_params.as_json)
+          head :ok
+        else
+          head :bad_request
+        end
+      rescue Pay::LemonSqueezy::Error
+        head :bad_request
+      end
+
+      private
+
+      def queue_event(event)
+        return unless Pay::Webhooks.delegator.listening?("lemon_squeezy.#{params[:meta][:event_name]}")
+
+        record = Pay::Webhook.create!(processor: :lemon_squeezy, event_type: params[:meta][:event_name], event: event)
+        Pay::Webhooks::ProcessJob.perform_later(record)
+      end
+
+      # Pass Lemon Squeezy signature from request.headers["X-Signature"]
+      def valid_signature?(signature)
+        return false if signature.blank?
+
+        key = Pay::LemonSqueezy.signing_secret
+        data = request.raw_post
+        digest = OpenSSL::Digest.new("sha256")
+
+        hmac = OpenSSL::HMAC.hexdigest(digest, key, data)
+        ActiveSupport::SecurityUtils.secure_compare(hmac, signature)
+      end
+
+      def verify_params
+        params.except(:action, :controller).permit!
+      end
+    end
+  end
+end

data/app/jobs/pay/customer_sync_job.rb

@@ -1,7 +1,7 @@
 module Pay
   class CustomerSyncJob < ApplicationJob
     def perform(pay_customer_id)
-      Pay::Customer.find(pay_customer_id).update_customer!
+      Pay::Customer.find(pay_customer_id).update_api_record
     rescue ActiveRecord::RecordNotFound
       Rails.logger.info "Couldn't find a Pay::Customer with ID = #{pay_customer_id}"
     end

data/app/models/concerns/pay/routing.rb

@@ -0,0 +1,13 @@
+module Pay
+  module Routing
+    extend ActiveSupport::Concern
+
+    included do
+      include Rails.application.routes.url_helpers
+    end
+
+    def default_url_options
+      Rails.application.config.action_mailer.default_url_options || {}
+    end
+  end
+end

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

@@ -1,10 +1,6 @@
 module Pay
   module Braintree
-    class Charge
-      attr_reader :pay_charge
-
-      delegate :processor_id, to: :pay_charge
-
+    class Charge < Pay::Charge
       def self.sync(charge_id, object: nil, try: 0, retries: 1)
         object ||= Pay.braintree_gateway.transaction.find(charge_id)
 
@@ -22,19 +18,16 @@ module Pay
         end
       end
 
-      def initialize(pay_charge)
-        @pay_charge = pay_charge
-      end
-
-      def charge
+      def api_record
         Pay.braintree_gateway.transaction.find(processor_id)
       rescue ::Braintree::Braintree::Error => e
         raise Pay::Braintree::Error, e
       end
 
-      def refund!(amount_to_refund)
+      def refund!(amount_to_refund = nil)
+        amount_to_refund ||= amount
         Pay.braintree_gateway.transaction.refund(processor_id, amount_to_refund / 100.0)
-        pay_charge.update(amount_refunded: amount_to_refund)
+        update(amount_refunded: amount_to_refund)
       rescue ::Braintree::BraintreeError => e
         raise Pay::Braintree::Error, e
       end

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

@@ -1,62 +1,34 @@
 module Pay
   module Braintree
-    class Billable
-      attr_reader :pay_customer
-
-      delegate :processor_id,
-        :processor_id?,
-        :email,
-        :customer_name,
-        :payment_method_token,
-        :payment_method_token?,
-        to: :pay_customer
-
-      def initialize(pay_customer)
-        @pay_customer = pay_customer
-      end
+    class Customer < Pay::Customer
+      has_many :charges, dependent: :destroy, class_name: "Pay::Braintree::Charge"
+      has_many :subscriptions, dependent: :destroy, class_name: "Pay::Braintree::Subscription"
+      has_many :payment_methods, dependent: :destroy, class_name: "Pay::Braintree::PaymentMethod"
+      has_one :default_payment_method, -> { where(default: true) }, class_name: "Pay::Braintree::PaymentMethod"
 
       # Returns a hash of attributes for the Stripe::Customer object
-      def customer_attributes
-        owner = pay_customer.owner
-
+      def api_record_attributes
         attributes = case owner.class.pay_braintree_customer_attributes
         when Symbol
-          owner.send(owner.class.pay_braintree_customer_attributes, pay_customer)
+          owner.send(owner.class.pay_braintree_customer_attributes, self)
         when Proc
-          owner.class.pay_braintree_customer_attributes.call(pay_customer)
+          owner.class.pay_braintree_customer_attributes.call(self)
         end
 
-        # Guard against attributes being returned nil
-        attributes ||= {}
-
         first_name, last_name = customer_name.split(" ", 2)
-        {email: email, first_name: first_name, last_name: last_name}.merge(attributes)
+        {email: email, first_name: first_name, last_name: last_name}.merge(attributes || {})
       end
 
       # Retrieve the Braintree::Customer object
       #
       # - If no processor_id is present, creates a Customer.
-      # - When 'payment_method_token' is present, it will also set the default payment method
-      def customer
+      def api_record
         if processor_id?
-          customer = gateway.customer.find(processor_id)
-
-          if payment_method_token?
-            add_payment_method(payment_method_token, default: true)
-            pay_customer.payment_method_token = nil
-          end
-
-          customer
+          gateway.customer.find(processor_id)
         else
-          result = gateway.customer.create(customer_attributes.merge(payment_method_nonce: payment_method_token))
+          result = gateway.customer.create(api_record_attributes)
           raise Pay::Braintree::Error, result unless result.success?
-          pay_customer.update!(processor_id: result.customer.id)
-
-          if payment_method_token?
-            save_payment_method(result.customer.payment_methods.last, default: true)
-            pay_customer.payment_method_token = nil
-          end
-
+          update!(processor_id: result.customer.id)
           result.customer
         end
       rescue ::Braintree::AuthorizationError => e
@@ -67,15 +39,15 @@ module Pay
 
       # Syncs name and email to Braintree::Customer
       # You can also pass in other attributes that will be merged into the default attributes
-      def update_customer!(**attributes)
-        customer unless processor_id?
-        gateway.customer.update(processor_id, customer_attributes.merge(attributes))
+      def update_api_record(**attributes)
+        api_record unless processor_id?
+        gateway.customer.update(processor_id, api_record_attributes.merge(attributes))
       end
 
       def charge(amount, options = {})
         args = {
           amount: amount.to_i / 100.0,
-          customer_id: customer.id,
+          customer_id: processor_id || api_record.id,
           options: {submit_for_settlement: true},
           custom_fields: options.delete(:metadata)
         }.merge(options)
@@ -91,7 +63,7 @@ module Pay
       end
 
       def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
-        token = customer.payment_methods.find(&:default?).try(:token)
+        token = api_record.payment_methods.find(&:default?).try(:token)
         raise Pay::Error, "Customer has no default payment method" if token.nil?
 
         # Standardize the trial period options
@@ -100,20 +72,20 @@ module Pay
         end
 
         metadata = options.delete(:metadata)
-        subscription_options = options.merge(
-          payment_method_token: token,
-          plan_id: plan
-        )
+        subscription_options = options.merge(payment_method_token: token, plan_id: plan)
 
         result = gateway.subscription.create(subscription_options)
         raise Pay::Braintree::Error, result unless result.success?
 
-        subscription = pay_customer.subscriptions.create!(
+        # Braintree returns dates without time zones, so we'll assume they're UTC
+        trial_end_date = result.subscription.trial_period.present? ? result.subscription.first_billing_date.end_of_day : nil
+
+        subscription = subscriptions.create!(
           name: name,
           processor_id: result.subscription.id,
           processor_plan: plan,
           status: :active,
-          trial_ends_at: trial_end_date(result.subscription),
+          trial_ends_at: trial_end_date,
           ends_at: nil,
           metadata: metadata
         )
@@ -130,10 +102,8 @@ module Pay
       end
 
       def add_payment_method(token, default: false)
-        customer unless processor_id?
-
         result = gateway.payment_method.create(
-          customer_id: processor_id,
+          customer_id: processor_id || api_record.id,
           payment_method_nonce: token,
           options: {
             make_default: default,
@@ -145,7 +115,7 @@ module Pay
         pay_payment_method = save_payment_method(result.payment_method, default: default)
 
         # Update existing subscriptions to the new payment method
-        pay_customer.subscriptions.each do |subscription|
+        subscriptions.each do |subscription|
           if subscription.active?
             gateway.subscription.update(subscription.processor_id, {payment_method_token: token})
           end
@@ -158,16 +128,6 @@ module Pay
         raise Pay::Braintree::Error, e
       end
 
-      def trial_end_date(subscription)
-        return unless subscription.trial_period
-        # Braintree returns dates without time zones, so we'll assume they're UTC
-        subscription.first_billing_date.end_of_day
-      end
-
-      def processor_subscription(subscription_id, options = {})
-        gateway.subscription.find(subscription_id)
-      end
-
       def save_transaction(transaction)
         attrs = card_details_for_braintree_transaction(transaction)
         attrs[:amount] = transaction.amount.to_f * 100
@@ -178,7 +138,7 @@ module Pay
 
         # Associate charge with subscription if we can
         if transaction.subscription_id
-          pay_subscription = pay_customer.subscriptions.find_by(processor_id: transaction.subscription_id)
+          pay_subscription = subscriptions.find_by(processor_id: transaction.subscription_id)
           pay_subscription ||= Pay::Braintree::Subscription.sync(transaction.subscription_id)
 
           if pay_subscription
@@ -187,7 +147,7 @@ module Pay
           end
         end
 
-        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
       end
@@ -238,13 +198,13 @@ module Pay
           }
         end
 
-        pay_payment_method = pay_customer.payment_methods.where(processor_id: payment_method.token).first_or_initialize
+        pay_payment_method = payment_methods.where(processor_id: payment_method.token).first_or_initialize
 
-        pay_customer.payment_methods.update_all(default: false) if default
+        payment_methods.update_all(default: false) if default
         pay_payment_method.update!(attributes.merge(default: default))
 
         # Reload the Rails association
-        pay_customer.reload_default_payment_method if default
+        reload_default_payment_method if default
 
         pay_payment_method
       end

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

@@ -1,10 +1,6 @@
 module Pay
   module Braintree
-    class PaymentMethod
-      attr_reader :pay_payment_method
-
-      delegate :customer, :processor_id, to: :pay_payment_method
-
+    class PaymentMethod < Pay::PaymentMethod
       def self.sync(id, object: nil, try: 0, retries: 1)
         object ||= Pay.braintree_gateway.payment_method.find(id)
 
@@ -14,10 +10,6 @@ module Pay
         pay_customer.save_payment_method(object, default: object.default?)
       end
 
-      def initialize(pay_payment_method)
-        @pay_payment_method = pay_payment_method
-      end
-
       # Sets payment method as default on Stripe
       def make_default!
         result = gateway.customer.update(customer.processor_id, default_payment_method_token: processor_id)

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

@@ -1,25 +1,6 @@
 module Pay
   module Braintree
-    class Subscription
-      attr_reader :pay_subscription
-
-      delegate :active?,
-        :canceled?,
-        :ends_at?,
-        :customer,
-        :ends_at,
-        :name,
-        :on_trial?,
-        :processor_id,
-        :processor_plan,
-        :processor_subscription,
-        :prorate,
-        :prorate?,
-        :quantity,
-        :quantity?,
-        :trial_ends_at,
-        to: :pay_subscription
-
+    class Subscription < Pay::Subscription
       def self.sync(subscription_id, object: nil, name: nil, try: 0, retries: 1)
         object ||= Pay.braintree_gateway.subscription.find(subscription_id)
 
@@ -69,11 +50,7 @@ module Pay
         end
       end
 
-      def initialize(pay_subscription)
-        @pay_subscription = pay_subscription
-      end
-
-      def subscription(**options)
+      def api_record(**options)
         gateway.subscription.find(processor_id)
       end
 
@@ -84,11 +61,9 @@ module Pay
         result = if on_trial?
           gateway.subscription.cancel(processor_id)
         else
-          gateway.subscription.update(subscription.id, {
-            number_of_billing_cycles: subscription.current_billing_cycle
-          })
+          gateway.subscription.update(processor_id, {number_of_billing_cycles: api_record.current_billing_cycle})
         end
-        pay_subscription.sync!(object: result.subscription)
+        sync!(object: result.subscription)
       rescue ::Braintree::BraintreeError => e
         raise Pay::Braintree::Error, e
       end
@@ -97,7 +72,7 @@ module Pay
         return if canceled?
 
         result = gateway.subscription.cancel(processor_id)
-        pay_subscription.sync!(object: result.subscription)
+        sync!(object: result.subscription)
       rescue ::Braintree::BraintreeError => e
         raise Pay::Braintree::Error, e
       end
@@ -106,10 +81,6 @@ module Pay
         raise NotImplementedError, "Braintree does not support setting quantity on subscriptions"
       end
 
-      def on_grace_period?
-        ends_at? && ends_at > Time.current
-      end
-
       def paused?
         false
       end
@@ -138,15 +109,13 @@ module Pay
             trial_duration_unit: :day
           )
         else
-          subscription = processor_subscription
-
-          gateway.subscription.update(subscription.id, {
+          gateway.subscription.update(processor_id, {
             never_expires: true,
             number_of_billing_cycles: nil
           })
         end
 
-        pay_subscription.update(status: :active)
+        update(ends_at: nil, status: :active)
       rescue ::Braintree::BraintreeError => e
         raise Pay::Braintree::Error, e
       end
@@ -171,9 +140,7 @@ module Pay
           return
         end
 
-        subscription = processor_subscription
-
-        result = gateway.subscription.update(subscription.id, {
+        result = gateway.subscription.update(processor_id, {
           plan_id: braintree_plan.id,
           price: braintree_plan.price,
           never_expires: true,
@@ -184,7 +151,7 @@ module Pay
         })
         raise Error, "Braintree failed to swap plans: #{result.message}" unless result.success?
 
-        pay_subscription.update(processor_plan: plan, ends_at: nil, status: :active)
+        update(processor_plan: plan, ends_at: nil, status: :active)
       rescue ::Braintree::BraintreeError => e
         raise Pay::Braintree::Error, e
       end
@@ -198,7 +165,7 @@ module Pay
         )
 
         if result.success?
-          pay_subscription.update(status: :active)
+          update(status: :active)
         end
       end
 
@@ -224,30 +191,25 @@ module Pay
 
       def discount_for_switching_to_monthly(current_plan, plan)
         cycles = (money_remaining_on_yearly_plan(current_plan) / plan.price).floor
-        OpenStruct.new(
+        ActiveSupport::InheritableOptions.new(
           amount: plan.price,
           number_of_billing_cycles: cycles
         )
       end
 
       def money_remaining_on_yearly_plan(current_plan)
-        end_date = processor_subscription.billing_period_end_date.to_date
+        end_date = api_record.billing_period_end_date.to_date
         (current_plan.price / 365) * (end_date - Date.today)
       end
 
-      def discount_for_switching_to_yearly
-        amount = 0
-
-        processor_subscription.discounts.each do |discount|
+      def discount_for_switching_to_yearly(amount: 0)
+        api_record.discounts.each do |discount|
           if discount.id == "plan-credit"
             amount += discount.amount * discount.number_of_billing_cycles
           end
         end
 
-        OpenStruct.new(
-          amount: amount,
-          number_of_billing_cycles: 1
-        )
+        ActiveSupport::InheritableOptions.new(amount: amount, number_of_billing_cycles: 1)
       end
 
       def swap_across_frequencies(plan)

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,10 +13,6 @@ 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
-
     # Payment method attributes
     store_accessor :data, :payment_method_type # card, paypal, sepa, etc
     store_accessor :data, :brand # Visa, Mastercard, Discover, PayPal
@@ -44,7 +38,7 @@ module Pay
     store_accessor :data, :refunds # array of refunds
 
     # 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,33 +46,14 @@ 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)
-    end
-
     def refunded?
       amount_refunded.to_i > 0
     end
@@ -104,7 +79,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"

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
 
@@ -23,9 +21,8 @@ module Pay
     store_accessor :data, :currency
 
     delegate :email, to: :owner
-    delegate_missing_to :pay_processor
 
-    %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)

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

@@ -0,0 +1,13 @@
+module Pay
+  module FakeProcessor
+    class Charge < Pay::Charge
+      def api_record
+        self
+      end
+
+      def refund!(amount_to_refund = nil)
+        update(amount_refunded: amount_to_refund || amount)
+      end
+    end
+  end
+end