pay 7.3.0 → 8.1.0

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

@@ -1,36 +1,20 @@
 module Pay
   module Stripe
-    class Billable
-      include Rails.application.routes.url_helpers
-
-      attr_reader :pay_customer
-
-      delegate :processor_id,
-        :processor_id?,
-        :email,
-        :customer_name,
-        :payment_method_token,
-        :payment_method_token?,
-        :stripe_account,
-        to: :pay_customer
-
-      def self.default_url_options
-        Rails.application.config.action_mailer.default_url_options || {}
-      end
+    class Customer < Pay::Customer
+      include Pay::Routing
 
-      def initialize(pay_customer)
-        @pay_customer = pay_customer
-      end
+      has_many :charges, dependent: :destroy, class_name: "Pay::Stripe::Charge"
+      has_many :subscriptions, dependent: :destroy, class_name: "Pay::Stripe::Subscription"
+      has_many :payment_methods, dependent: :destroy, class_name: "Pay::Stripe::PaymentMethod"
+      has_one :default_payment_method, -> { where(default: true) }, class_name: "Pay::Stripe::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_stripe_customer_attributes
         when Symbol
-          owner.send(owner.class.pay_stripe_customer_attributes, pay_customer)
+          owner.send(owner.class.pay_stripe_customer_attributes, self)
         when Proc
-          owner.class.pay_stripe_customer_attributes.call(pay_customer)
+          owner.class.pay_stripe_customer_attributes.call(self)
         end
 
         # Guard against attributes being returned nil
@@ -39,55 +23,30 @@ module Pay
         {email: email, name: customer_name}.merge(attributes)
       end
 
-      # Retrieves a Stripe::Customer object
-      #
-      # Finds an existing Stripe::Customer if processor_id exists
-      # Creates a new Stripe::Customer using `customer_attributes` if empty processor_id
-      #
-      # Updates the default payment method automatically if a payment_method_token is set
-      #
-      # Returns a Stripe::Customer object
-      def customer
-        stripe_customer = if processor_id?
-          ::Stripe::Customer.retrieve({id: processor_id, expand: ["tax", "invoice_credit_balance"]}, stripe_options)
-        else
-          sc = ::Stripe::Customer.create(customer_attributes.merge(expand: ["tax"]), stripe_options)
-          pay_customer.update!(processor_id: sc.id, stripe_account: stripe_account)
-          sc
-        end
-
-        if payment_method_token?
-          add_payment_method(payment_method_token, default: true)
-          pay_customer.payment_method_token = nil
+      def api_record(expand: ["tax", "invoice_credit_balance"])
+        with_lock do
+          if processor_id?
+            ::Stripe::Customer.retrieve({id: processor_id, expand: expand}, stripe_options)
+          else
+            ::Stripe::Customer.create(api_record_attributes.merge(expand: expand), stripe_options).tap do |customer|
+              update!(processor_id: customer.id, stripe_account: stripe_account)
+            end
+          end
         end
-
-        stripe_customer
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
-      # Syncs name and email to Stripe::Customer
-      # You can also pass in other attributes that will be merged into the default attributes
-      def update_customer!(**attributes)
-        customer unless processor_id?
-        ::Stripe::Customer.update(
-          processor_id,
-          customer_attributes.merge(attributes),
-          stripe_options
-        )
+      def update_api_record(**attributes)
+        api_record unless processor_id?
+        ::Stripe::Customer.update(processor_id, api_record_attributes.merge(attributes), stripe_options)
       end
 
       # Charges an amount to the customer's default payment method
       def charge(amount, options = {})
-        add_payment_method(payment_method_token, default: true) if payment_method_token?
-
-        payment_method = pay_customer.default_payment_method
-        args = {
-          confirm: true,
-          payment_method: payment_method&.processor_id
-        }.merge(options)
-
+        args = {confirm: true, payment_method: default_payment_method&.processor_id}.merge(options)
         payment_intent = create_payment_intent(amount, args)
+
         Pay::Payment.new(payment_intent).validate
 
         charge = payment_intent.latest_charge
@@ -96,24 +55,6 @@ module Pay
         raise Pay::Stripe::Error, e
       end
 
-      # Creates and returns a Stripe::PaymentIntent
-      def create_payment_intent(amount, options = {})
-        args = {
-          amount: amount,
-          currency: "usd",
-          customer: processor_id,
-          expand: ["latest_charge.refunds"],
-          return_url: root_url
-        }.merge(options)
-
-        ::Stripe::PaymentIntent.create(args, stripe_options)
-      end
-
-      # Used for creating Stripe Terminal charges
-      def terminal_charge(amount, options = {})
-        create_payment_intent(amount, options.merge(payment_method_types: ["card_present"], capture_method: "manual"))
-      end
-
       def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
         quantity = options.delete(:quantity)
         opts = {
@@ -122,7 +63,7 @@ module Pay
         }.merge(options)
 
         # Load the Stripe customer to verify it exists and update payment method if needed
-        opts[:customer] = customer.id
+        opts[:customer] = processor_id || api_record.id
 
         # Create subscription on Stripe
         stripe_sub = ::Stripe::Subscription.create(opts.merge(Pay::Stripe::Subscription.expand_options), stripe_options)
@@ -141,7 +82,7 @@ module Pay
       end
 
       def add_payment_method(payment_method_id, default: false)
-        customer unless processor_id?
+        api_record unless processor_id?
         payment_method = ::Stripe::PaymentMethod.attach(payment_method_id, {customer: processor_id}, stripe_options)
 
         if default
@@ -159,50 +100,56 @@ module Pay
 
       # Save the Stripe::PaymentMethod to the database
       def save_payment_method(payment_method, default:)
-        pay_payment_method = pay_customer.payment_methods.where(processor_id: payment_method.id).first_or_initialize
+        pay_payment_method = payment_methods.where(processor_id: payment_method.id).first_or_initialize
 
         attributes = Pay::Stripe::PaymentMethod.extract_attributes(payment_method).merge(default: default)
 
         # Ignore the payment method if it's already in the database
-        pay_customer.payment_methods.where.not(id: pay_payment_method.id).update_all(default: false) if default
+        payment_methods.where.not(id: pay_payment_method.id).update_all(default: false) if default
         pay_payment_method.update!(attributes)
 
         # Reload the Rails association
-        pay_customer.reload_default_payment_method
+        reload_default_payment_method
 
         pay_payment_method
       end
 
-      def processor_subscription(subscription_id, options = {})
-        ::Stripe::Subscription.retrieve(options.merge(id: subscription_id), stripe_options)
-      end
+      ### Stripe extras
 
-      def invoice!(options = {})
-        return unless processor_id?
-        ::Stripe::Invoice.create(options.merge(customer: processor_id), stripe_options).pay
+      # Creates and returns a Stripe::PaymentIntent
+      def create_payment_intent(amount, options = {})
+        args = {
+          amount: amount,
+          currency: "usd",
+          customer: processor_id || api_record.id,
+          expand: ["latest_charge.refunds"],
+          return_url: root_url
+        }.merge(options)
+
+        ::Stripe::PaymentIntent.create(args, stripe_options)
       end
 
-      def upcoming_invoice
-        ::Stripe::Invoice.upcoming({customer: processor_id}, stripe_options)
+      # Used for creating Stripe Terminal charges
+      def terminal_charge(amount, options = {})
+        create_payment_intent(amount, options.merge(payment_method_types: ["card_present"], capture_method: "manual"))
       end
 
       def create_setup_intent(options = {})
-        customer unless processor_id?
-        ::Stripe::SetupIntent.create({
-          customer: processor_id,
-          usage: :off_session
-        }.merge(options), stripe_options)
+        ::Stripe::SetupIntent.create({customer: processor_id || api_record.id, usage: :off_session}.merge(options), stripe_options)
       end
 
-      def trial_end_date(stripe_sub)
-        # Times in Stripe are returned in UTC
-        stripe_sub.trial_end.present? ? Time.at(stripe_sub.trial_end) : nil
+      def invoice!(options = {})
+        ::Stripe::Invoice.create(options.merge(customer: processor_id || api_record.id), stripe_options).pay
+      end
+
+      def upcoming_invoice
+        ::Stripe::Invoice.upcoming({customer: processor_id || api_record.id}, stripe_options)
       end
 
       # Syncs a customer's subscriptions from Stripe to the database.
       # Note that by default canceled subscriptions are NOT returned by Stripe. In order to include them, use `sync_subscriptions(status: "all")`.
       def sync_subscriptions(**options)
-        subscriptions = ::Stripe::Subscription.list(options.merge(customer: customer), stripe_options)
+        subscriptions = ::Stripe::Subscription.list(options.with_defaults(customer: processor_id), stripe_options)
         subscriptions.map do |subscription|
           Pay::Stripe::Subscription.sync(subscription.id)
         end
@@ -221,7 +168,7 @@ module Pay
       # checkout(line_items: "price_12345", allow_promotion_codes: true)
       #
       def checkout(**options)
-        customer unless processor_id?
+        api_record unless processor_id?
         args = {
           customer: processor_id,
           mode: "payment"
@@ -261,7 +208,7 @@ module Pay
       # checkout_charge(amount: 15_00, name: "T-shirt", quantity: 2)
       #
       def checkout_charge(amount:, name:, quantity: 1, **options)
-        customer unless processor_id?
+        api_record unless processor_id?
         currency = options.delete(:currency) || "usd"
         checkout(
           line_items: {
@@ -277,7 +224,7 @@ module Pay
       end
 
       def billing_portal(**options)
-        customer unless processor_id?
+        api_record unless processor_id?
         args = {
           customer: processor_id,
           return_url: options.delete(:return_url) || root_url
@@ -285,10 +232,28 @@ module Pay
         ::Stripe::BillingPortal::Session.create(args.merge(options), stripe_options)
       end
 
+      def customer_session(**options)
+        api_record unless processor_id?
+        args = {customer: processor_id}
+        ::Stripe::CustomerSession.create(args.merge(options), stripe_options)
+      end
+
       def authorize(amount, options = {})
         charge(amount, options.merge(capture_method: :manual))
       end
 
+      # Creates a meter event to bill for usage
+      #
+      # create_meter_event(:api_request, value: 1)
+      # create_meter_event(:api_request, token: 7)
+      def create_meter_event(event_name, payload: {}, **options)
+        api_record unless processor_id?
+        ::Stripe::Billing::MeterEvent.create({
+          event_name: event_name,
+          payload: {stripe_customer_id: processor_id}.merge(payload)
+        }.merge(options))
+      end
+
       private
 
       # Options for Stripe requests
@@ -299,7 +264,7 @@ module Pay
       # Includes the `session_id` param for Stripe Checkout with existing params (and makes sure the curly braces aren't escaped)
       def merge_session_id_param(url)
         uri = URI.parse(url)
-        uri.query = URI.encode_www_form(URI.decode_www_form(uri.query.to_s).to_h.merge("session_id" => "{CHECKOUT_SESSION_ID}").to_a)
+        uri.query = URI.encode_www_form(URI.decode_www_form(uri.query.to_s).to_h.merge("stripe_checkout_session_id" => "{CHECKOUT_SESSION_ID}").to_a)
         uri.to_s.gsub("%7BCHECKOUT_SESSION_ID%7D", "{CHECKOUT_SESSION_ID}")
       end
     end

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

@@ -1,15 +1,6 @@
 module Pay
   module Stripe
-    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)
         defaults = {
           type: "express",
@@ -20,7 +11,7 @@ module Pay
         }
 
         stripe_account = ::Stripe::Account.create(defaults.merge(options))
-        pay_merchant.update(processor_id: stripe_account.id)
+        update(processor_id: stripe_account.id)
         stripe_account
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e

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

@@ -1,14 +1,6 @@
 module Pay
   module Stripe
-    class PaymentMethod
-      attr_reader :pay_payment_method
-
-      delegate :customer, :processor_id, to: :pay_payment_method
-
-      def initialize(pay_payment_method)
-        @pay_payment_method = pay_payment_method
-      end
-
+    class PaymentMethod < Pay::PaymentMethod
       # Syncs a PaymentIntent's payment method to the database
       def self.sync_payment_intent(id, stripe_account: nil)
         payment_intent = ::Stripe::PaymentIntent.retrieve({id: id, expand: ["payment_method"]}, {stripe_account: stripe_account}.compact)
@@ -39,7 +31,7 @@ module Pay
           return
         end
 
-        default_payment_method_id = pay_customer.customer.invoice_settings.default_payment_method
+        default_payment_method_id = pay_customer.api_record.invoice_settings.default_payment_method
         default = (id == default_payment_method_id)
 
         attributes = extract_attributes(object).merge(default: default, stripe_account: stripe_account)

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

@@ -1,33 +1,7 @@
 module Pay
   module Stripe
-    class Subscription
-      attr_accessor :stripe_subscription
-      attr_reader :pay_subscription
-
-      delegate :active?,
-        :canceled?,
-        :ends_at?,
-        :ends_at,
-        :name,
-        :on_trial?,
-        :past_due?,
-        :pause_starts_at,
-        :pause_starts_at?,
-        :processor_id,
-        :processor_plan,
-        :processor_subscription,
-        :prorate,
-        :prorate?,
-        :quantity,
-        :quantity?,
-        :stripe_account,
-        :subscription_items,
-        :trial_ends_at,
-        :pause_behavior,
-        :pause_resumes_at,
-        :current_period_start,
-        :current_period_end,
-        to: :pay_subscription
+    class Subscription < Pay::Subscription
+      attr_writer :api_record
 
       def self.sync_from_checkout_session(session_id, stripe_account: nil)
         checkout_session = ::Stripe::Checkout::Session.retrieve({id: session_id}, {stripe_account: stripe_account}.compact)
@@ -125,7 +99,7 @@ module Pay
         end
 
         # Cache the Stripe subscription on the Pay::Subscription that we return
-        pay_subscription.stripe_subscription = object
+        pay_subscription.api_record = object
 
         # Sync the latest charge if we already have it loaded (like during subscrbe), otherwise, let webhooks take care of creating it
         if (charge = object.try(:latest_invoice).try(:charge)) && charge.try(:status) == "succeeded"
@@ -157,30 +131,20 @@ module Pay
         }
       end
 
-      def initialize(pay_subscription)
-        @pay_subscription = pay_subscription
-      end
-
-      def subscription(**options)
-        options[:id] = processor_id
-        @stripe_subscription ||= ::Stripe::Subscription.retrieve(options.merge(expand_options), {stripe_account: stripe_account}.compact)
-      end
-
-      def reload!
-        @stripe_subscription = nil
+      def api_record(**options)
+        @api_record ||= ::Stripe::Subscription.retrieve(options.with_defaults(id: processor_id).merge(expand_options), {stripe_account: stripe_account}.compact)
       end
 
       # Returns a SetupIntent or PaymentIntent client secret for the subscription
       def client_secret
-        stripe_sub = subscription
-        stripe_sub&.pending_setup_intent&.client_secret || stripe_sub&.latest_invoice&.payment_intent&.client_secret
+        api_record&.pending_setup_intent&.client_secret || api_record&.latest_invoice&.payment_intent&.client_secret
       end
 
       # Sets the default_payment_method on a subscription
       # Pass an empty string to unset
       def update_payment_method(id)
-        @stripe_subscription = ::Stripe::Subscription.update(processor_id, {default_payment_method: id}.merge(expand_options), stripe_options)
-        pay_subscription.update(payment_method_id: @stripe_subscription.default_payment_method&.id)
+        @api_record = ::Stripe::Subscription.update(processor_id, {default_payment_method: id}.merge(expand_options), stripe_options)
+        update(payment_method_id: @api_record.default_payment_method&.id)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -195,8 +159,8 @@ module Pay
         if past_due? && options.fetch(:past_due_cancel_now, true)
           cancel_now!
         else
-          @stripe_subscription = ::Stripe::Subscription.update(processor_id, {cancel_at_period_end: true}.merge(expand_options), stripe_options)
-          pay_subscription.update(ends_at: (on_trial? ? trial_ends_at : Time.at(@stripe_subscription.current_period_end)))
+          @api_record = ::Stripe::Subscription.update(processor_id, {cancel_at_period_end: true}.merge(expand_options), stripe_options)
+          update(ends_at: (on_trial? ? trial_ends_at : Time.at(@api_record.current_period_end)))
         end
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
@@ -209,8 +173,8 @@ module Pay
       def cancel_now!(**options)
         return if canceled? && ends_at.past?
 
-        @stripe_subscription = ::Stripe::Subscription.cancel(processor_id, options.merge(expand_options), stripe_options)
-        pay_subscription.update(ends_at: Time.current, status: :canceled)
+        @api_record = ::Stripe::Subscription.cancel(processor_id, options.merge(expand_options), stripe_options)
+        update(ends_at: Time.current, status: :canceled)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -223,11 +187,11 @@ module Pay
         subscription_item_id = options.delete(:subscription_item_id) || subscription_items&.first&.dig("id")
         if subscription_item_id
           ::Stripe::SubscriptionItem.update(subscription_item_id, options.merge(quantity: quantity), stripe_options)
-          @stripe_subscription = nil
+          @api_record = nil
         else
-          @stripe_subscription = ::Stripe::Subscription.update(processor_id, options.merge(quantity: quantity).merge(expand_options), stripe_options)
+          @api_record = ::Stripe::Subscription.update(processor_id, options.merge(quantity: quantity).merge(expand_options), stripe_options)
         end
-        true
+        update(quantity: quantity)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -265,12 +229,12 @@ module Pay
       # https://docs.stripe.com/billing/subscriptions/pause-payment
       def pause(**options)
         attributes = {pause_collection: options.reverse_merge(behavior: "void")}
-        @stripe_subscription = ::Stripe::Subscription.update(processor_id, attributes.merge(expand_options), stripe_options)
-        behavior = @stripe_subscription.pause_collection&.behavior
-        pay_subscription.update(
+        @api_record = ::Stripe::Subscription.update(processor_id, attributes.merge(expand_options), stripe_options)
+        behavior = @api_record.pause_collection&.behavior
+        update(
           pause_behavior: behavior,
-          pause_resumes_at: (@stripe_subscription.pause_collection&.resumes_at ? Time.at(@stripe_subscription.pause_collection&.resumes_at) : nil),
-          pause_starts_at: ((behavior == "void") ? Time.at(@stripe_subscription.current_period_end) : nil)
+          pause_resumes_at: (@api_record.pause_collection&.resumes_at ? Time.at(@api_record.pause_collection&.resumes_at) : nil),
+          pause_starts_at: ((behavior == "void") ? Time.at(@api_record.current_period_end) : nil)
         )
       end
 
@@ -278,8 +242,8 @@ module Pay
       #
       # https://docs.stripe.com/billing/subscriptions/pause-payment#unpausing
       def unpause
-        @stripe_subscription = ::Stripe::Subscription.update(processor_id, {pause_collection: ""}.merge(expand_options), stripe_options)
-        pay_subscription.update(
+        @api_record = ::Stripe::Subscription.update(processor_id, {pause_collection: ""}.merge(expand_options), stripe_options)
+        update(
           pause_behavior: nil,
           pause_resumes_at: nil,
           pause_starts_at: nil
@@ -298,16 +262,14 @@ module Pay
         if paused?
           unpause
         else
-          @stripe_subscription = ::Stripe::Subscription.update(
-            processor_id,
-            {
-              plan: processor_plan,
-              trial_end: (on_trial? ? trial_ends_at.to_i : "now"),
-              cancel_at_period_end: false
-            }.merge(expand_options),
-            stripe_options
-          )
+          @api_record = ::Stripe::Subscription.update(processor_id, {
+            plan: processor_plan,
+            trial_end: (on_trial? ? trial_ends_at.to_i : "now"),
+            cancel_at_period_end: false
+          }.merge(expand_options),
+            stripe_options)
         end
+        update(ends_at: nil, status: :active)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -317,7 +279,7 @@ module Pay
 
         proration_behavior = options.delete(:proration_behavior) || (prorate ? "always_invoice" : "none")
 
-        @stripe_subscription = ::Stripe::Subscription.update(
+        @api_record = ::Stripe::Subscription.update(
           processor_id,
           {
             cancel_at_period_end: false,
@@ -330,11 +292,11 @@ module Pay
         )
 
         # Validate that swap was successful and handle SCA if needed
-        if (payment_intent = @stripe_subscription.latest_invoice.payment_intent)
+        if (payment_intent = @api_record.latest_invoice.payment_intent)
           Pay::Payment.new(payment_intent).validate
         end
 
-        pay_subscription.sync!(object: @stripe_subscription)
+        sync!(object: @api_record)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
@@ -374,7 +336,7 @@ module Pay
         payment_intent = ::Stripe::PaymentIntent.retrieve({id: payment_intent_id}, stripe_options)
 
         payment_intent = if payment_intent.status == "requires_payment_method"
-          ::Stripe::PaymentIntent.confirm(payment_intent_id, {payment_method: pay_subscription.customer.default_payment_method.processor_id}, stripe_options)
+          ::Stripe::PaymentIntent.confirm(payment_intent_id, {payment_method: customer.default_payment_method.processor_id}, stripe_options)
         else
           ::Stripe::PaymentIntent.confirm(payment_intent_id, stripe_options)
         end
@@ -390,6 +352,10 @@ module Pay
         end
       end
 
+      def latest_payment
+        api_record(expand: ["latest_invoice.payment_intent"]).latest_invoice.payment_intent
+      end
+
       private
 
       # Options for Stripe requests

data/app/models/pay/subscription.rb

@@ -9,7 +9,7 @@ module Pay
 
     # Scopes
     scope :for_name, ->(name) { where(name: name) }
-    scope :on_trial, -> { where(status: ["trialing", "active"]).where("trial_ends_at > ?", Time.current) }
+    scope :on_trial, -> { where(status: ["on_trial", "trialing", "active"]).where("trial_ends_at > ?", Time.current) }
     scope :canceled, -> { where.not(ends_at: nil) }
     scope :cancelled, -> { canceled }
     scope :on_grace_period, -> { where("#{table_name}.ends_at IS NOT NULL AND #{table_name}.ends_at > ?", Time.current) }
@@ -40,10 +40,8 @@ module Pay
     validates :quantity, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 0}
     validates :status, presence: true
 
-    delegate_missing_to :payment_processor
-
     # Helper methods 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
@@ -55,16 +53,8 @@ module Pay
       joins(:customer).find_by(processor_id: processor_id, pay_customers: {processor: processor})
     end
 
-    def self.pay_processor_for(name)
-      "Pay::#{name.to_s.classify}::Subscription".constantize
-    end
-
-    def payment_processor
-      @payment_processor ||= self.class.pay_processor_for(customer.processor).new(self)
-    end
-
     def sync!(**options)
-      self.class.pay_processor_for(customer.processor).sync(processor_id, **options)
+      self.class.sync(processor_id, **options)
       reload
     end
 
@@ -105,6 +95,10 @@ module Pay
       ends_at? && ends_at <= Time.current
     end
 
+    def on_grace_period?
+      ends_at? && ends_at > Time.current
+    end
+
     # If you cancel during a trial, you should still retain access until the end of the trial
     # Otherwise a subscription is active unless it has ended or is currently paused
     # Check the subscription status so we don't accidentally consider "incomplete", "unpaid", or other statuses as active
@@ -129,35 +123,11 @@ module Pay
       past_due? || incomplete?
     end
 
-    def change_quantity(quantity, **options)
-      payment_processor.change_quantity(quantity, **options)
-      update(quantity: quantity)
-    end
-
-    def resume
-      payment_processor.resume
-      update(ends_at: nil, status: :active)
-      self
-    end
-
-    def swap(plan, **options)
-      raise ArgumentError, "plan must be a string. Got `#{plan.inspect}` instead." unless plan.is_a?(String)
-      payment_processor.swap(plan, **options)
-    end
-
     def swap_and_invoice(plan)
       swap(plan)
       customer.invoice!(subscription: processor_id)
     end
 
-    def processor_subscription(**options)
-      payment_processor.subscription(**options)
-    end
-
-    def latest_payment
-      processor_subscription(expand: ["latest_invoice.payment_intent"]).latest_invoice.payment_intent
-    end
-
     private
 
     def cancel_if_active

data/app/models/pay/webhook.rb

@@ -21,6 +21,8 @@ module Pay
         to_recursive_ostruct(event["data"])
       when "paddle_classic"
         to_recursive_ostruct(event)
+      when "lemon_squeezy"
+        Pay::LemonSqueezy.construct_from_webhook_event(event)
       when "stripe"
         ::Stripe::Event.construct_from(event)
       else
@@ -30,7 +32,7 @@ module Pay
 
     def to_recursive_ostruct(obj)
       if obj.is_a?(Hash)
-        OpenStruct.new(obj.map { |key, val| [key, to_recursive_ostruct(val)] }.to_h)
+        ActiveSupport::InheritableOptions.new(obj.map { |key, val| [key.to_sym, to_recursive_ostruct(val)] }.to_h)
       elsif obj.is_a?(Array)
         obj.map { |o| to_recursive_ostruct(o) }
       else # Assumed to be a primitive value

data/config/routes.rb

@@ -6,4 +6,5 @@ Pay::Engine.routes.draw do
   post "webhooks/braintree", to: "pay/webhooks/braintree#create" if Pay::Braintree.enabled?
   post "webhooks/paddle_billing", to: "pay/webhooks/paddle_billing#create" if Pay::PaddleBilling.enabled?
   post "webhooks/paddle_classic", to: "pay/webhooks/paddle_classic#create" if Pay::PaddleClassic.enabled?
+  post "webhooks/lemon_squeezy", to: "pay/webhooks/lemon_squeezy#create" if Pay::LemonSqueezy.enabled?
 end