pay 7.1.0 → 7.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 731897282e09b738950bdef4b213ef808bc39cae0bbc84c43840de743e9611f4
-  data.tar.gz: 44624d892463cf3e40206fba9c812005ff4e8fab13642ed932d966c3ec02dafb
+  metadata.gz: b50cc63cfa61beffbc725d9f6c623c469a6357e0808ff06d3e814c4aa4e19955
+  data.tar.gz: ae87dbfcd24862baa2f156cb2b1b94fe836a0d113853b562cbe59835e59569c5
 SHA512:
-  metadata.gz: d4d24fca5a2619c32d5b0a6e45b2ca5ca20654719bca47bcc377799716e4aeb54a2059fe05ea522db24394ce366c6181fb0ba4051065d1a0039f48236ff48dca
-  data.tar.gz: 5131748acaed2da28332e6d853b66b086c1354eafc7880669ae291cec664bbed35dfa194e7ddcb4060097e42fc18f5c0e2e5f69cf1a4fe7c40501926f2b208ea
+  metadata.gz: 459524ff5b772a08c1ee1d994088b71f0e9a854f4b1afa76ecdb60fa8229f43ea72ed327a6dbf55d497478d033f99f1d19c4ed978c69931e27ad9ddc99fd57af
+  data.tar.gz: 200898e080a94d76520e0a85088d43691f64a27da3d94ac4fa74a9f14db4f6a5c1bdc16992422b3f4c4ab9b63bb35344e099799984cca0beb4cff8a6dc6e8512

data/README.md

@@ -44,7 +44,7 @@ Want to add a new payment provider? Contributions are welcome.
 * **Payment Processors**
   * [Stripe](docs/stripe/1_overview.md)
   * [Braintree](docs/braintree/1_overview.md)
-  * [Paddle](docs/paddle/1_overview.md)
+  * [Paddle](docs/paddle_billing/1_overview.md)
   * [Fake Processor](docs/fake_processor/1_overview.md)
 * **Marketplaces**
   * [Stripe Connect](docs/marketplaces/stripe_connect.md)
@@ -55,6 +55,10 @@ Want to add a new payment provider? Contributions are welcome.
 
 If you have an issue you'd like to submit, please do so using the issue tracker in GitHub. In order for us to help you in the best way possible, please be as detailed as you can.
 
+For those using devcontainers, if you want to test the application with different databases:
+1. Uncomment the `DATABASE_URL` corresponding to the database type you wish to use in the `.devcontainer/devcontainer.json` file.
+2. Rebuild the devcontainer, which will configure the application to use the selected database for your development environment.
+
 If you'd like to open a PR please make sure the following things pass:
 
 ```ruby

data/app/models/pay/charge.rb

@@ -45,7 +45,7 @@ module Pay
 
     # Helpers for payment processors
     %w[braintree stripe paddle_billing paddle_classic fake_processor].each do |processor_name|
-      define_method "#{processor_name}?" do
+      define_method :"#{processor_name}?" do
         customer.processor == processor_name
       end
 

data/app/models/pay/customer.rb

@@ -28,7 +28,7 @@ module Pay
     %w[stripe braintree paddle_billing paddle_classic fake_processor].each do |processor_name|
       scope processor_name, -> { where(processor: processor_name) }
 
-      define_method "#{processor_name}?" do
+      define_method :"#{processor_name}?" do
         processor == processor_name
       end
     end

data/app/models/pay/subscription.rb

@@ -9,11 +9,11 @@ module Pay
 
     # Scopes
     scope :for_name, ->(name) { where(name: name) }
-    scope :on_trial, -> { where("trial_ends_at > ?", Time.current) }
+    scope :on_trial, -> { where(status: ["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) }
-    scope :active, -> { where(status: ["trialing", "active"]).pause_not_started.where("#{table_name}.ends_at IS NULL OR #{table_name}.ends_at > ?", Time.current).where("trial_ends_at IS NULL OR trial_ends_at > ?", Time.current) }
+    scope :active, -> { where(status: "active").pause_not_started.where("#{table_name}.ends_at IS NULL OR #{table_name}.ends_at > ?", Time.current).or(on_trial) }
     scope :paused, -> { where(status: "paused").or(where("pause_starts_at <= ?", Time.current)) }
     scope :pause_not_started, -> { where("pause_starts_at IS NULL OR pause_starts_at > ?", Time.current) }
     scope :active_or_paused, -> { active.or(paused) }
@@ -44,7 +44,7 @@ module Pay
 
     # Helper methods for payment processors
     %w[braintree stripe paddle_billing paddle_classic fake_processor].each do |processor_name|
-      define_method "#{processor_name}?" do
+      define_method :"#{processor_name}?" do
         customer.processor == processor_name
       end
 

data/lib/pay/braintree/billable.rb

@@ -265,7 +265,7 @@ module Pay
           end
 
           # Retrieve payment method details from transaction
-          payment_method = transaction.send("#{attribute_name}_details")
+          payment_method = transaction.send(:"#{attribute_name}_details")
 
           {
             payment_method_type: :card,

data/lib/pay/fake_processor/billable.rb

@@ -28,7 +28,8 @@ module Pay
         # Make to generate a processor_id
         customer
 
-        attributes = options.merge(
+        valid_attributes = options.slice(*Pay::Charge.attribute_names.map(&:to_sym))
+        attributes = {
           processor_id: NanoId.generate,
           amount: amount,
           data: {
@@ -38,7 +39,7 @@ module Pay
             exp_month: Date.today.month,
             exp_year: Date.today.year
           }
-        )
+        }.deep_merge(valid_attributes)
         pay_customer.charges.create!(attributes)
       end
 

data/lib/pay/paddle_billing/charge.rb

@@ -37,8 +37,8 @@ module Pay
           subscription: pay_customer.subscriptions.find_by(processor_id: object.subscription_id)
         }
 
-        if object.payment
-          case object.payment.method_details.type.downcase
+        if (details = Array.wrap(object.payments).first&.method_details)
+          case details.type.downcase
           when "card"
             attrs[:payment_method_type] = "card"
             attrs[:brand] = details.card.type

data/lib/pay/paddle_billing/payment_method.rb

@@ -5,6 +5,13 @@ module Pay
 
       delegate :customer, :processor_id, to: :pay_payment_method
 
+      def self.sync_from_transaction(pay_customer:, transaction:)
+        transaction = ::Paddle::Transaction.retrieve(id: transaction)
+        return unless transaction.status == "completed"
+        return if transaction.payments.empty?
+        sync(pay_customer: pay_customer, attributes: transaction.payments.first)
+      end
+
       def self.sync(pay_customer:, attributes:)
         details = attributes.method_details
         attrs = {
@@ -19,7 +26,7 @@ module Pay
           attrs[:exp_year] = details.card.expiry_year
         end
 
-        payment_method = pay_customer.payment_methods.find_or_initialize_by(processor_id: attributes.stored_payment_method_id)
+        payment_method = pay_customer.payment_methods.find_or_initialize_by(processor_id: attributes.payment_method_id)
         payment_method.update!(attrs)
         payment_method
       end

data/lib/pay/paddle_billing/subscription.rb

@@ -56,9 +56,13 @@ module Pay
           # Remove payment methods since customer cannot be reused after cancelling
           Pay::PaymentMethod.where(customer_id: object.customer_id).destroy_all
         when "trialing"
-          attributes[:trial_ends_at] = Time.parse(object.next_billed_at)
+          attributes[:trial_ends_at] = Time.parse(object.next_billed_at) if object.next_billed_at
         when "paused"
-          attributes[:pause_starts_at] = Time.parse(object.paused_at)
+          attributes[:pause_starts_at] = Time.parse(object.paused_at) if object.paused_at
+        when "active", "past_due"
+          attributes[:trial_ends_at] = nil
+          attributes[:pause_starts_at] = nil
+          attributes[:ends_at] = nil
         end
 
         case object.scheduled_change&.action
@@ -105,7 +109,7 @@ module Pay
         )
         pay_subscription.update(
           status: response.status,
-          ends_at: response.scheduled_change.effective_at
+          ends_at: response.scheduled_change&.effective_at || Time.current
         )
       rescue ::Paddle::Error => e
         raise Pay::PaddleBilling::Error, e

data/lib/pay/paddle_classic/subscription.rb

@@ -44,12 +44,15 @@ module Pay
           status: object.state || object.status
         }
 
-        # If paused or delete while on trial, set ends_at to match
         case attributes[:status]
         when "trialing"
           attributes[:trial_ends_at] = Time.zone.parse(object.next_bill_date)
           attributes[:ends_at] = nil
+        when "active", "past_due"
+          attributes[:trial_ends_at] = nil
+          attributes[:ends_at] = nil
         when "paused", "deleted"
+          # If paused or delete while on trial, set ends_at to match
           attributes[:trial_ends_at] = nil
           attributes[:ends_at] = Time.zone.parse(object.next_bill_date)
         end

data/lib/pay/stripe/charge.rb

@@ -29,7 +29,7 @@ module Pay
         refunds = []
         object.refunds.auto_paging_each { |refund| refunds << refund }
 
-        payment_method = object.payment_method_details.send(object.payment_method_details.type)
+        payment_method = object.payment_method_details.try(object.payment_method_details.type)
         attrs = {
           amount: object.amount,
           amount_captured: object.amount_captured,

data/lib/pay/stripe/payment_method.rb

@@ -60,7 +60,7 @@ module Pay
 
       # Extracts payment method details from a Stripe::PaymentMethod object
       def self.extract_attributes(payment_method)
-        details = payment_method.send(payment_method.type)
+        details = payment_method.try(payment_method.type)
 
         {
           payment_method_type: payment_method.type,

data/lib/pay/stripe/subscription.rb

@@ -207,7 +207,7 @@ module Pay
       # cancel_now!(prorate: true)
       # cancel_now!(invoice_now: true)
       def cancel_now!(**options)
-        return if canceled?
+        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)
@@ -342,13 +342,13 @@ module Pay
       # create_usage_record(quantity: 4, action: :increment)
       # create_usage_record(subscription_item_id: "si_1234", quantity: 100, action: :set)
       def create_usage_record(**options)
-        subscription_item_id = options.fetch(:subscription_item_id, metered_subscription_item&.dig("id"))
+        subscription_item_id = options.delete(:subscription_item_id) || metered_subscription_item&.dig("id")
         ::Stripe::SubscriptionItem.create_usage_record(subscription_item_id, options, stripe_options)
       end
 
       # Returns usage record summaries for a subscription item
       def usage_record_summaries(**options)
-        subscription_item_id = options.fetch(:subscription_item_id, metered_subscription_item&.dig("id"))
+        subscription_item_id = options.delete(:subscription_item_id) || metered_subscription_item&.dig("id")
         ::Stripe::SubscriptionItem.list_usage_record_summaries(subscription_item_id, options, stripe_options)
       end
 

data/lib/pay/stripe.rb

@@ -30,7 +30,7 @@ module Pay
 
     extend Env
 
-    REQUIRED_VERSION = "~> 10"
+    REQUIRED_VERSION = "~> 11"
 
     # A list of database model names that include Pay
     # Used for safely looking up models with client_reference_id

data/lib/pay/version.rb

@@ -1,3 +1,3 @@
 module Pay
-  VERSION = "7.1.0"
+  VERSION = "7.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pay
 version: !ruby/object:Gem::Version
-  version: 7.1.0
+  version: 7.2.0
 platform: ruby
 authors:
 - Jason Charnes
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-06 00:00:00.000000000 Z
+date: 2024-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -104,14 +104,6 @@ files:
 - lib/pay/fake_processor/merchant.rb
 - lib/pay/fake_processor/payment_method.rb
 - lib/pay/fake_processor/subscription.rb
-- lib/pay/lemon_squeezy.rb
-- lib/pay/lemon_squeezy/billable.rb
-- lib/pay/lemon_squeezy/charge.rb
-- lib/pay/lemon_squeezy/error.rb
-- lib/pay/lemon_squeezy/payment_method.rb
-- lib/pay/lemon_squeezy/subscription.rb
-- lib/pay/lemon_squeezy/webhooks/subscription.rb
-- lib/pay/lemon_squeezy/webhooks/transaction_completed.rb
 - lib/pay/nano_id.rb
 - lib/pay/paddle_billing.rb
 - lib/pay/paddle_billing/billable.rb
@@ -184,7 +176,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: Payments engine for Ruby on Rails

data/lib/pay/lemon_squeezy/billable.rb

@@ -1,90 +0,0 @@
-module Pay
-  module PaddleBilling
-    class Billable
-      attr_reader :pay_customer
-
-      delegate :processor_id,
-        :processor_id?,
-        :email,
-        :customer_name,
-        :card_token,
-        to: :pay_customer
-
-      def initialize(pay_customer)
-        @pay_customer = pay_customer
-      end
-
-      def customer_attributes
-        {email: email, name: customer_name}
-      end
-
-      # Retrieves a Paddle::Customer object
-      #
-      # Finds an existing Paddle::Customer if processor_id exists
-      # Creates a new Paddle::Customer using `email` and `customer_name` if empty processor_id
-      #
-      # Returns a Paddle::Customer object
-      def customer
-        if processor_id?
-          ::Paddle::Customer.retrieve(id: processor_id)
-        else
-          sc = ::Paddle::Customer.create(email: email, name: customer_name)
-          pay_customer.update!(processor_id: sc.id)
-          sc
-        end
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      # Syncs name and email to Paddle::Customer
-      # You can also pass in other attributes that will be merged into the default attributes
-      def update_customer!(**attributes)
-        customer unless processor_id?
-        attrs = customer_attributes.merge(attributes)
-        ::Paddle::Customer.update(id: processor_id, **attrs)
-      end
-
-      def charge(amount, options = {})
-        return Pay::Error unless options
-
-        items = options[:items]
-        opts = options.except(:items).merge(customer_id: processor_id)
-        transaction = ::Paddle::Transaction.create(items: items, **opts)
-
-        attrs = {
-          amount: transaction.details.totals.grand_total,
-          created_at: transaction.created_at,
-          currency: transaction.currency_code,
-          metadata: transaction.details.line_items&.first&.id
-        }
-
-        charge = pay_customer.charges.find_or_initialize_by(processor_id: transaction.id)
-        charge.update(attrs)
-        charge
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
-        # pass
-      end
-
-      # Paddle does not use payment method tokens. The method signature has it here
-      # to have a uniform API with the other payment processors.
-      def add_payment_method(token = nil, default: true)
-        Pay::PaddleBilling::PaymentMethod.sync(pay_customer: pay_customer)
-      end
-
-      def trial_end_date(subscription)
-        return unless subscription.state == "trialing"
-        Time.zone.parse(subscription.next_payment[:date]).end_of_day
-      end
-
-      def processor_subscription(subscription_id, options = {})
-        ::Paddle::Subscription.retrieve(id: subscription_id, **options)
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-    end
-  end
-end

data/lib/pay/lemon_squeezy/charge.rb

@@ -1,68 +0,0 @@
-module Pay
-  module PaddleBilling
-    class Charge
-      attr_reader :pay_charge
-
-      delegate :processor_id, :customer, to: :pay_charge
-
-      def initialize(pay_charge)
-        @pay_charge = pay_charge
-      end
-
-      def self.sync(charge_id, object: nil, try: 0, retries: 1)
-        # Skip loading the latest charge details from the API if we already have it
-        object ||= ::Paddle::Transaction.retrieve(id: charge_id)
-
-        # Ignore transactions that aren't completed
-        return unless object.status == "completed"
-
-        # Ignore charges without a Customer
-        return if object.customer_id.blank?
-
-        pay_customer = Pay::Customer.find_by(processor: :paddle_billing, processor_id: object.customer_id)
-        return unless pay_customer
-
-        # Ignore transactions that are payment method changes
-        # But update the customer's payment method
-        if object.origin == "subscription_payment_method_change"
-          Pay::PaddleBilling::PaymentMethod.sync(pay_customer: pay_customer, attributes: object.payments.first)
-          return
-        end
-
-        attrs = {
-          amount: object.details.totals.grand_total,
-          created_at: object.created_at,
-          currency: object.currency_code,
-          metadata: object.details.line_items&.first&.id,
-          subscription: pay_customer.subscriptions.find_by(processor_id: object.subscription_id)
-        }
-
-        if object.payment
-          case object.payment.method_details.type.downcase
-          when "card"
-            attrs[:payment_method_type] = "card"
-            attrs[:brand] = details.card.type
-            attrs[:exp_month] = details.card.expiry_month
-            attrs[:exp_year] = details.card.expiry_year
-            attrs[:last4] = details.card.last4
-          when "paypal"
-            attrs[:payment_method_type] = "paypal"
-          end
-
-          # Update customer's payment method
-          Pay::PaddleBilling::PaymentMethod.sync(pay_customer: pay_customer, attributes: object.payments.first)
-        end
-
-        # Update or create the charge
-        if (pay_charge = pay_customer.charges.find_by(processor_id: object.id))
-          pay_charge.with_lock do
-            pay_charge.update!(attrs)
-          end
-          pay_charge
-        else
-          pay_customer.charges.create!(attrs.merge(processor_id: object.id))
-        end
-      end
-    end
-  end
-end

data/lib/pay/lemon_squeezy/error.rb

@@ -1,7 +0,0 @@
-module Pay
-  module PaddleBilling
-    class Error < Pay::Error
-      delegate :message, to: :cause
-    end
-  end
-end

data/lib/pay/lemon_squeezy/payment_method.rb

@@ -1,40 +0,0 @@
-module Pay
-  module PaddleBilling
-    class PaymentMethod
-      attr_reader :pay_payment_method
-
-      delegate :customer, :processor_id, to: :pay_payment_method
-
-      def self.sync(pay_customer:, attributes:)
-        details = attributes.method_details
-        attrs = {
-          type: details.type.downcase
-        }
-
-        case details.type.downcase
-        when "card"
-          attrs[:brand] = details.card.type
-          attrs[:last4] = details.card.last4
-          attrs[:exp_month] = details.card.expiry_month
-          attrs[:exp_year] = details.card.expiry_year
-        end
-
-        payment_method = pay_customer.payment_methods.find_or_initialize_by(processor_id: attributes.stored_payment_method_id)
-        payment_method.update!(attrs)
-        payment_method
-      end
-
-      def initialize(pay_payment_method)
-        @pay_payment_method = pay_payment_method
-      end
-
-      # Sets payment method as default
-      def make_default!
-      end
-
-      # Remove payment method
-      def detach
-      end
-    end
-  end
-end

data/lib/pay/lemon_squeezy/subscription.rb

@@ -1,185 +0,0 @@
-module Pay
-  module PaddleBilling
-    class Subscription
-      attr_reader :pay_subscription
-
-      delegate :active?,
-        :canceled?,
-        :on_grace_period?,
-        :on_trial?,
-        :ends_at,
-        :name,
-        :owner,
-        :pause_starts_at,
-        :pause_starts_at?,
-        :processor_id,
-        :processor_plan,
-        :processor_subscription,
-        :prorate,
-        :prorate?,
-        :quantity,
-        :quantity?,
-        :trial_ends_at,
-        to: :pay_subscription
-
-      def self.sync_from_transaction(transaction_id)
-        transaction = ::Paddle::Transaction.retrieve(id: transaction_id)
-        sync(transaction.subscription_id) if transaction.subscription_id
-      end
-
-      def self.sync(subscription_id, object: nil, name: Pay.default_product_name)
-        # Passthrough is not return from this API, so we can't use that
-        object ||= ::Paddle::Subscription.retrieve(id: subscription_id)
-
-        pay_customer = Pay::Customer.find_by(processor: :paddle_billing, processor_id: object.customer_id)
-        return unless pay_customer
-
-        attributes = {
-          current_period_end: object.current_billing_period&.ends_at,
-          current_period_start: object.current_billing_period&.starts_at,
-          ends_at: (object.canceled_at ? Time.parse(object.canceled_at) : nil),
-          metadata: object.custom_data,
-          paddle_cancel_url: object.management_urls&.cancel,
-          paddle_update_url: object.management_urls&.update_payment_method,
-          pause_starts_at: (object.paused_at ? Time.parse(object.paused_at) : nil),
-          status: object.status
-        }
-
-        if object.items&.first
-          item = object.items.first
-          attributes[:processor_plan] = item.price.id
-          attributes[:quantity] = item.quantity
-        end
-
-        case attributes[:status]
-        when "canceled"
-          # Remove payment methods since customer cannot be reused after cancelling
-          Pay::PaymentMethod.where(customer_id: object.customer_id).destroy_all
-        when "trialing"
-          attributes[:trial_ends_at] = Time.parse(object.next_billed_at)
-        when "paused"
-          attributes[:pause_starts_at] = Time.parse(object.paused_at)
-        end
-
-        case object.scheduled_change&.action
-        when "cancel"
-          attributes[:ends_at] = Time.parse(object.scheduled_change.effective_at)
-        when "pause"
-          attributes[:pause_starts_at] = Time.parse(object.scheduled_change.effective_at)
-        when "resume"
-          attributes[:pause_resumes_at] = Time.parse(object.scheduled_change.effective_at)
-        end
-
-        # Update or create the subscription
-        if (pay_subscription = pay_customer.subscriptions.find_by(processor_id: subscription_id))
-          pay_subscription.with_lock do
-            pay_subscription.update!(attributes)
-          end
-          pay_subscription
-        else
-          pay_customer.subscriptions.create!(attributes.merge(name: name, processor_id: subscription_id))
-        end
-      end
-
-      def initialize(pay_subscription)
-        @pay_subscription = pay_subscription
-      end
-
-      def subscription(**options)
-        @paddle_billing_subscription ||= ::Paddle::Subscription.retrieve(id: processor_id, **options)
-      end
-
-      # Get a transaction to update payment method
-      def payment_method_transaction
-        ::Paddle::Subscription.get_transaction(id: processor_id)
-      end
-
-      # If a subscription is paused, cancel immediately
-      # Otherwise, cancel at period end
-      def cancel(**options)
-        return if canceled?
-
-        response = ::Paddle::Subscription.cancel(
-          id: processor_id,
-          effective_from: options.fetch(:effective_from, (paused? ? "immediately" : "next_billing_period"))
-        )
-        pay_subscription.update(
-          status: response.status,
-          ends_at: response.scheduled_change.effective_at
-        )
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      def cancel_now!(**options)
-        cancel(options.merge(effective_from: "immediately"))
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      def change_quantity(quantity, **options)
-        items = [{
-          price_id: processor_plan,
-          quantity: quantity
-        }]
-
-        ::Paddle::Subscription.update(id: processor_id, items: items, proration_billing_mode: "prorated_immediately")
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      # A subscription could be set to cancel or pause in the future
-      # It is considered on grace period until the cancel or pause time begins
-      def on_grace_period?
-        (canceled? && Time.current < ends_at) || (paused? && pause_starts_at? && Time.current < pause_starts_at)
-      end
-
-      def paused?
-        pay_subscription.status == "paused"
-      end
-
-      def pause
-        response = ::Paddle::Subscription.pause(id: processor_id)
-        pay_subscription.update!(status: :paused, pause_starts_at: response.scheduled_change.effective_at)
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      def resumable?
-        paused?
-      end
-
-      def resume
-        unless resumable?
-          raise StandardError, "You can only resume paused subscriptions."
-        end
-
-        # Paddle Billing API only allows "resuming" subscriptions when they are paused
-        # So cancel the scheduled change if it is in the future
-        if paused? && pause_starts_at? && Time.current < pause_starts_at
-          ::Paddle::Subscription.update(id: processor_id, scheduled_change: nil)
-        else
-          ::Paddle::Subscription.resume(id: processor_id, effective_from: "immediately")
-        end
-
-        pay_subscription.update(status: :active, pause_starts_at: nil)
-      rescue ::Paddle::Error => e
-        raise Pay::PaddleBilling::Error, e
-      end
-
-      def swap(plan, **options)
-        items = [{
-          price_id: plan,
-          quantity: quantity || 1
-        }]
-
-        ::Paddle::Subscription.update(id: processor_id, items: items, proration_billing_mode: "prorated_immediately")
-        pay_subscription.update(processor_plan: plan, ends_at: nil, status: :active)
-      end
-
-      # Retries the latest invoice for a Past Due subscription
-      def retry_failed_payment
-      end
-    end
-  end
-end

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

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

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

@@ -1,11 +0,0 @@
-module Pay
-  module PaddleBilling
-    module Webhooks
-      class TransactionCompleted
-        def call(event)
-          Pay::PaddleBilling::Charge.sync(event.id)
-        end
-      end
-    end
-  end
-end

data/lib/pay/lemon_squeezy.rb

@@ -1,138 +0,0 @@
-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"
-
-    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"
-    end
-
-    extend Env
-
-    REQUIRED_VERSION = "~> 1"
-
-    def self.enabled?
-      return false unless Pay.enabled_processors.include?(:lemonsqueezy) && defined?(::Lemonzsqueezy)
-
-      Pay::Engine.version_matches?(required: REQUIRED_VERSION, current: ::Lemonsqueezy::VERSION) || (raise "[Pay] lemonsqueezy gem must be version #{REQUIRED_VERSION}")
-    end
-
-    def self.setup
-      ::Stripe.api_key = private_key
-
-      # 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")
-
-      # 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
-    end
-
-    def self.public_key
-      find_value_by_name(:stripe, :public_key)
-    end
-
-    def self.private_key
-      find_value_by_name(:stripe, :private_key)
-    end
-
-    def self.signing_secret
-      find_value_by_name(:stripe, :signing_secret)
-    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
-      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("_")
-    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)
-
-      model_name.constantize.find(id)
-    rescue ActiveRecord::RecordNotFound
-      Rails.logger.error "[Pay] Unable to locate record with: #{client_reference_id}"
-      nil
-    end
-  end
-end