pay 7.3.0 → 11.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ec013c6c05d0e8027b628258882c9bac3a01f7942e9654cc52582643cf57629
-  data.tar.gz: 75bcbbfcd8b63bb0f73e97b4a4da41335923f5f3af2e8577fc1f2aa94baa8542
+  metadata.gz: 0e194484cea3ae3dee4d9fdded7e5732f182a5e7699128f2f86bfa020284806f
+  data.tar.gz: 14b67bbf65d49fb2d7d73fdfbc8519baf5ddcade178ba88bd5b5b30534413d09
 SHA512:
-  metadata.gz: dd2822689a009a126f016365182312e4555098ba40b429e16c1dc41b76902a4fd18da06e3465b25cf17e0bf53371adf147bfd3c72e2c9186ce965de304f403e4
-  data.tar.gz: 1ad32b2e21be33e58ffb855dec4275cdff66d036a1728f2573d54d61a2937c6aa6c4602cb59f1dc53bea2edcd4fac46f89efcb91a5ea22443669087569959e5b
+  metadata.gz: b2c00bd4c90a603a91b62202ba36c5cb3cfdd99fcacdd347e274c2bf6c6cb4d813115373e23c9a3e575559d3ec0d37561c8f9a08a60e028415dace786dfcbb16
+  data.tar.gz: d62df086e5566fa6c25304c8cdbb54ef9ef401ba0a3023541085c57ab32214287c953d78f1c86be4aeaeb34cc26c29635bc00e4e4b757f7f3579d65fa2ceb02b

data/README.md

@@ -2,13 +2,14 @@
 
 # 💳 Pay - Payments engine for Ruby on Rails
 
-[![Build Status](https://github.com/pay-rails/pay/workflows/Tests/badge.svg)](https://github.com/pay-rails/pay/actions) [![Gem Version](https://badge.fury.io/rb/pay.svg)](https://badge.fury.io/rb/pay)
-
-<img src="docs/images/stripe_partner_badge.svg" height="26px">
+[![Build Status](https://github.com/pay-rails/pay/workflows/Tests/badge.svg)](https://github.com/pay-rails/pay/actions) [![Gem Version](https://badge.fury.io/rb/pay.svg)](https://badge.fury.io/rb/pay) <img src="docs/images/stripe_partner_badge.svg" height="26px">
 
 Pay is a payments engine for Ruby on Rails 6.0 and higher.
 
-⚠️  **Upgrading?** Check the [UPGRADE](UPGRADE.md) guide for required changes and/or migration when upgrading from a previous version of Pay.
+> [!TIP]
+> Check out [Jumpstart](https://jumpstartrails.com) for Rails Starter Kit with Pay already integrated!
+
+**Upgrading?** Check the [UPGRADE](UPGRADE.md) guide for required changes and/or migration when upgrading from a previous version of Pay.
 
 ## 🧑‍💻 Tutorial
 
@@ -23,6 +24,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,7 +47,9 @@ 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)
+  * [Asaas (Community)](https://github.com/PedroAugustoRamalhoDuarte/pay-asaas)
 * **Marketplaces**
   * [Stripe Connect](docs/marketplaces/stripe_connect.md)
 * **Contributing**

data/app/controllers/pay/payments_controller.rb

@@ -6,6 +6,8 @@ module Pay
 
     def show
       @payment = Payment.from_id(params[:id])
+    rescue ::Stripe::StripeError => e
+      redirect_to root_path, alert: e.message
     end
 
     private

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,22 +18,21 @@ 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
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_braintree_charge, Pay::Braintree::Charge

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 = Pay::Braintree::Charge.find_or_initialize_by(customer: self, 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
@@ -302,3 +262,5 @@ module Pay
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_braintree_customer, Pay::Braintree::Customer

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

@@ -1,23 +1,15 @@
 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)
 
-        pay_customer = Pay::Customer.find_by(processor: :braintree, processor_id: object.customer_id)
+        pay_customer = Pay::Braintree::Customer.find_by(processor_id: object.customer_id)
         return unless pay_customer
 
         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)
@@ -40,3 +32,5 @@ module Pay
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_braintree_payment_method, Pay::Braintree::PaymentMethod

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)
 
@@ -50,15 +31,12 @@ module Pay
           attributes[:ends_at] = object.paid_through_date.end_of_day
         end
 
-        pay_subscription = pay_customer.subscriptions.find_by(processor_id: object.id)
-        if pay_subscription
+        if (pay_subscription = find_by(customer: pay_customer, processor_id: object.id))
           pay_subscription.with_lock { pay_subscription.update!(attributes) }
         else
           name ||= Pay.default_product_name
-          pay_subscription = pay_customer.subscriptions.create!(attributes.merge(name: name, processor_id: object.id))
+          create!(attributes.merge(customer: pay_customer, name: name, processor_id: object.id))
         end
-
-        pay_subscription
       rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique
         try += 1
         if try <= retries
@@ -69,11 +47,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 +58,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 +69,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 +78,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
@@ -124,7 +92,7 @@ module Pay
 
       def resume
         unless resumable?
-          raise StandardError, "You can only resume subscriptions within their grace period."
+          raise Error, "You can only resume subscriptions within their grace period."
         end
 
         if canceled? && on_trial?
@@ -138,15 +106,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
@@ -165,26 +131,25 @@ module Pay
         end
 
         braintree_plan = find_braintree_plan(plan)
+        prorate = options.fetch(:prorate) { true }
 
-        if would_change_billing_frequency?(braintree_plan) && prorate?
+        if would_change_billing_frequency?(braintree_plan) && prorate
           swap_across_frequencies(braintree_plan)
           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,
           number_of_billing_cycles: nil,
           options: {
-            prorate_charges: prorate?
+            prorate_charges: prorate
           }
         })
         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 +163,7 @@ module Pay
         )
 
         if result.success?
-          pay_subscription.update(status: :active)
+          update(status: :active)
         end
       end
 
@@ -224,30 +189,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)
@@ -283,3 +243,5 @@ module Pay
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_braintree_subscription, Pay::Braintree::Subscription