pay 7.3.0 → 11.2.2

data/{lib → app/models}/pay/paddle_classic/subscription.rb

@@ -1,26 +1,8 @@
 module Pay
   module PaddleClassic
-    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
+    class Subscription < Pay::Subscription
+      store_accessor :data, :paddle_update_url
+      store_accessor :data, :paddle_cancel_url
 
       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
@@ -68,11 +50,7 @@ module Pay
         end
       end
 
-      def initialize(pay_subscription)
-        @pay_subscription = pay_subscription
-      end
-
-      def subscription(**options)
+      def api_record(**options)
         PaddleClassic.client.users.list(subscription_id: processor_id).data.try(:first)
       rescue ::Paddle::Error => e
         raise Pay::PaddleClassic::Error, e
@@ -87,17 +65,17 @@ module Pay
         elsif paused?
           pause_starts_at
         else
-          Time.parse(processor_subscription.next_payment.date)
+          Time.parse(api_record.next_payment.date)
         end
 
         PaddleClassic.client.users.cancel(subscription_id: processor_id)
-        pay_subscription.update(
+        update(
           status: (ends_at.future? ? :active : :canceled),
           ends_at: ends_at
         )
 
         # Remove payment methods since customer cannot be reused after cancelling
-        Pay::PaymentMethod.where(customer_id: pay_subscription.customer_id).destroy_all
+        Pay::PaymentMethod.where(customer_id: customer_id).destroy_all
       rescue ::Paddle::Error => e
         raise Pay::PaddleClassic::Error, e
       end
@@ -106,10 +84,10 @@ module Pay
         return if canceled?
 
         PaddleClassic.client.users.cancel(subscription_id: processor_id)
-        pay_subscription.update(status: :canceled, ends_at: Time.current)
+        update(status: :canceled, ends_at: Time.current)
 
         # Remove payment methods since customer cannot be reused after cancelling
-        Pay::PaymentMethod.where(customer_id: pay_subscription.customer_id).destroy_all
+        Pay::PaymentMethod.where(customer_id: customer_id).destroy_all
       rescue ::Paddle::Error => e
         raise Pay::PaddleClassic::Error, e
       end
@@ -125,12 +103,12 @@ module Pay
       end
 
       def paused?
-        pay_subscription.status == "paused"
+        status == "paused"
       end
 
       def pause
         response = PaddleClassic.client.users.pause(subscription_id: processor_id)
-        pay_subscription.update(status: :paused, pause_starts_at: Time.zone.parse(response.dig(:next_payment, :date)))
+        update(status: :paused, pause_starts_at: Time.zone.parse(response.dig(:next_payment, :date)))
       rescue ::Paddle::Error => e
         raise Pay::PaddleClassic::Error, e
       end
@@ -141,11 +119,11 @@ module Pay
 
       def resume
         unless resumable?
-          raise StandardError, "You can only resume paused subscriptions."
+          raise Error, "You can only resume paused subscriptions."
         end
 
         PaddleClassic.client.users.unpause(subscription_id: processor_id)
-        pay_subscription.update(status: :active, pause_starts_at: nil)
+        update(ends_at: nil, status: :active, pause_starts_at: nil)
       rescue ::Paddle::Error => e
         raise Pay::PaddleClassic::Error, e
       end
@@ -153,11 +131,11 @@ module Pay
       def swap(plan, **options)
         raise ArgumentError, "plan must be a string" unless plan.is_a?(String)
 
-        attributes = {plan_id: plan, prorate: prorate}
+        attributes = {plan_id: plan, prorate: options.fetch(:prorate) { true }}
         attributes[:quantity] = quantity if quantity?
         PaddleClassic.client.users.update(subscription_id: processor_id, **attributes)
 
-        pay_subscription.update(processor_plan: plan, ends_at: nil, status: :active)
+        update(processor_plan: plan, ends_at: nil, status: :active)
       rescue ::Paddle::Error => e
         raise Pay::PaddleClassic::Error, e
       end
@@ -168,3 +146,5 @@ module Pay
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_paddle_classic_subscription, Pay::PaddleClassic::Subscription

data/app/models/pay/payment_method.rb

@@ -1,9 +1,9 @@
 module Pay
   class PaymentMethod < Pay::ApplicationRecord
-    self.inheritance_column = nil
-
     belongs_to :customer
 
+    delegate :owner, to: :customer
+
     store_accessor :data, :brand # Visa, Mastercard, Discover, PayPal
     store_accessor :data, :last4
     store_accessor :data, :exp_month
@@ -12,9 +12,6 @@ module Pay
     store_accessor :data, :username
     store_accessor :data, :bank
 
-    # Aliases to share PaymentMethodAttributes
-    alias_attribute :payment_method_type, :type
-
     validates :processor_id, presence: true, uniqueness: {scope: :customer_id, case_sensitive: true}
 
     def self.find_by_processor_and_id(processor, processor_id)
@@ -39,3 +36,5 @@ module Pay
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_payment_method, Pay::PaymentMethod

data/app/models/pay/stripe/charge.rb

@@ -0,0 +1,155 @@
+module Pay
+  module Stripe
+    class Charge < Pay::Charge
+      EXPAND = ["balance_transaction", "payment_intent", "refunds.data.balance_transaction"]
+
+      delegate :amount_captured, :payment_intent, to: :stripe_object, allow_nil: true
+
+      store_accessor :data, :stripe_invoice
+      store_accessor :data, :stripe_receipt_url
+
+      def self.sync_payment_intent(id, stripe_account: nil)
+        payment_intent = ::Stripe::PaymentIntent.retrieve({id: id}, {stripe_account: stripe_account}.compact)
+        sync(payment_intent.latest_charge, stripe_account: stripe_account)
+      end
+
+      def self.sync(charge_id, object: nil, stripe_account: nil, try: 0, retries: 1)
+        # Skip loading the latest charge details from the API if we already have it
+        object ||= ::Stripe::Charge.retrieve({id: charge_id, expand: EXPAND}, {stripe_account: stripe_account}.compact)
+        if object.customer.blank?
+          Rails.logger.debug "Stripe Charge #{object.id} does not have a customer"
+          return
+        end
+
+        pay_customer = Pay::Customer.find_by(processor: :stripe, processor_id: object.customer)
+        if pay_customer.blank?
+          Rails.logger.debug "Pay::Customer #{object.customer} is not in the database while syncing Stripe Charge #{object.id}"
+          return
+        end
+
+        payment_method = object.payment_method_details.try(object.payment_method_details.type)
+        attrs = {
+          object: object.to_hash,
+          amount: object.amount,
+          amount_refunded: object.amount_refunded,
+          application_fee_amount: object.application_fee_amount,
+          bank: payment_method.try(:bank_name) || payment_method.try(:bank), # eps, fpx, ideal, p24, acss_debit, etc
+          brand: payment_method.try(:brand)&.capitalize,
+          created_at: Time.at(object.created),
+          currency: object.currency,
+          exp_month: payment_method.try(:exp_month).to_s,
+          exp_year: payment_method.try(:exp_year).to_s,
+          last4: payment_method.try(:last4).to_s,
+          metadata: object.metadata,
+          payment_method_type: object.payment_method_details.type,
+          stripe_account: pay_customer.stripe_account,
+          stripe_receipt_url: object.receipt_url
+        }
+
+        # Associate charge with subscription if we can
+        if object.payment_intent.present?
+          invoice_payments = ::Stripe::InvoicePayment.list({payment: {type: :payment_intent, payment_intent: object.payment_intent}, status: :paid, expand: ["data.invoice.total_discount_amounts.discount"]}, {stripe_account: stripe_account}.compact)
+          if invoice_payments.any? && (invoice = invoice_payments.first.invoice)
+            attrs[:stripe_invoice] = invoice.to_hash
+            attrs[:subtotal] = invoice.subtotal
+            attrs[:tax] = invoice.total - invoice.total_excluding_tax.to_i
+            if (subscription = invoice.parent.try(:subscription_details).try(:subscription))
+              attrs[:subscription] = pay_customer.subscriptions.find_by(processor_id: subscription)
+            end
+          end
+        end
+
+        # Update or create the charge
+        if (pay_charge = find_by(customer: pay_customer, processor_id: object.id))
+          pay_charge.with_lock { pay_charge.update!(attrs) }
+          pay_charge
+        else
+          create!(attrs.merge(customer: pay_customer, processor_id: object.id))
+        end
+      rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotUnique
+        if try > retries
+          raise
+        else
+          try += 1
+          sleep 0.15**try
+          retry
+        end
+      end
+
+      def api_record
+        ::Stripe::Charge.retrieve({id: processor_id, expand: EXPAND}, stripe_options)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
+      end
+
+      # Issues a CreditNote if there's an invoice, otherwise uses a Refund
+      # This allows Tax to be handled properly
+      #
+      # https://stripe.com/docs/api/credit_notes/create
+      # https://stripe.com/docs/api/refunds/create
+      #
+      # refund!
+      # refund!(5_00)
+      # refund!(5_00, refund_application_fee: true)
+      def refund!(amount_to_refund = nil, **options)
+        amount_to_refund ||= amount
+
+        if stripe_invoice.present?
+          description = options.delete(:description) || I18n.t("pay.refund")
+          lines = [{type: :custom_line_item, description: description, quantity: 1, unit_amount: amount_to_refund}]
+          credit_note!(**options.merge(refund_amount: amount_to_refund, lines: lines))
+        else
+          ::Stripe::Refund.create(options.merge(charge: processor_id, amount: amount_to_refund), stripe_options)
+        end
+        update!(amount_refunded: amount_refunded + amount_to_refund)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
+      end
+
+      # Adds a credit note to a Stripe Invoice
+      def credit_note!(**options)
+        raise Pay::Stripe::Error, "no Stripe Invoice on Pay::Charge" if stripe_invoice.blank?
+
+        ::Stripe::CreditNote.create({invoice: stripe_invoice.id}.merge(options), stripe_options)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
+      end
+
+      # https://stripe.com/docs/payments/capture-later
+      #
+      # capture
+      # capture(amount_to_capture: 15_00)
+      def capture(**options)
+        raise Pay::Stripe::Error, "no payment_intent on charge" unless payment_intent.present?
+        payment_intent_id = payment_intent.is_a?(::Stripe::PaymentIntent) ? payment_intent.id : payment_intent
+        ::Stripe::PaymentIntent.capture(payment_intent_id, options, stripe_options)
+        self.class.sync(processor_id)
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
+      end
+
+      def captured?
+        amount_captured > 0
+      end
+
+      def stripe_invoice
+        if (value = data.dig("stripe_invoice"))
+          ::Stripe::Invoice.construct_from(value)
+        end
+      end
+
+      def stripe_object
+        ::Stripe::Charge.construct_from(object) if object?
+      end
+
+      private
+
+      # Options for Stripe requests
+      def stripe_options
+        {stripe_account: stripe_account}.compact
+      end
+    end
+  end
+end
+
+ActiveSupport.run_load_hooks :pay_stripe_charge, Pay::Stripe::Charge

data/{lib/pay/stripe/billable.rb → app/models/pay/stripe/customer.rb}

@@ -1,36 +1,20 @@
 module Pay
   module Stripe
-    class Billable
-      include Rails.application.routes.url_helpers
-
-      attr_reader :pay_customer
-
-      delegate :processor_id,
-        :processor_id?,
-        :email,
-        :customer_name,
-        :payment_method_token,
-        :payment_method_token?,
-        :stripe_account,
-        to: :pay_customer
-
-      def self.default_url_options
-        Rails.application.config.action_mailer.default_url_options || {}
-      end
+    class Customer < Pay::Customer
+      include Pay::Routing
 
-      def initialize(pay_customer)
-        @pay_customer = pay_customer
-      end
+      has_many :charges, dependent: :destroy, class_name: "Pay::Stripe::Charge"
+      has_many :subscriptions, dependent: :destroy, class_name: "Pay::Stripe::Subscription"
+      has_many :payment_methods, dependent: :destroy, class_name: "Pay::Stripe::PaymentMethod"
+      has_one :default_payment_method, -> { where(default: true) }, class_name: "Pay::Stripe::PaymentMethod"
 
       # Returns a hash of attributes for the Stripe::Customer object
-      def customer_attributes
-        owner = pay_customer.owner
-
+      def api_record_attributes
         attributes = case owner.class.pay_stripe_customer_attributes
         when Symbol
-          owner.send(owner.class.pay_stripe_customer_attributes, pay_customer)
+          owner.send(owner.class.pay_stripe_customer_attributes, self)
         when Proc
-          owner.class.pay_stripe_customer_attributes.call(pay_customer)
+          owner.class.pay_stripe_customer_attributes.call(self)
         end
 
         # Guard against attributes being returned nil
@@ -39,55 +23,30 @@ module Pay
         {email: email, name: customer_name}.merge(attributes)
       end
 
-      # Retrieves a Stripe::Customer object
-      #
-      # Finds an existing Stripe::Customer if processor_id exists
-      # Creates a new Stripe::Customer using `customer_attributes` if empty processor_id
-      #
-      # Updates the default payment method automatically if a payment_method_token is set
-      #
-      # Returns a Stripe::Customer object
-      def customer
-        stripe_customer = if processor_id?
-          ::Stripe::Customer.retrieve({id: processor_id, expand: ["tax", "invoice_credit_balance"]}, stripe_options)
-        else
-          sc = ::Stripe::Customer.create(customer_attributes.merge(expand: ["tax"]), stripe_options)
-          pay_customer.update!(processor_id: sc.id, stripe_account: stripe_account)
-          sc
-        end
-
-        if payment_method_token?
-          add_payment_method(payment_method_token, default: true)
-          pay_customer.payment_method_token = nil
+      def api_record(expand: ["tax", "invoice_credit_balance"])
+        with_lock do
+          if processor_id?
+            ::Stripe::Customer.retrieve({id: processor_id, expand: expand}, stripe_options)
+          else
+            ::Stripe::Customer.create(api_record_attributes.merge(expand: expand), stripe_options).tap do |customer|
+              update!(processor_id: customer.id, stripe_account: stripe_account)
+            end
+          end
         end
-
-        stripe_customer
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
-      # Syncs name and email to Stripe::Customer
-      # You can also pass in other attributes that will be merged into the default attributes
-      def update_customer!(**attributes)
-        customer unless processor_id?
-        ::Stripe::Customer.update(
-          processor_id,
-          customer_attributes.merge(attributes),
-          stripe_options
-        )
+      def update_api_record(**attributes)
+        api_record unless processor_id?
+        ::Stripe::Customer.update(processor_id, api_record_attributes.merge(attributes), stripe_options)
       end
 
       # Charges an amount to the customer's default payment method
       def charge(amount, options = {})
-        add_payment_method(payment_method_token, default: true) if payment_method_token?
-
-        payment_method = pay_customer.default_payment_method
-        args = {
-          confirm: true,
-          payment_method: payment_method&.processor_id
-        }.merge(options)
-
+        args = {confirm: true, payment_method: default_payment_method&.processor_id}.merge(options)
         payment_intent = create_payment_intent(amount, args)
+
         Pay::Payment.new(payment_intent).validate
 
         charge = payment_intent.latest_charge
@@ -96,33 +55,14 @@ module Pay
         raise Pay::Stripe::Error, e
       end
 
-      # Creates and returns a Stripe::PaymentIntent
-      def create_payment_intent(amount, options = {})
-        args = {
-          amount: amount,
-          currency: "usd",
-          customer: processor_id,
-          expand: ["latest_charge.refunds"],
-          return_url: root_url
-        }.merge(options)
-
-        ::Stripe::PaymentIntent.create(args, stripe_options)
-      end
-
-      # Used for creating Stripe Terminal charges
-      def terminal_charge(amount, options = {})
-        create_payment_intent(amount, options.merge(payment_method_types: ["card_present"], capture_method: "manual"))
-      end
-
       def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
         quantity = options.delete(:quantity)
         opts = {
-          expand: ["pending_setup_intent", "latest_invoice.payment_intent", "latest_invoice.charge"],
-          items: [plan: plan, quantity: quantity]
+          items: [price: plan, quantity: quantity]
         }.merge(options)
 
         # Load the Stripe customer to verify it exists and update payment method if needed
-        opts[:customer] = customer.id
+        opts[:customer] = processor_id || api_record.id
 
         # Create subscription on Stripe
         stripe_sub = ::Stripe::Subscription.create(opts.merge(Pay::Stripe::Subscription.expand_options), stripe_options)
@@ -132,7 +72,8 @@ module Pay
 
         # No trial, payment method requires SCA
         if options[:payment_behavior].to_s != "default_incomplete" && subscription.incomplete?
-          Pay::Payment.new(stripe_sub.latest_invoice.payment_intent).validate
+          payment_intent_id = stripe_sub.latest_invoice.payments.first.payment.payment_intent
+          Pay::Payment.from_id(payment_intent_id).validate
         end
 
         subscription
@@ -141,7 +82,7 @@ module Pay
       end
 
       def add_payment_method(payment_method_id, default: false)
-        customer unless processor_id?
+        api_record unless processor_id?
         payment_method = ::Stripe::PaymentMethod.attach(payment_method_id, {customer: processor_id}, stripe_options)
 
         if default
@@ -159,50 +100,56 @@ module Pay
 
       # Save the Stripe::PaymentMethod to the database
       def save_payment_method(payment_method, default:)
-        pay_payment_method = pay_customer.payment_methods.where(processor_id: payment_method.id).first_or_initialize
+        pay_payment_method = payment_methods.where(processor_id: payment_method.id).first_or_initialize
 
         attributes = Pay::Stripe::PaymentMethod.extract_attributes(payment_method).merge(default: default)
 
         # Ignore the payment method if it's already in the database
-        pay_customer.payment_methods.where.not(id: pay_payment_method.id).update_all(default: false) if default
+        payment_methods.where.not(id: pay_payment_method.id).update_all(default: false) if default
         pay_payment_method.update!(attributes)
 
         # Reload the Rails association
-        pay_customer.reload_default_payment_method
+        reload_default_payment_method
 
         pay_payment_method
       end
 
-      def processor_subscription(subscription_id, options = {})
-        ::Stripe::Subscription.retrieve(options.merge(id: subscription_id), stripe_options)
-      end
+      ### Stripe extras
 
-      def invoice!(options = {})
-        return unless processor_id?
-        ::Stripe::Invoice.create(options.merge(customer: processor_id), stripe_options).pay
+      # Creates and returns a Stripe::PaymentIntent
+      def create_payment_intent(amount, options = {})
+        args = {
+          amount: amount,
+          currency: "usd",
+          customer: processor_id || api_record.id,
+          expand: Pay::Stripe::Charge::EXPAND.map { |option| "latest_charge.#{option}" },
+          return_url: root_url
+        }.merge(options)
+
+        ::Stripe::PaymentIntent.create(args, stripe_options)
       end
 
-      def upcoming_invoice
-        ::Stripe::Invoice.upcoming({customer: processor_id}, stripe_options)
+      # Used for creating Stripe Terminal charges
+      def terminal_charge(amount, options = {})
+        create_payment_intent(amount, options.merge(payment_method_types: ["card_present"], capture_method: "manual"))
       end
 
       def create_setup_intent(options = {})
-        customer unless processor_id?
-        ::Stripe::SetupIntent.create({
-          customer: processor_id,
-          usage: :off_session
-        }.merge(options), stripe_options)
+        ::Stripe::SetupIntent.create({customer: processor_id || api_record.id, usage: :off_session}.merge(options), stripe_options)
+      end
+
+      def invoice!(options = {})
+        ::Stripe::Invoice.create(options.merge(customer: processor_id || api_record.id), stripe_options).pay
       end
 
-      def trial_end_date(stripe_sub)
-        # Times in Stripe are returned in UTC
-        stripe_sub.trial_end.present? ? Time.at(stripe_sub.trial_end) : nil
+      def preview_invoice(**options)
+        ::Stripe::Invoice.create_preview(options.merge(customer: processor_id || api_record.id), stripe_options)
       end
 
       # Syncs a customer's subscriptions from Stripe to the database.
       # Note that by default canceled subscriptions are NOT returned by Stripe. In order to include them, use `sync_subscriptions(status: "all")`.
       def sync_subscriptions(**options)
-        subscriptions = ::Stripe::Subscription.list(options.merge(customer: customer), stripe_options)
+        subscriptions = ::Stripe::Subscription.list(options.with_defaults(customer: processor_id), stripe_options)
         subscriptions.map do |subscription|
           Pay::Stripe::Subscription.sync(subscription.id)
         end
@@ -221,7 +168,7 @@ module Pay
       # checkout(line_items: "price_12345", allow_promotion_codes: true)
       #
       def checkout(**options)
-        customer unless processor_id?
+        api_record unless processor_id?
         args = {
           customer: processor_id,
           mode: "payment"
@@ -261,7 +208,7 @@ module Pay
       # checkout_charge(amount: 15_00, name: "T-shirt", quantity: 2)
       #
       def checkout_charge(amount:, name:, quantity: 1, **options)
-        customer unless processor_id?
+        api_record unless processor_id?
         currency = options.delete(:currency) || "usd"
         checkout(
           line_items: {
@@ -277,7 +224,7 @@ module Pay
       end
 
       def billing_portal(**options)
-        customer unless processor_id?
+        api_record unless processor_id?
         args = {
           customer: processor_id,
           return_url: options.delete(:return_url) || root_url
@@ -285,10 +232,28 @@ module Pay
         ::Stripe::BillingPortal::Session.create(args.merge(options), stripe_options)
       end
 
+      def customer_session(**options)
+        api_record unless processor_id?
+        args = {customer: processor_id}
+        ::Stripe::CustomerSession.create(args.merge(options), stripe_options)
+      end
+
       def authorize(amount, options = {})
         charge(amount, options.merge(capture_method: :manual))
       end
 
+      # Creates a meter event to bill for usage
+      #
+      # create_meter_event(:api_request, value: 1)
+      # create_meter_event(:api_request, token: 7)
+      def create_meter_event(event_name, payload: {}, **options)
+        api_record unless processor_id?
+        ::Stripe::Billing::MeterEvent.create({
+          event_name: event_name,
+          payload: {stripe_customer_id: processor_id}.merge(payload)
+        }.merge(options))
+      end
+
       private
 
       # Options for Stripe requests
@@ -299,9 +264,11 @@ module Pay
       # Includes the `session_id` param for Stripe Checkout with existing params (and makes sure the curly braces aren't escaped)
       def merge_session_id_param(url)
         uri = URI.parse(url)
-        uri.query = URI.encode_www_form(URI.decode_www_form(uri.query.to_s).to_h.merge("session_id" => "{CHECKOUT_SESSION_ID}").to_a)
+        uri.query = URI.encode_www_form(URI.decode_www_form(uri.query.to_s).to_h.merge("stripe_checkout_session_id" => "{CHECKOUT_SESSION_ID}").to_a)
         uri.to_s.gsub("%7BCHECKOUT_SESSION_ID%7D", "{CHECKOUT_SESSION_ID}")
       end
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_stripe_customer, Pay::Stripe::Customer

data/{lib → app/models}/pay/stripe/merchant.rb

@@ -1,26 +1,9 @@
 module Pay
   module Stripe
-    class Merchant
-      attr_reader :pay_merchant
-
-      delegate :processor_id,
-        to: :pay_merchant
-
-      def initialize(pay_merchant)
-        @pay_merchant = pay_merchant
-      end
-
+    class Merchant < Pay::Merchant
       def create_account(**options)
-        defaults = {
-          type: "express",
-          capabilities: {
-            card_payments: {requested: true},
-            transfers: {requested: true}
-          }
-        }
-
-        stripe_account = ::Stripe::Account.create(defaults.merge(options))
-        pay_merchant.update(processor_id: stripe_account.id)
+        stripe_account = ::Stripe::Account.create(options)
+        update(processor_id: stripe_account.id)
         stripe_account
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
@@ -64,3 +47,5 @@ module Pay
     end
   end
 end
+
+ActiveSupport.run_load_hooks :pay_stripe_merchant, Pay::Stripe::Merchant