pay 7.3.0 → 11.2.2

data/app/views/pay/user_mailer/subscription_trial_will_end.text.erb

@@ -0,0 +1,8 @@
+Your <%= Pay.application_name %> trial is ending soon
+
+This is just a friendly reminder that your <%= Pay.application_name %> trial will be ending soon.
+
+You may manage your subscription via your account: <%= root_url %>
+If you have any questions, please hit reply and let us know.
+
+— The <%= Pay.application_name %> Team

data/config/locales/en.yml

@@ -24,6 +24,7 @@ en:
       subtotal: "Subtotal"
       discount: "Discount"
       tax: "Tax"
+      total: "Total excluding tax"
       total: "Total"
       unit_price: "Unit Price"
       percent_discount: "%{name} (%{percent}% off)"

data/config/routes.rb

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

data/db/migrate/20250415151129_add_object_to_pay_models.rb

@@ -0,0 +1,7 @@
+class AddObjectToPayModels < ActiveRecord::Migration[6.0]
+  def change
+    add_column :pay_charges, :object, Pay::Adapter.json_column_type
+    add_column :pay_customers, :object, Pay::Adapter.json_column_type
+    add_column :pay_subscriptions, :object, Pay::Adapter.json_column_type
+  end
+end

data/db/migrate/2_add_pay_sti_columns.rb

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

data/lib/pay/attributes.rb

@@ -13,8 +13,8 @@ module Pay
         cattr_accessor :pay_braintree_customer_attributes
 
         has_many :pay_customers, class_name: "Pay::Customer", as: :owner, inverse_of: :owner
-        has_many :charges, through: :pay_customers, class_name: "Pay::Charge"
-        has_many :subscriptions, through: :pay_customers, class_name: "Pay::Subscription"
+        has_many :pay_charges, through: :pay_customers, class_name: "Pay::Charge", source: :charges
+        has_many :pay_subscriptions, through: :pay_customers, class_name: "Pay::Subscription", source: :subscriptions
         has_one :payment_processor, -> { where(default: true, deleted_at: nil) }, class_name: "Pay::Customer", as: :owner, inverse_of: :owner
 
         after_commit :cancel_active_pay_subscriptions!, on: [:destroy]
@@ -31,9 +31,13 @@ module Pay
       def set_payment_processor(processor_name, allow_fake: false, **attributes)
         raise Pay::Error, "Processor `#{processor_name}` is not allowed" if processor_name.to_s == "fake_processor" && !allow_fake
 
-        ActiveRecord::Base.transaction do
+        # Safety check to make sure this is a valid Pay processor
+        klass = "Pay::#{processor_name.to_s.classify}::Customer".constantize
+        raise ArgumentError, "not a valid payment processor" if klass.ancestors.exclude?(Pay::Customer)
+
+        with_lock do
           pay_customers.update_all(default: false)
-          pay_customer = pay_customers.active.where(processor: processor_name).first_or_initialize
+          pay_customer = pay_customers.active.where(processor: processor_name, type: klass.name).first_or_initialize
           pay_customer.update!(attributes.merge(default: true))
         end
 
@@ -44,7 +48,11 @@ module Pay
       def add_payment_processor(processor_name, allow_fake: false, **attributes)
         raise Pay::Error, "Processor `#{processor_name}` is not allowed" if processor_name.to_s == "fake_processor" && !allow_fake
 
-        pay_customer = pay_customers.active.where(processor: processor_name).first_or_initialize
+        # Safety check to make sure this is a valid Pay processor
+        klass = "Pay::#{processor_name.to_s.classify}::Customer".constantize
+        raise ArgumentError, "not a valid payment processor" if klass.ancestors.exclude?(Pay::Customer)
+
+        pay_customer = pay_customers.active.where(processor: processor_name, type: klass.name).first_or_initialize
         pay_customer.update!(attributes)
         pay_customer
       end
@@ -60,7 +68,7 @@ module Pay
       end
 
       def cancel_active_pay_subscriptions!
-        subscriptions.active.each(&:cancel_now!)
+        pay_subscriptions.active.each(&:cancel_now!)
       end
     end
 
@@ -73,9 +81,9 @@ module Pay
       end
 
       def set_merchant_processor(processor_name, **attributes)
-        ActiveRecord::Base.transaction do
+        with_lock do
           pay_merchants.update_all(default: false)
-          pay_merchant = pay_merchants.where(processor: processor_name).first_or_initialize
+          pay_merchant = pay_merchants.where(processor: processor_name, type: "Pay::#{processor_name.to_s.classify}::Merchant").first_or_initialize
           pay_merchant.update!(attributes.merge(default: true))
         end
 

data/lib/pay/braintree.rb

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

data/lib/pay/engine.rb

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

data/lib/pay/fake_processor.rb

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

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

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

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

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

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

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

data/lib/pay/lemon_squeezy.rb

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

data/lib/pay/nano_id.rb

@@ -5,7 +5,7 @@ module Pay
     ALPHABET_SIZE = ALPHABET.size
 
     def self.generate(size: 21)
-      id = ""
+      id = +""
       size.times { id << ALPHABET[(Random.rand * ALPHABET_SIZE).floor] }
       id
     end

data/lib/pay/paddle_billing.rb

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

data/lib/pay/paddle_classic/webhooks/signature_verifier.rb

@@ -61,7 +61,7 @@ module Pay
         # array will be assumed to be an associative array, and will be serialized
         # as a PHP associative array rather than a multidimensional array.
         def serialize(var, assoc = false)
-          s = ""
+          s = +""
           case var
           when Array
             s << "a:#{var.size}:{"

data/lib/pay/paddle_classic.rb

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