pay 2.7.1 → 3.0.2

data/lib/pay/paddle/payment_method.rb

@@ -0,0 +1,60 @@
+module Pay
+  module Paddle
+    class PaymentMethod
+      attr_reader :pay_payment_method
+
+      delegate :customer, :processor_id, to: :pay_payment_method
+
+      # Paddle doesn't provide PaymentMethod IDs, so we have to lookup via the Customer
+      def self.sync(pay_customer:, attributes: nil)
+        return unless pay_customer.subscription
+
+        payment_method = pay_customer.default_payment_method || pay_customer.build_default_payment_method
+        payment_method.processor_id ||= NanoId.generate
+
+        # Lookup payment method from API unless passed in
+        attributes ||= payment_method_details_for(subscription_id: pay_customer.subscription.processor_id)
+
+        payment_method.update!(attributes)
+        payment_method
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Pay::Paddle::Error, e
+      end
+
+      def self.payment_method_details_for(subscription_id:)
+        subscription_user = PaddlePay::Subscription::User.list({subscription_id: subscription_id}).try(:first)
+        payment_information = subscription_user ? subscription_user[:payment_information] : {}
+
+        case payment_information[:payment_method]
+        when "card"
+          {
+            payment_method_type: :card,
+            brand: payment_information[:card_type],
+            last4: payment_information[:last_four_digits],
+            exp_month: payment_information[:expiry_date].split("/").first,
+            exp_year: payment_information[:expiry_date].split("/").last
+          }
+        when "paypal"
+          {
+            payment_method_type: :paypal,
+            brand: "PayPal"
+          }
+        else
+          {}
+        end
+      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/paddle/subscription.rb

@@ -20,6 +20,49 @@ module Pay
         :trial_ends_at,
         to: :pay_subscription
 
+      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 ||= OpenStruct.new PaddlePay::Subscription::User.list({subscription_id: subscription_id}).try(:first)
+
+        pay_customer = Pay::Customer.find_by(processor: :paddle, processor_id: object.user_id)
+
+        # If passthrough exists (only on webhooks) we can use it to create the Pay::Customer
+        if pay_customer.nil? && object.passthrough
+          owner = Pay::Paddle.owner_from_passthrough(object.passthrough)
+          pay_customer = owner&.set_payment_processor(:paddle, processor_id: object.user_id)
+        end
+
+        return unless pay_customer
+
+        attributes = {
+          paddle_cancel_url: object.cancel_url,
+          paddle_update_url: object.update_url,
+          processor_plan: object.plan_id || object.subscription_plan_id,
+          quantity: object.quantity,
+          status: object.state || object.status
+        }
+
+        # If paused or delete while on trial, set ends_at to match
+        case attributes[:status]
+        when "trialing"
+          attributes[:trial_ends_at] = Time.zone.parse(object.next_bill_date)
+          attributes[:ends_at] = nil
+        when "paused", "deleted"
+          attributes[:trial_ends_at] = nil
+          attributes[:ends_at] = Time.zone.parse(object.next_bill_date)
+        end
+
+        # Update or create the subscription
+        if (pay_subscription = pay_customer.subscriptions.find_by(processor_id: object.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: object.subscription_id))
+        end
+      end
+
       def initialize(pay_subscription)
         @pay_subscription = pay_subscription
       end
@@ -32,26 +75,22 @@ module Pay
       end
 
       def cancel
-        subscription = processor_subscription
+        ends_at = on_trial? ? trial_ends_at : processor_subscription.next_payment[:date]
         PaddlePay::Subscription::User.cancel(processor_id)
-        if on_trial?
-          pay_subscription.update(status: :canceled, ends_at: trial_ends_at)
-        else
-          pay_subscription.update(status: :canceled, ends_at: Time.zone.parse(subscription.next_payment[:date]))
-        end
+        pay_subscription.update(status: :canceled, ends_at: ends_at)
       rescue ::PaddlePay::PaddlePayError => e
         raise Pay::Paddle::Error, e
       end
 
       def cancel_now!
         PaddlePay::Subscription::User.cancel(processor_id)
-        pay_subscription.update(status: :canceled, ends_at: Time.zone.now)
+        pay_subscription.update(status: :canceled, ends_at: Time.current)
       rescue ::PaddlePay::PaddlePayError => e
         raise Pay::Paddle::Error, e
       end
 
       def on_grace_period?
-        canceled? && Time.zone.now < ends_at || paused? && Time.zone.now < paddle_paused_from
+        canceled? && Time.current < ends_at || paused? && Time.current < paddle_paused_from
       end
 
       def paused?
@@ -79,6 +118,8 @@ module Pay
       end
 
       def swap(plan)
+        raise ArgumentError, "plan must be a string" unless plan.is_a?(String)
+
         attributes = {plan_id: plan, prorate: prorate}
         attributes[:quantity] = quantity if quantity?
         PaddlePay::Subscription::User.update(processor_id, attributes)

data/lib/pay/paddle/webhooks/subscription_cancelled.rb

@@ -3,14 +3,17 @@ module Pay
     module Webhooks
       class SubscriptionCancelled
         def call(event)
-          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: event["subscription_id"])
+          pay_subscription = Pay::Subscription.find_by_processor_and_id(:paddle, event.subscription_id)
 
           # We couldn't find the subscription for some reason, maybe it's from another service
-          return if subscription.nil?
+          return if pay_subscription.nil?
 
           # User canceled subscriptions have an ends_at
           # Automatically canceled subscriptions need this value set
-          subscription.update!(ends_at: Time.zone.parse(event["cancellation_effective_date"])) if subscription.ends_at.blank? && event["cancellation_effective_date"].present?
+          pay_subscription.update!(ends_at: Time.zone.parse(event.cancellation_effective_date)) if pay_subscription.ends_at.blank? && event.cancellation_effective_date.present?
+
+          # Paddle doesn't allow reusing customers, so we should remove their payment methods
+          pay_subscription.customer.payment_methods.destroy_all
         end
       end
     end

data/lib/pay/paddle/webhooks/subscription_created.rb

@@ -3,46 +3,7 @@ module Pay
     module Webhooks
       class SubscriptionCreated
         def call(event)
-          # We may already have the subscription in the database, so we can update that record
-          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: event["subscription_id"])
-
-          # Create the subscription in the database if we don't have it already
-          if subscription.nil?
-
-            # The customer could already be in the database
-            owner = Pay.find_billable(processor: :paddle, processor_id: event["user_id"])
-
-            if owner.nil?
-              owner = Pay::Paddle.owner_from_passthrough(event["passthrough"])
-              owner&.update!(processor: "paddle", processor_id: event["user_id"])
-            end
-
-            if owner.nil?
-              Rails.logger.error("[Pay] Unable to find Pay::Billable with owner: '#{event["passthrough"]}'. Searched these models: #{Pay.billable_models.join(", ")}")
-              return
-            end
-
-            subscription = Pay.subscription_model.new(owner: owner, name: Pay.default_product_name, processor: "paddle", processor_id: event["subscription_id"], status: :active)
-          end
-
-          subscription.quantity = event["quantity"]
-          subscription.processor_plan = event["subscription_plan_id"]
-          subscription.paddle_update_url = event["update_url"]
-          subscription.paddle_cancel_url = event["cancel_url"]
-          subscription.trial_ends_at = Time.zone.parse(event["next_bill_date"]) if event["status"] == "trialing"
-
-          # If user was on trial, their subscription ends at the end of the trial
-          subscription.ends_at = if ["paused", "deleted"].include?(event["status"]) && subscription.on_trial?
-            subscription.trial_ends_at
-
-          # User wasn't on trial, so subscription ends at period end
-          elsif ["paused", "deleted"].include?(event["status"])
-            Time.zone.parse(event["next_bill_date"])
-
-            # Subscription isn't marked to cancel at period end
-          end
-
-          subscription.save!
+          Pay::Paddle::Subscription.sync(event.subscription_id, object: event)
         end
       end
     end

data/lib/pay/paddle/webhooks/subscription_payment_refunded.rb

@@ -3,11 +3,11 @@ module Pay
     module Webhooks
       class SubscriptionPaymentRefunded
         def call(event)
-          charge = Pay.charge_model.find_by(processor: :paddle, processor_id: event["subscription_payment_id"])
+          charge = Pay::Charge.find_by_processor_and_id(:paddle, event.subscription_payment_id)
           return unless charge.present?
 
-          charge.update(amount_refunded: Integer(event["gross_refund"].to_f * 100))
-          notify_user(charge.owner, charge)
+          charge.update(amount_refunded: (event.gross_refund.to_f * 100).to_i)
+          notify_user(charge.customer.owner, charge)
         end
 
         def notify_user(billable, charge)

data/lib/pay/paddle/webhooks/subscription_payment_succeeded.rb

@@ -3,43 +3,41 @@ module Pay
     module Webhooks
       class SubscriptionPaymentSucceeded
         def call(event)
-          billable = Pay.find_billable(processor: :paddle, processor_id: event["user_id"])
+          pay_customer = Pay::Customer.find_by(processor: :paddle, processor_id: event.user_id)
 
-          if billable.nil?
-            billable = Pay::Paddle.owner_from_passthrough(event["passthrough"])
-            billable&.update!(processor: "paddle", processor_id: event["user_id"])
+          if pay_customer.nil?
+            owner = Pay::Paddle.owner_from_passthrough(event.passthrough)
+            pay_customer = owner&.set_payment_processor :paddle, processor_id: event.user_id
           end
 
-          if billable.nil?
-            Rails.logger.error("[Pay] Unable to find Pay::Billable with owner: '#{event["passthrough"]}'. Searched these models: #{Pay.billable_models.join(", ")}")
+          if pay_customer.nil?
+            Rails.logger.error("[Pay] Unable to find Pay::Customer with: '#{event.passthrough}'")
             return
           end
 
-          return if billable.charges.where(processor_id: event["subscription_payment_id"]).any?
+          return if pay_customer.charges.where(processor_id: event.subscription_payment_id).any?
 
-          charge = create_charge(billable, event)
-          notify_user(billable, charge)
+          charge = create_charge(pay_customer, event)
+          notify_user(pay_customer.owner, charge)
         end
 
-        def create_charge(user, event)
-          charge = user.charges.find_or_initialize_by(
-            processor: :paddle,
-            processor_id: event["subscription_payment_id"]
-          )
-
-          params = {
-            amount: Integer(event["sale_gross"].to_f * 100),
-            card_type: event["payment_method"],
-            created_at: Time.zone.parse(event["event_time"]),
-            currency: event["currency"],
-            paddle_receipt_url: event["receipt_url"],
-            subscription: Pay::Subscription.find_by(processor: :paddle, processor_id: event["subscription_id"])
-          }
-
-          payment_information = Pay::Paddle::Billable.new(user).payment_information(event["subscription_id"])
-
-          charge.update(params.merge(payment_information))
-          user.update(payment_information)
+        def create_charge(pay_customer, event)
+          payment_method_details = Pay::Paddle::PaymentMethod.payment_method_details_for(subscription_id: event.subscription_id)
+
+          attributes = {
+            amount: (event.sale_gross.to_f * 100).to_i,
+            created_at: Time.zone.parse(event.event_time),
+            currency: event.currency,
+            paddle_receipt_url: event.receipt_url,
+            subscription: pay_customer.subscriptions.find_by(processor_id: event.subscription_id),
+            metadata: Pay::Paddle.parse_passthrough(event.passthrough).except("owner_sgid")
+          }.merge(payment_method_details)
+
+          charge = pay_customer.charges.find_or_initialize_by(processor_id: event.subscription_payment_id)
+          charge.update!(attributes)
+
+          # Update customer's payment method
+          Pay::Paddle::PaymentMethod.sync(pay_customer: pay_customer, attributes: payment_method_details)
 
           charge
         end

data/lib/pay/paddle/webhooks/subscription_updated.rb

@@ -3,14 +3,14 @@ module Pay
     module Webhooks
       class SubscriptionUpdated
         def call(event)
-          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: event["subscription_id"])
+          subscription = Pay::Subscription.find_by_processor_and_id(:paddle, event["subscription_id"])
 
           return if subscription.nil?
 
           case event["status"]
           when "deleted"
             subscription.status = "canceled"
-            subscription.ends_at = Time.zone.parse(event["next_bill_date"]) || Time.zone.now if subscription.ends_at.blank?
+            subscription.ends_at = Time.zone.parse(event["next_bill_date"]) || Time.current if subscription.ends_at.blank?
           when "trialing"
             subscription.status = "trialing"
             subscription.trial_ends_at = Time.zone.parse(event["next_bill_date"])

data/lib/pay/paddle.rb

@@ -2,8 +2,9 @@ module Pay
   module Paddle
     autoload :Billable, "pay/paddle/billable"
     autoload :Charge, "pay/paddle/charge"
-    autoload :Subscription, "pay/paddle/subscription"
     autoload :Error, "pay/paddle/error"
+    autoload :PaymentMethod, "pay/paddle/payment_method"
+    autoload :Subscription, "pay/paddle/subscription"
 
     module Webhooks
       autoload :SignatureVerifier, "pay/paddle/webhooks/signature_verifier"
@@ -44,9 +45,12 @@ module Pay
       options.merge(owner_sgid: owner.to_sgid.to_s).to_json
     end
 
+    def self.parse_passthrough(passthrough)
+      JSON.parse(passthrough)
+    end
+
     def self.owner_from_passthrough(passthrough)
-      passthrough_json = JSON.parse(passthrough)
-      GlobalID::Locator.locate_signed(passthrough_json["owner_sgid"])
+      GlobalID::Locator.locate_signed parse_passthrough(passthrough)["owner_sgid"]
     rescue JSON::ParserError
       nil
     end

data/lib/pay/payment.rb

@@ -2,7 +2,7 @@ module Pay
   class Payment
     attr_reader :intent
 
-    delegate :id, :amount, :client_secret, :status, :confirm, to: :intent
+    delegate :id, :amount, :client_secret, :customer, :status, :confirm, to: :intent
 
     def self.from_id(id)
       intent = id.start_with?("seti_") ? ::Stripe::SetupIntent.retrieve(id) : ::Stripe::PaymentIntent.retrieve(id)

data/lib/pay/receipts.rb

@@ -1,14 +1,14 @@
 module Pay
   module Receipts
-    def filename
-      "receipt-#{created_at.strftime("%Y-%m-%d")}.pdf"
-    end
-
     def product
       Pay.application_name
     end
 
-    # Must return a file object
+    def receipt_filename
+      "receipt-#{created_at.strftime("%Y-%m-%d")}.pdf"
+    end
+    alias_method :filename, :receipt_filename
+
     def receipt
       receipt_pdf.render
     end
@@ -26,15 +26,43 @@ module Pay
       )
     end
 
+    def invoice_filename
+      "invoice-#{created_at.strftime("%Y-%m-%d")}.pdf"
+    end
+
+    def invoice
+      invoice_pdf.render
+    end
+
+    def invoice_pdf
+      ::Receipts::Invoice.new(
+        id: id,
+        issue_date: created_at,
+        due_date: created_at,
+        status: "<b><color rgb='#5eba7d'>PAID</color></b>",
+        bill_to: [
+          customer.customer_name,
+          customer.email
+        ].compact,
+        product: product,
+        company: {
+          name: Pay.business_name,
+          address: Pay.business_address,
+          email: Pay.support_email
+        },
+        line_items: line_items
+      )
+    end
+
     def line_items
       line_items = [
         [I18n.t("receipt.date"), created_at.to_s],
-        [I18n.t("receipt.account_billed"), "#{owner.name} (#{owner.email})"],
+        [I18n.t("receipt.account_billed"), "#{customer.customer_name} (#{customer.email})"],
         [I18n.t("receipt.product"), product],
         [I18n.t("receipt.amount"), ActionController::Base.helpers.number_to_currency(amount / 100.0)],
         [I18n.t("receipt.charged_to"), charged_to]
       ]
-      line_items << [I18n.t("receipt.additional_info"), owner.extra_billing_info] if owner.extra_billing_info?
+      line_items << [I18n.t("receipt.additional_info"), customer.owner.extra_billing_info] if customer.owner.extra_billing_info?
       line_items
     end
   end

data/lib/pay/stripe/billable.rb

@@ -3,43 +3,40 @@ module Pay
     class Billable
       include Rails.application.routes.url_helpers
 
-      attr_reader :billable
+      attr_reader :pay_customer
 
       delegate :processor_id,
         :processor_id?,
         :email,
         :customer_name,
-        :card_token,
+        :payment_method_token,
+        :payment_method_token?,
         :stripe_account,
-        to: :billable
+        to: :pay_customer
 
-      class << self
-        def default_url_options
-          Rails.application.config.action_mailer.default_url_options || {}
-        end
+      def self.default_url_options
+        Rails.application.config.action_mailer.default_url_options || {}
       end
 
-      def initialize(billable)
-        @billable = billable
+      def initialize(pay_customer)
+        @pay_customer = pay_customer
       end
 
-      # Handles Billable#customer
-      #
-      # Returns Stripe::Customer
       def customer
         stripe_customer = if processor_id?
-          ::Stripe::Customer.retrieve(processor_id, {stripe_account: stripe_account})
+          ::Stripe::Customer.retrieve({id: processor_id}, stripe_options)
         else
-          sc = ::Stripe::Customer.create({email: email, name: customer_name}, {stripe_account: stripe_account})
-          billable.update(processor: :stripe, processor_id: sc.id, stripe_account: stripe_account)
+          sc = ::Stripe::Customer.create({email: email, name: customer_name}, stripe_options)
+          pay_customer.update!(processor_id: sc.id, stripe_account: stripe_account)
           sc
         end
 
-        # Update the user's card on file if a token was passed in
-        if card_token.present?
-          payment_method = ::Stripe::PaymentMethod.attach(card_token, {customer: stripe_customer.id}, {stripe_account: stripe_account})
-          stripe_customer = ::Stripe::Customer.update(stripe_customer.id, {invoice_settings: {default_payment_method: payment_method.id}}, {stripe_account: stripe_account})
-          update_card_on_file(payment_method.card)
+        if payment_method_token?
+          payment_method = ::Stripe::PaymentMethod.attach(payment_method_token, {customer: stripe_customer.id}, stripe_options)
+          pay_payment_method = save_payment_method(payment_method, default: false)
+          pay_payment_method.make_default!
+
+          pay_customer.payment_method_token = nil
         end
 
         stripe_customer
@@ -47,37 +44,32 @@ module Pay
         raise Pay::Stripe::Error, e
       end
 
-      # Handles Billable#charge
-      #
-      # Returns Pay::Charge
       def charge(amount, options = {})
-        stripe_customer = customer
+        add_payment_method(payment_method_token, default: true) if payment_method_token?
+
+        payment_method = pay_customer.default_payment_method
         args = {
           amount: amount,
           confirm: true,
           confirmation_method: :automatic,
           currency: "usd",
-          customer: stripe_customer.id,
-          payment_method: stripe_customer.invoice_settings.default_payment_method
+          customer: processor_id,
+          payment_method: payment_method&.processor_id
         }.merge(options)
 
-        payment_intent = ::Stripe::PaymentIntent.create(args, {stripe_account: stripe_account})
+        payment_intent = ::Stripe::PaymentIntent.create(args, stripe_options)
         Pay::Payment.new(payment_intent).validate
 
-        # Create a new charge object
         charge = payment_intent.charges.first
         Pay::Stripe::Charge.sync(charge.id, object: charge)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
-      # Handles Billable#subscribe
-      #
-      # Returns Pay::Subscription
       def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
         quantity = options.delete(:quantity) || 1
         opts = {
-          expand: ["pending_setup_intent", "latest_invoice.payment_intent"],
+          expand: ["pending_setup_intent", "latest_invoice.payment_intent", "latest_invoice.charge.invoice"],
           items: [plan: plan, quantity: quantity],
           off_session: true
         }.merge(options)
@@ -85,22 +77,18 @@ module Pay
         # Inherit trial from plan unless trial override was specified
         opts[:trial_from_plan] = true unless opts[:trial_period_days]
 
-        # Load the Stripe customer to verify it exists and update card if needed
+        # Load the Stripe customer to verify it exists and update payment method if needed
         opts[:customer] = customer.id
 
         # Create subscription on Stripe
-        stripe_sub = ::Stripe::Subscription.create(opts, {stripe_account: stripe_account})
+        stripe_sub = ::Stripe::Subscription.create(opts, stripe_options)
 
         # Save Pay::Subscription
         subscription = Pay::Stripe::Subscription.sync(stripe_sub.id, object: stripe_sub, name: name)
 
-        # No trial, card requires SCA
+        # No trial, payment method requires SCA
         if subscription.incomplete?
           Pay::Payment.new(stripe_sub.latest_invoice.payment_intent).validate
-
-        # Trial, card requires SCA
-        elsif subscription.on_trial? && stripe_sub.pending_setup_intent
-          Pay::Payment.new(stripe_sub.pending_setup_intent).validate
         end
 
         subscription
@@ -108,51 +96,57 @@ module Pay
         raise Pay::Stripe::Error, e
       end
 
-      # Handles Billable#update_card
-      #
-      # Returns true if successful
-      def update_card(payment_method_id)
-        stripe_customer = customer
-
-        return true if payment_method_id == stripe_customer.invoice_settings.default_payment_method
+      def add_payment_method(payment_method_id, default: false)
+        customer unless processor_id?
+        payment_method = ::Stripe::PaymentMethod.attach(payment_method_id, {customer: processor_id}, stripe_options)
 
-        payment_method = ::Stripe::PaymentMethod.attach(payment_method_id, {customer: stripe_customer.id}, {stripe_account: stripe_account})
-        ::Stripe::Customer.update(stripe_customer.id, {invoice_settings: {default_payment_method: payment_method.id}}, {stripe_account: stripe_account})
+        if default
+          ::Stripe::Customer.update(processor_id, {
+            invoice_settings: {
+              default_payment_method: payment_method.id
+            }
+          }, stripe_options)
+        end
 
-        update_card_on_file(payment_method.card)
-        true
+        save_payment_method(payment_method, default: default)
       rescue ::Stripe::StripeError => e
         raise Pay::Stripe::Error, e
       end
 
+      # 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
+
+        attributes = Pay::Stripe::PaymentMethod.extract_attributes(payment_method).merge(default: default)
+
+        pay_customer.payment_methods.update_all(default: false) if default
+        pay_payment_method.update!(attributes)
+
+        # Reload the Rails association
+        pay_customer.reload_default_payment_method if default
+
+        pay_payment_method
+      end
+
       def update_email!
-        ::Stripe::Customer.update(processor_id, {email: email, name: customer_name}, {stripe_account: stripe_account})
+        ::Stripe::Customer.update(processor_id, {email: email, name: customer_name}, stripe_options)
       end
 
       def processor_subscription(subscription_id, options = {})
-        ::Stripe::Subscription.retrieve(options.merge(id: subscription_id), {stripe_account: stripe_account})
+        ::Stripe::Subscription.retrieve(options.merge(id: subscription_id), stripe_options)
       end
 
       def invoice!(options = {})
         return unless processor_id?
-        ::Stripe::Invoice.create(options.merge(customer: processor_id), {stripe_account: stripe_account}).pay
+        ::Stripe::Invoice.create(options.merge(customer: processor_id), stripe_options).pay
       end
 
       def upcoming_invoice
-        ::Stripe::Invoice.upcoming({customer: processor_id}, {stripe_account: stripe_account})
-      end
-
-      # Used by webhooks when the customer or source changes
-      def sync_card_from_stripe
-        if (payment_method_id = customer.invoice_settings.default_payment_method)
-          update_card_on_file ::Stripe::PaymentMethod.retrieve(payment_method_id, {stripe_account: stripe_account}).card
-        else
-          billable.update(card_type: nil, card_last4: nil)
-        end
+        ::Stripe::Invoice.upcoming({customer: processor_id}, stripe_options)
       end
 
       def create_setup_intent
-        ::Stripe::SetupIntent.create({customer: processor_id, usage: :off_session}, {stripe_account: stripe_account})
+        ::Stripe::SetupIntent.create({customer: processor_id, usage: :off_session}, stripe_options)
       end
 
       def trial_end_date(stripe_sub)
@@ -160,16 +154,14 @@ module Pay
         stripe_sub.trial_end.present? ? Time.at(stripe_sub.trial_end) : nil
       end
 
-      # Save the card to the database as the user's current card
-      def update_card_on_file(card)
-        billable.update!(
-          card_type: card.brand.capitalize,
-          card_last4: card.last4,
-          card_exp_month: card.exp_month,
-          card_exp_year: card.exp_year
-        )
-
-        billable.card_token = nil
+      # Syncs a customer's subscriptions from Stripe to the database
+      def sync_subscriptions
+        subscriptions = ::Stripe::Subscription.list({customer: customer}, stripe_options)
+        subscriptions.map do |subscription|
+          Pay::Stripe::Subscription.sync(subscription.id)
+        end
+      rescue ::Stripe::StripeError => e
+        raise Pay::Stripe::Error, e
       end
 
       # https://stripe.com/docs/api/checkout/sessions/create
@@ -203,7 +195,7 @@ module Pay
           }
         end
 
-        ::Stripe::Checkout::Session.create(args.merge(options), {stripe_account: stripe_account})
+        ::Stripe::Checkout::Session.create(args.merge(options), stripe_options)
       end
 
       # https://stripe.com/docs/api/checkout/sessions/create
@@ -230,7 +222,14 @@ module Pay
           customer: processor_id,
           return_url: options.delete(:return_url) || root_url
         }
-        ::Stripe::BillingPortal::Session.create(args.merge(options), {stripe_account: stripe_account})
+        ::Stripe::BillingPortal::Session.create(args.merge(options), stripe_options)
+      end
+
+      private
+
+      # Options for Stripe requests
+      def stripe_options
+        {stripe_account: stripe_account}.compact
       end
     end
   end