Best way to handle fulfillment for subscriptions: webhook listeners or model callbacks?

[rameerez]

The most straightforward use case for a subscription is to have subscriber-only features, for which pay does all the heavy lifting of processing webhooks and creating objects, and just checking if the user is .subscribed? before any relevant actions is enough.

However, some other use cases require additional logic, like doing some initial setup (for example, giving users access to external resources), monthly fulfillments (like topping up credits), and removing access to resources when the subscription is cancelled.

I initially thought of doing this by adding custom webhook listeners as described in the docs, but I also came across this other idea of adding model concerns to Pay::Subscription and/or Pay::Charge, and then just adding ActiveRecord callbacks that implement this additional logic, like this:

# app/pay/pay_subscription_extension.rb

module PaySubscriptionExtension
  extend ActiveSupport::Concern

  included do
    after_commit :cleanup_subscription, on: :update, if: -> { saved_change_to_status? && !active? }
  end
  
  def cleanup_subscription
    # Subscription cleanup logic
  end
end

With the corresponding configuration in pay.rb:

# config/initializers/pay.rb

Rails.configuration.to_prepare do
  Pay::Subscription.include PaySubscriptionExtension
end

The ActiveRecord callbacks solution looks somewhat cleaner, since it's a processor-agnostic solution and I'm not dealing with or unnecesarily exposing Stripe-specific event names etc. The setup / refill / cleanup gets done only when the ActiveRecord object is created / changes status, and I don't care what specific events get sent to my endpoint.

What's the best practice here? Is there any reason to choose one approach over the other?

[nachoal]

What did you end up doing here @rameerez ? It's the first time that I'm implementing this gem and the docs are pretty abstract about this, specially with the following.

Fulfilling orders after Checkout completed
For one-time payments, you'll need to add a webhook listener for the Checkout stripe.checkout.session.completed and stripe.checkout.session.async_payment_succeeded events. Some payment methods are delayed so you need to verify the payment_status == "paid". The async payment succeeded event fires when delayed payments are complete.

For subscriptions, Pay will automatically create the Pay::Subscription record for you.

It seems that we have 2 approaches:

The webhook listener and the Model one mentioned here

[excid3]

I've settled on always handling it in model callbacks for everything. Then it doesn't matter if webhooks are enabled or not (which can be handy during development).

[nachoal]

Thanks for answering @excid3, I'll implement something similar 🙏