pay 6.8.0 → 7.0.0

data/lib/pay/{paddle → lemon_squeezy}/error.rb

@@ -1,5 +1,5 @@
 module Pay
-  module Paddle
+  module PaddleBilling
     class Error < Pay::Error
       delegate :message, to: :cause
     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/paddle_billing/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/paddle_billing/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/paddle_billing/error.rb

@@ -0,0 +1,7 @@
+module Pay
+  module PaddleBilling
+    class Error < Pay::Error
+      delegate :message, to: :cause
+    end
+  end
+end

data/lib/pay/paddle_billing/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