pay 7.1.1 → 7.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5976a641a8e7a7eafa74d343fa1bdb2ab4c1b07d234d44e1efafba5b9b34b34d
-  data.tar.gz: 57f00237ae29f1a611f714f473a05de859277cdc5bb515741cefa5f75426b393
+  metadata.gz: 690bb7ad1078274199d3a9c3c32b5ace7fb405bf0c37f0bcabeffeb8af734902
+  data.tar.gz: 1e0df19aea4d907f3878450fcbb320421a3abb7da1fe0187ba7bde1878267d60
 SHA512:
-  metadata.gz: '0396532d1af2f80400facc5f6294d7b2f6bcbeab373d004a241e05eb8213a4c91c09ae3fd28655501fec298cfb75520c8506ce697629f41e21cfc961cb76b7bc'
-  data.tar.gz: 6e0a26efaf1eb11347ab34c2eac50a25ed59d4f6b9b8eaa11707eb6f3b0d72d4708c3dcb399cbf915999343fd35625397c00c800f90853634db8da00c24643a7
+  metadata.gz: a0767157a5d6ecc7a710e71047080b4e5d6edbdf4a27fb7f2fcfbf585558b68b43af5f483d87815668dcc4d85128f3fe6c098a5fc2899195529142a1ba3682fa
+  data.tar.gz: 400de12e3525fc3395ba4bf4dd8b2df158de62cb18db60a298d51acec1fe1a16fa0c32f0f3750f9f8a01f0337de9f71d61b33628e0c39848508dc818c85f5356

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/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) }

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/lemon_squeezy/billable.rb

@@ -0,0 +1,90 @@
+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

@@ -0,0 +1,68 @@
+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

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

data/lib/pay/lemon_squeezy/payment_method.rb

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,185 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,138 @@
+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

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,9 @@ 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
@@ -109,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/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)
@@ -261,6 +261,8 @@ module Pay
       #
       # pause_behavior of `void` is considered active until the end of the current period and not active after that. The current_period_end is stored as `pause_starts_at`
       # Other pause_behaviors do not set `pause_starts_at` because they are used for offering free services
+      #
+      # 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)
@@ -273,8 +275,10 @@ module Pay
       end
 
       # Unpauses a subscription
+      #
+      # https://docs.stripe.com/billing/subscriptions/pause-payment#unpausing
       def unpause
-        @stripe_subscription = ::Stripe::Subscription.update(processor_id, {pause_collection: nil}.merge(expand_options), stripe_options)
+        @stripe_subscription = ::Stripe::Subscription.update(processor_id, {pause_collection: ""}.merge(expand_options), stripe_options)
         pay_subscription.update(
           pause_behavior: nil,
           pause_resumes_at: nil,

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.1"
+  VERSION = "7.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pay
 version: !ruby/object:Gem::Version
-  version: 7.1.1
+  version: 7.2.1
 platform: ruby
 authors:
 - Jason Charnes
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-12 00:00:00.000000000 Z
+date: 2024-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -104,6 +104,14 @@ 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
@@ -176,7 +184,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
 summary: Payments engine for Ruby on Rails