pay 7.3.0 → 8.0.0

data/db/migrate/2_add_pay_sti_columns.rb

@@ -0,0 +1,24 @@
+class AddPayStiColumns < ActiveRecord::Migration[6.0]
+  def change
+    add_column :pay_customers, :type, :string
+    add_column :pay_charges, :type, :string
+    add_column :pay_subscriptions, :type, :string
+
+    rename_column :pay_payment_methods, :type, :payment_method_type
+    add_column :pay_payment_methods, :type, :string
+
+    add_column :pay_merchants, :type, :string
+
+    Pay::Customer.find_each do |pay_customer|
+      pay_customer.update(type: "Pay::#{pay_customer.processor.classify}::Customer")
+
+      pay_customer.charges.update_all(type: "Pay::#{pay_customer.processor.classify}::Charge")
+      pay_customer.subscriptions.update_all(type: "Pay::#{pay_customer.processor.classify}::Subscription")
+      pay_customer.payment_methods.update_all(type: "Pay::#{pay_customer.processor.classify}::PaymentMethod")
+    end
+
+    Pay::Merchant.find_each do |pay_merchant|
+      pay_merchant.update(type: "Pay::#{pay_merchant.processor.classify}::Merchant")
+    end
+  end
+end

data/lib/pay/attributes.rb

@@ -31,9 +31,13 @@ module Pay
       def set_payment_processor(processor_name, allow_fake: false, **attributes)
         raise Pay::Error, "Processor `#{processor_name}` is not allowed" if processor_name.to_s == "fake_processor" && !allow_fake
 
+        # Safety check to make sure this is a valid Pay processor
+        klass = "Pay::#{processor_name.to_s.classify}::Customer".constantize
+        raise ArgumentError, "not a valid payment processor" if klass.ancestors.exclude?(Pay::Customer)
+
         ActiveRecord::Base.transaction do
           pay_customers.update_all(default: false)
-          pay_customer = pay_customers.active.where(processor: processor_name).first_or_initialize
+          pay_customer = pay_customers.active.where(processor: processor_name, type: klass.name).first_or_initialize
           pay_customer.update!(attributes.merge(default: true))
         end
 
@@ -44,7 +48,11 @@ module Pay
       def add_payment_processor(processor_name, allow_fake: false, **attributes)
         raise Pay::Error, "Processor `#{processor_name}` is not allowed" if processor_name.to_s == "fake_processor" && !allow_fake
 
-        pay_customer = pay_customers.active.where(processor: processor_name).first_or_initialize
+        # Safety check to make sure this is a valid Pay processor
+        klass = "Pay::#{processor_name.to_s.classify}::Customer".constantize
+        raise ArgumentError, "not a valid payment processor" if klass.ancestors.exclude?(Pay::Customer)
+
+        pay_customer = pay_customers.active.where(processor: processor_name, type: klass.name).first_or_initialize
         pay_customer.update!(attributes)
         pay_customer
       end
@@ -75,7 +83,7 @@ module Pay
       def set_merchant_processor(processor_name, **attributes)
         ActiveRecord::Base.transaction do
           pay_merchants.update_all(default: false)
-          pay_merchant = pay_merchants.where(processor: processor_name).first_or_initialize
+          pay_merchant = pay_merchants.where(processor: processor_name, type: "Pay::#{processor_name.to_s.classify}::Merchant").first_or_initialize
           pay_merchant.update!(attributes.merge(default: true))
         end
 

data/lib/pay/braintree.rb

@@ -1,11 +1,30 @@
 module Pay
   module Braintree
-    autoload :AuthorizationError, "pay/braintree/authorization_error"
-    autoload :Billable, "pay/braintree/billable"
-    autoload :Charge, "pay/braintree/charge"
-    autoload :Error, "pay/braintree/error"
-    autoload :PaymentMethod, "pay/braintree/payment_method"
-    autoload :Subscription, "pay/braintree/subscription"
+    class Error < Pay::Error
+      # For any manually raised Braintree error results (for failure responses)
+      # we can raise this exception manually but treat it as if we wrapped an exception
+
+      attr_reader :result
+
+      def initialize(result)
+        if result.is_a?(::Braintree::ErrorResult)
+          super(result.message)
+          @result = result
+        else
+          super
+        end
+      end
+
+      def cause
+        super || result
+      end
+    end
+
+    class AuthorizationError < Error
+      def message
+        I18n.t("pay.errors.braintree.authorization")
+      end
+    end
 
     module Webhooks
       autoload :SubscriptionCanceled, "pay/braintree/webhooks/subscription_canceled"

data/lib/pay/engine.rb

@@ -28,12 +28,14 @@ module Pay
       Pay::Braintree.configure_webhooks if Pay::Braintree.enabled?
       Pay::PaddleBilling.configure_webhooks if Pay::PaddleBilling.enabled?
       Pay::PaddleClassic.configure_webhooks if Pay::PaddleClassic.enabled?
+      Pay::LemonSqueezy.configure_webhooks if Pay::LemonSqueezy.enabled?
     end
 
     config.to_prepare do
       Pay::Stripe.setup if Pay::Stripe.enabled?
       Pay::Braintree.setup if Pay::Braintree.enabled?
       Pay::PaddleBilling.setup if Pay::PaddleBilling.enabled?
+      Pay::LemonSqueezy.setup if Pay::LemonSqueezy.enabled?
 
       if defined?(::Receipts::VERSION)
         if Pay::Engine.version_matches?(required: "~> 2", current: ::Receipts::VERSION)

data/lib/pay/fake_processor.rb

@@ -1,10 +1,6 @@
 module Pay
   module FakeProcessor
-    autoload :Billable, "pay/fake_processor/billable"
-    autoload :Charge, "pay/fake_processor/charge"
-    autoload :Error, "pay/fake_processor/error"
-    autoload :PaymentMethod, "pay/fake_processor/payment_method"
-    autoload :Subscription, "pay/fake_processor/subscription"
-    autoload :Merchant, "pay/fake_processor/merchant"
+    class Error < Pay::Error
+    end
   end
 end

data/lib/pay/lemon_squeezy/webhooks/order.rb

@@ -0,0 +1,11 @@
+module Pay
+  module LemonSqueezy
+    module Webhooks
+      class Order
+        def call(order)
+          Pay::LemonSqueezy.sync_order(order.id, object: order)
+        end
+      end
+    end
+  end
+end

data/lib/pay/lemon_squeezy/webhooks/subscription.rb

@@ -1,9 +1,9 @@
 module Pay
-  module PaddleBilling
+  module LemonSqueezy
     module Webhooks
       class Subscription
-        def call(event)
-          Pay::PaddleBilling::Subscription.sync(event.id, object: event)
+        def call(subscription)
+          Pay::LemonSqueezy::Subscription.sync(subscription.id, object: subscription)
         end
       end
     end

data/lib/pay/lemon_squeezy/webhooks/subscription_payment.rb

@@ -0,0 +1,11 @@
+module Pay
+  module LemonSqueezy
+    module Webhooks
+      class SubscriptionPayment
+        def call(subscription_invoice)
+          Pay::LemonSqueezy::Charge.sync_subscription_invoice(subscription_invoice.id, object: subscription_invoice)
+        end
+      end
+    end
+  end
+end

data/lib/pay/lemon_squeezy.rb

@@ -1,138 +1,90 @@
 module Pay
   module LemonSqueezy
-    autoload :Billable, "pay/stripe/billable"
-    autoload :Charge, "pay/stripe/charge"
-    autoload :Error, "pay/stripe/error"
-    autoload :Merchant, "pay/stripe/merchant"
-    autoload :PaymentMethod, "pay/stripe/payment_method"
-    autoload :Subscription, "pay/stripe/subscription"
+    class Error < Pay::Error
+      delegate :message, to: :cause
+    end
 
     module Webhooks
-      autoload :AccountUpdated, "pay/stripe/webhooks/account_updated"
-      autoload :ChargeRefunded, "pay/stripe/webhooks/charge_refunded"
-      autoload :ChargeSucceeded, "pay/stripe/webhooks/charge_succeeded"
-      autoload :CheckoutSessionCompleted, "pay/stripe/webhooks/checkout_session_completed"
-      autoload :CheckoutSessionAsyncPaymentSucceeded, "pay/stripe/webhooks/checkout_session_async_payment_succeeded"
-      autoload :CustomerDeleted, "pay/stripe/webhooks/customer_deleted"
-      autoload :CustomerUpdated, "pay/stripe/webhooks/customer_updated"
-      autoload :PaymentActionRequired, "pay/stripe/webhooks/payment_action_required"
-      autoload :PaymentFailed, "pay/stripe/webhooks/payment_failed"
-      autoload :PaymentIntentSucceeded, "pay/stripe/webhooks/payment_intent_succeeded"
-      autoload :PaymentMethodAttached, "pay/stripe/webhooks/payment_method_attached"
-      autoload :PaymentMethodDetached, "pay/stripe/webhooks/payment_method_detached"
-      autoload :PaymentMethodUpdated, "pay/stripe/webhooks/payment_method_updated"
-      autoload :SubscriptionCreated, "pay/stripe/webhooks/subscription_created"
-      autoload :SubscriptionDeleted, "pay/stripe/webhooks/subscription_deleted"
-      autoload :SubscriptionRenewing, "pay/stripe/webhooks/subscription_renewing"
-      autoload :SubscriptionUpdated, "pay/stripe/webhooks/subscription_updated"
-      autoload :SubscriptionTrialWillEnd, "pay/stripe/webhooks/subscription_trial_will_end"
+      autoload :Order, "pay/lemon_squeezy/webhooks/order"
+      autoload :Subscription, "pay/lemon_squeezy/webhooks/subscription"
+      autoload :SubscriptionPayment, "pay/lemon_squeezy/webhooks/subscription_payment"
     end
 
     extend Env
 
-    REQUIRED_VERSION = "~> 1"
-
     def self.enabled?
-      return false unless Pay.enabled_processors.include?(:lemonsqueezy) && defined?(::Lemonzsqueezy)
+      return false unless Pay.enabled_processors.include?(:lemon_squeezy) && defined?(::LemonSqueezy)
 
-      Pay::Engine.version_matches?(required: REQUIRED_VERSION, current: ::Lemonsqueezy::VERSION) || (raise "[Pay] lemonsqueezy gem must be version #{REQUIRED_VERSION}")
+      Pay::Engine.version_matches?(required: "~> 1.0", current: ::LemonSqueezy::VERSION) || (raise "[Pay] lemonsqueezy gem must be version ~> 1.0")
     end
 
     def self.setup
-      ::Stripe.api_key = private_key
+      ::LemonSqueezy.config.api_key = api_key
+    end
 
-      # Used by Stripe to identify Pay for support
-      ::Stripe.set_app_info("PayRails", partner_id: "pp_partner_IqhY0UExnJYLxg", version: Pay::VERSION, url: "https://github.com/pay-rails/pay")
+    def self.api_key
+      find_value_by_name(:lemon_squeezy, :api_key)
+    end
 
-      # Automatically retry requests that fail
-      # This automatically includes idempotency keys in the request to guarantee that retires are safe
-      # https://github.com/stripe/stripe-ruby#configuring-automatic-retries
-      ::Stripe.max_network_retries = 2
+    def self.store_id
+      find_value_by_name(:lemon_squeezy, :store_id)
     end
 
-    def self.public_key
-      find_value_by_name(:stripe, :public_key)
+    def self.signing_secret
+      find_value_by_name(:lemon_squeezy, :signing_secret)
     end
 
-    def self.private_key
-      find_value_by_name(:stripe, :private_key)
+    def self.passthrough(owner:, **options)
+      owner.to_sgid.to_s
     end
 
-    def self.signing_secret
-      find_value_by_name(:stripe, :signing_secret)
+    def self.owner_from_passthrough(passthrough)
+      GlobalID::Locator.locate_signed passthrough
+    rescue JSON::ParserError
+      nil
     end
 
     def self.configure_webhooks
       Pay::Webhooks.configure do |events|
-        # Listen to the charge event to make sure we get non-subscription
-        # purchases as well. Invoice is only for subscriptions and manual creation
-        # so it does not include individual charges.
-        events.subscribe "stripe.charge.succeeded", Pay::Stripe::Webhooks::ChargeSucceeded.new
-        events.subscribe "stripe.charge.refunded", Pay::Stripe::Webhooks::ChargeRefunded.new
-
-        events.subscribe "stripe.payment_intent.succeeded", Pay::Stripe::Webhooks::PaymentIntentSucceeded.new
-
-        # Warn user of upcoming charges for their subscription. This is handy for
-        # notifying annual users their subscription will renew shortly.
-        # This probably should be ignored for monthly subscriptions.
-        events.subscribe "stripe.invoice.upcoming", Pay::Stripe::Webhooks::SubscriptionRenewing.new
-
-        # Payment action is required to process an invoice
-        events.subscribe "stripe.invoice.payment_action_required", Pay::Stripe::Webhooks::PaymentActionRequired.new
-
-        # If an invoice payment fails, we want to notify the user via email to update their payment details
-        events.subscribe "stripe.invoice.payment_failed", Pay::Stripe::Webhooks::PaymentFailed.new
-
-        # If a subscription is manually created on Stripe, we want to sync
-        events.subscribe "stripe.customer.subscription.created", Pay::Stripe::Webhooks::SubscriptionCreated.new
-
-        # If the plan, quantity, or trial ending date is updated on Stripe, we want to sync
-        events.subscribe "stripe.customer.subscription.updated", Pay::Stripe::Webhooks::SubscriptionUpdated.new
-
-        # When a customers subscription is canceled, we want to update our records
-        events.subscribe "stripe.customer.subscription.deleted", Pay::Stripe::Webhooks::SubscriptionDeleted.new
-
-        # When a customers subscription trial period is 3 days from ending or ended immediately this event is fired
-        events.subscribe "stripe.customer.subscription.trial_will_end", Pay::Stripe::Webhooks::SubscriptionTrialWillEnd.new
-
-        # Monitor changes for customer's default card changing and invoice credit updates
-        events.subscribe "stripe.customer.updated", Pay::Stripe::Webhooks::CustomerUpdated.new
-
-        # If a customer was deleted in Stripe, their subscriptions should be cancelled
-        events.subscribe "stripe.customer.deleted", Pay::Stripe::Webhooks::CustomerDeleted.new
-
-        # If a customer's payment source was deleted in Stripe, we should update as well
-        events.subscribe "stripe.payment_method.attached", Pay::Stripe::Webhooks::PaymentMethodAttached.new
-        events.subscribe "stripe.payment_method.updated", Pay::Stripe::Webhooks::PaymentMethodUpdated.new
-        events.subscribe "stripe.payment_method.card_automatically_updated", Pay::Stripe::Webhooks::PaymentMethodUpdated.new
-        events.subscribe "stripe.payment_method.detached", Pay::Stripe::Webhooks::PaymentMethodDetached.new
-
-        # If an account is updated in stripe, we should update it as well
-        events.subscribe "stripe.account.updated", Pay::Stripe::Webhooks::AccountUpdated.new
-
-        # Handle subscriptions in Stripe Checkout Sessions
-        events.subscribe "stripe.checkout.session.completed", Pay::Stripe::Webhooks::CheckoutSessionCompleted.new
-        events.subscribe "stripe.checkout.session.async_payment_succeeded", Pay::Stripe::Webhooks::CheckoutSessionAsyncPaymentSucceeded.new
+        events.subscribe "lemon_squeezy.order_created", Pay::LemonSqueezy::Webhooks::Order.new
+        events.subscribe "lemon_squeezy.subscription_created", Pay::LemonSqueezy::Webhooks::Subscription.new
+        events.subscribe "lemon_squeezy.subscription_updated", Pay::LemonSqueezy::Webhooks::Subscription.new
+        events.subscribe "lemon_squeezy.subscription_payment_refunded", Pay::LemonSqueezy::Webhooks::SubscriptionPayment.new
+        events.subscribe "lemon_squeezy.subscription_payment_success", Pay::LemonSqueezy::Webhooks::SubscriptionPayment.new
       end
     end
 
-    def self.to_client_reference_id(record)
-      raise ArgumentError, "#{record.class.name} does not include Pay. Allowed models: #{model_names.to_a.join(", ")}" unless model_names.include?(record.class.name)
-      [record.class.name, record.id].join("_")
+    def self.construct_from_webhook_event(event)
+      data = event["data"]
+      case data
+      when Array
+        data.map do |object|
+          construct_from_webhook_event(object)
+        end
+      when Hash
+        type = {
+          "orders" => ::LemonSqueezy::Order,
+          "subscriptions" => ::LemonSqueezy::Subscription,
+          "subscription-invoices" => ::LemonSqueezy::SubscriptionInvoice
+        }.fetch(data["type"])
+
+        type.new(data)
+      end
     end
 
-    def self.find_by_client_reference_id(client_reference_id)
-      # If there is a client reference ID, make sure we have a Pay::Customer record
-      # client_reference_id should be in the format of "User/1"
-      model_name, id = client_reference_id.split("_", 2)
-
-      # Only allow model names that use Pay
-      return unless model_names.include?(model_name)
+    # An Order may have subscriptions or be a one-time purchase
+    def self.sync_order(order_id, object: nil)
+      subscriptions = ::LemonSqueezy::Subscription.list(order_id: order_id).data
+      subscriptions.each do |subscription|
+        Pay::LemonSqueezy::Subscription.sync(subscription.id, object: subscription)
+        ::LemonSqueezy::SubscriptionInvoice.list(subscription_id: subscription.id).data.each do |invoice|
+          Pay::LemonSqueezy::Charge.sync_subscription_invoice(invoice.id, object: invoice)
+        end
+      end
 
-      model_name.constantize.find(id)
-    rescue ActiveRecord::RecordNotFound
-      Rails.logger.error "[Pay] Unable to locate record with: #{client_reference_id}"
-      nil
+      if subscriptions.empty?
+        Pay::LemonSqueezy::Charge.sync_order(order_id, object: object)
+      end
     end
   end
 end

data/lib/pay/paddle_billing.rb

@@ -1,10 +1,8 @@
 module Pay
   module PaddleBilling
-    autoload :Billable, "pay/paddle_billing/billable"
-    autoload :Charge, "pay/paddle_billing/charge"
-    autoload :Error, "pay/paddle_billing/error"
-    autoload :PaymentMethod, "pay/paddle_billing/payment_method"
-    autoload :Subscription, "pay/paddle_billing/subscription"
+    class Error < Pay::Error
+      delegate :message, to: :cause
+    end
 
     module Webhooks
       autoload :Subscription, "pay/paddle_billing/webhooks/subscription"
@@ -16,7 +14,8 @@ module Pay
     def self.enabled?
       return false unless Pay.enabled_processors.include?(:paddle_billing) && defined?(::Paddle)
 
-      Pay::Engine.version_matches?(required: "~> 2.1", current: ::Paddle::VERSION) || (raise "[Pay] paddle gem must be version ~> 2.1")
+      Pay::Engine.version_matches?(required: "~> 2.5",
+        current: ::Paddle::VERSION) || (raise "[Pay] paddle gem must be version ~> 2.5")
     end
 
     def self.setup
@@ -54,5 +53,15 @@ module Pay
         events.subscribe "paddle_billing.transaction.completed", Pay::PaddleBilling::Webhooks::TransactionCompleted.new
       end
     end
+
+    def self.sync_transaction(transaction_id)
+      transaction = ::Paddle::Transaction.retrieve(id: transaction_id)
+
+      if transaction.subscription_id.present?
+        Pay::PaddleBilling::Subscription.sync(transaction.subscription_id)
+      else
+        Pay::PaddleBilling::Charge.sync(transaction_id, object: transaction)
+      end
+    end
   end
 end

data/lib/pay/paddle_classic.rb

@@ -1,10 +1,8 @@
 module Pay
   module PaddleClassic
-    autoload :Billable, "pay/paddle_classic/billable"
-    autoload :Charge, "pay/paddle_classic/charge"
-    autoload :Error, "pay/paddle_classic/error"
-    autoload :PaymentMethod, "pay/paddle_classic/payment_method"
-    autoload :Subscription, "pay/paddle_classic/subscription"
+    class Error < Pay::Error
+      delegate :message, to: :cause
+    end
 
     module Webhooks
       autoload :SignatureVerifier, "pay/paddle_classic/webhooks/signature_verifier"
@@ -20,7 +18,8 @@ module Pay
     def self.enabled?
       return false unless Pay.enabled_processors.include?(:paddle_classic) && defined?(::Paddle)
 
-      Pay::Engine.version_matches?(required: "~> 2.1", current: ::Paddle::VERSION) || (raise "[Pay] paddle gem must be version ~> 2.1")
+      Pay::Engine.version_matches?(required: "~> 2.5",
+        current: ::Paddle::VERSION) || (raise "[Pay] paddle gem must be version ~> 2.5")
     end
 
     def self.client
@@ -73,9 +72,12 @@ module Pay
       Pay::Webhooks.configure do |events|
         events.subscribe "paddle_classic.subscription_created", Pay::PaddleClassic::Webhooks::SubscriptionCreated.new
         events.subscribe "paddle_classic.subscription_updated", Pay::PaddleClassic::Webhooks::SubscriptionUpdated.new
-        events.subscribe "paddle_classic.subscription_cancelled", Pay::PaddleClassic::Webhooks::SubscriptionCancelled.new
-        events.subscribe "paddle_classic.subscription_payment_succeeded", Pay::PaddleClassic::Webhooks::SubscriptionPaymentSucceeded.new
-        events.subscribe "paddle_classic.subscription_payment_refunded", Pay::PaddleClassic::Webhooks::SubscriptionPaymentRefunded.new
+        events.subscribe "paddle_classic.subscription_cancelled",
+          Pay::PaddleClassic::Webhooks::SubscriptionCancelled.new
+        events.subscribe "paddle_classic.subscription_payment_succeeded",
+          Pay::PaddleClassic::Webhooks::SubscriptionPaymentSucceeded.new
+        events.subscribe "paddle_classic.subscription_payment_refunded",
+          Pay::PaddleClassic::Webhooks::SubscriptionPaymentRefunded.new
       end
     end
   end

data/lib/pay/receipts.rb

@@ -1,9 +1,5 @@
 module Pay
   module Receipts
-    def product
-      Pay.application_name
-    end
-
     def receipt_filename
       "receipt-#{created_at.strftime("%Y-%m-%d")}.pdf"
     end
@@ -21,6 +17,10 @@ module Pay
       ]
     end
 
+    def pdf_product_name
+      Pay.application_name
+    end
+
     def pdf_line_items
       items = [
         [
@@ -45,7 +45,7 @@ module Pay
           end
         end
       else
-        items << [product, 1, Pay::Currency.format(amount, currency: currency), Pay::Currency.format(amount, currency: currency)]
+        items << [pdf_product_name, 1, Pay::Currency.format(amount, currency: currency), Pay::Currency.format(amount, currency: currency)]
       end
 
       # If no subtotal, we will display the total
@@ -155,7 +155,7 @@ module Pay
         company: {
           name: Pay.business_name,
           address: Pay.business_address,
-          email: Pay.support_email.address,
+          email: Pay.support_email&.address,
           logo: Pay.business_logo
         },
         line_items: pdf_line_items

data/lib/pay/stripe/webhooks/customer_updated.rb

@@ -9,7 +9,7 @@ module Pay
           # Couldn't find user, we can skip
           return unless pay_customer.present?
 
-          stripe_customer = pay_customer.customer
+          stripe_customer = pay_customer.api_record
 
           # Sync default card
           if (payment_method_id = stripe_customer.invoice_settings.default_payment_method)

data/lib/pay/stripe.rb

@@ -1,11 +1,8 @@
 module Pay
   module Stripe
-    autoload :Billable, "pay/stripe/billable"
-    autoload :Charge, "pay/stripe/charge"
-    autoload :Error, "pay/stripe/error"
-    autoload :Merchant, "pay/stripe/merchant"
-    autoload :PaymentMethod, "pay/stripe/payment_method"
-    autoload :Subscription, "pay/stripe/subscription"
+    class Error < Pay::Error
+      delegate :message, to: :cause
+    end
 
     module Webhooks
       autoload :AccountUpdated, "pay/stripe/webhooks/account_updated"
@@ -143,5 +140,17 @@ module Pay
       Rails.logger.error "[Pay] Unable to locate record with: #{client_reference_id}"
       nil
     end
+
+    def self.sync_checkout_session(session_id, stripe_account: nil)
+      checkout_session = ::Stripe::Checkout::Session.retrieve({id: session_id, expand: ["payment_intent.latest_charge"]}, {stripe_account: stripe_account}.compact)
+      case checkout_session.mode
+      when "payment"
+        if (id = checkout_session.payment_intent.try(:latest_charge)&.id)
+          Pay::Stripe::Charge.sync(id, stripe_account: stripe_account)
+        end
+      when "subscription"
+        Pay::Stripe::Subscription.sync(checkout_session.subscription, stripe_account: stripe_account)
+      end
+    end
   end
 end

data/lib/pay/version.rb

@@ -1,3 +1,3 @@
 module Pay
-  VERSION = "7.3.0"
+  VERSION = "8.0.0"
 end

data/lib/pay.rb

@@ -19,6 +19,7 @@ module Pay
   autoload :FakeProcessor, "pay/fake_processor"
   autoload :PaddleBilling, "pay/paddle_billing"
   autoload :PaddleClassic, "pay/paddle_classic"
+  autoload :LemonSqueezy, "pay/lemon_squeezy"
   autoload :Stripe, "pay/stripe"
 
   autoload :Webhooks, "pay/webhooks"
@@ -56,7 +57,7 @@ module Pay
   @@routes_path = "/pay"
 
   mattr_accessor :enabled_processors
-  @@enabled_processors = [:stripe, :braintree, :paddle_billing, :paddle_classic]
+  @@enabled_processors = [:stripe, :braintree, :paddle_billing, :paddle_classic, :lemon_squeezy]
 
   mattr_accessor :send_emails
   @@send_emails = true
@@ -130,4 +131,14 @@ module Pay
       option
     end
   end
+
+  def self.sync(params)
+    if (session_id = params[:stripe_checkout_session_id] || params[:session_id])
+      Pay::Stripe.sync_checkout_session(session_id)
+    elsif (transaction_id = params[:paddle_billing_transaction_id] || params[:transaction_id])
+      Pay::PaddleBilling.sync_transaction(transaction_id)
+    elsif (order_id = params[:lemon_squeezy_order_id])
+      Pay::LemonSqueezy.sync_order(order_id)
+    end
+  end
 end