pay 7.2.0 → 7.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b50cc63cfa61beffbc725d9f6c623c469a6357e0808ff06d3e814c4aa4e19955
-  data.tar.gz: ae87dbfcd24862baa2f156cb2b1b94fe836a0d113853b562cbe59835e59569c5
+  metadata.gz: 3ec013c6c05d0e8027b628258882c9bac3a01f7942e9654cc52582643cf57629
+  data.tar.gz: 75bcbbfcd8b63bb0f73e97b4a4da41335923f5f3af2e8577fc1f2aa94baa8542
 SHA512:
-  metadata.gz: 459524ff5b772a08c1ee1d994088b71f0e9a854f4b1afa76ecdb60fa8229f43ea72ed327a6dbf55d497478d033f99f1d19c4ed978c69931e27ad9ddc99fd57af
-  data.tar.gz: 200898e080a94d76520e0a85088d43691f64a27da3d94ac4fa74a9f14db4f6a5c1bdc16992422b3f4c4ab9b63bb35344e099799984cca0beb4cff8a6dc6e8512
+  metadata.gz: dd2822689a009a126f016365182312e4555098ba40b429e16c1dc41b76902a4fd18da06e3465b25cf17e0bf53371adf147bfd3c72e2c9186ce965de304f403e4
+  data.tar.gz: 1ad32b2e21be33e58ffb855dec4275cdff66d036a1728f2573d54d61a2937c6aa6c4602cb59f1dc53bea2edcd4fac46f89efcb91a5ea22443669087569959e5b

data/app/controllers/pay/webhooks/stripe_controller.rb

@@ -6,7 +6,8 @@ module Pay
       end
 
       def create
-        queue_event(verified_event)
+        event = verified_event
+        queue_event(event) if event.livemode || Pay::Stripe.webhook_receive_test_events
         head :ok
       rescue ::Stripe::SignatureVerificationError => e
         log_error(e)

data/lib/pay/fake_processor/billable.rb

@@ -79,7 +79,11 @@ module Pay
           }
         )
 
-        pay_customer.reload_default_payment_method if default
+        if default
+          pay_customer.payment_methods.where.not(id: pay_payment_method.id).update_all(default: false)
+          pay_customer.reload_default_payment_method
+        end
+
         pay_payment_method
       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/stripe/subscription.rb

@@ -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/webhooks/checkout_session_completed.rb

@@ -10,7 +10,7 @@ module Pay
 
           if (payment_intent_id = event.data.object.payment_intent)
             payment_intent = ::Stripe::PaymentIntent.retrieve({id: payment_intent_id}, {stripe_account: event.try(:account)}.compact)
-            Pay::Stripe::Charge.sync(payment_intent.latest_charge, stripe_account: event.try(:account))
+            Pay::Stripe::Charge.sync(payment_intent.latest_charge, stripe_account: event.try(:account)) if payment_intent.latest_charge
           end
 
           if (subscription_id = event.data.object.subscription)

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

@@ -8,7 +8,7 @@ module Pay
           pay_subscription = Pay::Subscription.find_by_processor_and_id(:stripe, object.id)
           return if pay_subscription.nil?
 
-          pay_subscription.sync!
+          pay_subscription.sync!(stripe_account: event.try(:account))
 
           pay_user_mailer = Pay.mailer.with(pay_customer: pay_subscription.customer, pay_subscription: pay_subscription)
 

data/lib/pay/stripe.rb

@@ -30,7 +30,7 @@ module Pay
 
     extend Env
 
-    REQUIRED_VERSION = "~> 11"
+    REQUIRED_VERSION = "~> 12"
 
     # A list of database model names that include Pay
     # Used for safely looking up models with client_reference_id
@@ -66,6 +66,11 @@ module Pay
       find_value_by_name(:stripe, :signing_secret)
     end
 
+    def self.webhook_receive_test_events
+      value = find_value_by_name(:stripe, :webhook_receive_test_events)
+      value.blank? ? true : ActiveModel::Type::Boolean.new.cast(value)
+    end
+
     def self.configure_webhooks
       Pay::Webhooks.configure do |events|
         # Listen to the charge event to make sure we get non-subscription

data/lib/pay/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pay
 version: !ruby/object:Gem::Version
-  version: 7.2.0
+  version: 7.3.0
 platform: ruby
 authors:
 - Jason Charnes
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-16 00:00:00.000000000 Z
+date: 2024-07-09 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.6
+rubygems_version: 3.5.13
 signing_key:
 specification_version: 4
 summary: Payments engine for Ruby on Rails