solidus_stripe 4.4.1 → 5.0.0.alpha.1

data/lib/generators/solidus_stripe/install/install_generator.rb

@@ -3,30 +3,137 @@
 module SolidusStripe
   module Generators
     class InstallGenerator < Rails::Generators::Base
-      class_option :auto_run_migrations, type: :boolean, default: false
+      class_option :migrations, type: :boolean, default: true
+      class_option :core, type: :boolean, default: true
+      class_option :backend, type: :boolean, default: true
+      class_option :starter_frontend, type: :boolean, default: true
 
-      def add_javascripts
-        append_file 'vendor/assets/javascripts/spree/frontend/all.js', "//= require spree/frontend/solidus_stripe\n"
+      class_option :migrate, type: :boolean, default: true
+      class_option :load_seeds, type: :boolean, default: true
+      class_option :watch, type: :boolean, default: false, hide: true
+      class_option :sync, type: :boolean, default: false, hide: true
+
+      # This is only used to run all-specs during development and CI,  regular installation limits
+      # installed specs to frontend, which are the ones related to code copied to the target application.
+      class_option :specs, type: :string, enum: %w[all frontend], default: 'frontend', hide: true
+
+      source_root File.expand_path('templates', __dir__)
+
+      def install_migrations
+        return if options[:sync]
+
+        say_status :install, "[#{engine.engine_name}] migrations", :blue
+        shell.indent do
+          rake 'railties:install:migrations FROM=solidus_stripe'
+          run 'bin/rails db:migrate' if options[:migrate]
+        end
+      end
+
+      def install_solidus_core_support
+        support_code_for(:core) do
+          directory 'config/initializers', 'config/initializers'
+          route "mount SolidusStripe::Engine, at: '/solidus_stripe'"
+        end
+      end
+
+      def install_solidus_backend_support
+        support_code_for(:backend) do
+          append_file(
+            'vendor/assets/javascripts/spree/backend/all.js',
+            "//= require spree/backend/solidus_stripe\n"
+          )
+          inject_into_file(
+            'vendor/assets/stylesheets/spree/backend/all.css',
+            " *= require spree/backend/solidus_stripe\n",
+            before: %r{\*/},
+            verbose: true,
+          )
+        end
       end
 
-      def add_migrations
-        run 'bin/rails railties:install:migrations FROM=solidus_stripe'
+      def install_solidus_starter_frontend_support
+        support_code_for(:starter_frontend) do
+          directory 'app', 'app'
+          inject_into_file(
+            'app/assets/stylesheets/solidus_starter_frontend.css',
+            " *= require spree/frontend/solidus_stripe\n",
+            before: %r{\*/},
+            verbose: true,
+          )
+
+          spec_paths =
+            case options[:specs]
+            when 'all' then %w[spec]
+            when 'frontend'
+              %w[
+                spec/solidus_stripe_spec_helper.rb
+                spec/system/frontend
+                spec/support
+              ]
+            end
+
+          spec_paths.each do |path|
+            if engine.root.join(path).directory?
+              directory engine.root.join(path), path
+            else
+              template engine.root.join(path), path
+            end
+          end
+
+          run 'bin/importmap pin @stripe/stripe-js'
+        end
       end
 
-      def run_migrations
-        run_migrations = options[:auto_run_migrations] || ENV['CI'] || ['', 'y', 'Y'].include?(ask('Would you like to run the migrations now? [Y/n]')) # rubocop:disable Layout/LineLength
-        if run_migrations
-          run 'bin/rails db:migrate'
+      def load_seeds
+        if options[:migrate] && options[:load_seeds]
+          say_status :load, "seed data", :blue
+          append_file "db/seeds.rb", <<~RUBY
+            #{engine.name}.load_seed
+          RUBY
+          engine.load_seed
         else
-          puts 'Skipping bin/rails db:migrate, don\'t forget to run it!' # rubocop:disable Rails/Output
+          say_status :skip, "loading seed data", :blue
+        end
+      end
+
+      def watch
+        return unless options[:watch]
+
+        glob = "#{::SolidusStripe::Engine.root}/{app,lib,config}"
+        say_status :watch, "starting watcher... #{glob}", :cyan
+
+        require 'listen'
+        listener = Listen.to(*Dir[glob], relative: true) do |*changes|
+          say_status :watch, "changed: #{changes.flatten.join(', ')}", :cyan
+          shell.indent do
+            install_solidus_core_support
+            install_solidus_backend_support
+            install_solidus_starter_frontend_support
+          end
+          say_status :watch, "update completed", :cyan
         end
+        listener.start
+        sleep
+      rescue Interrupt
+        say_status :watch, "stopping watcher...", :cyan
+        listener.stop
+      rescue LoadError
+        say_status :error, 'in order for the --watch option to work you need the "listen" gem in your Gemfile', :red
       end
 
-      def populate_seed_data
-        return unless options.auto_run_seeds?
+      private
+
+      def support_code_for(component_name, &block)
+        if options[component_name]
+          say_status :install, "[#{engine.engine_name}] solidus_#{component_name}", :blue
+          shell.indent(&block)
+        else
+          say_status :skip, "[#{engine.engine_name}] solidus_#{component_name}", :blue
+        end
+      end
 
-        say_status :loading, 'stripe seed data'
-        rake('db:seed:solidus_stripe')
+      def engine
+        ::SolidusStripe::Engine
       end
     end
   end

data/lib/generators/solidus_stripe/install/templates/app/assets/stylesheets/spree/frontend/solidus_stripe.css

@@ -0,0 +1,13 @@
+/*
+Placeholder manifest file.
+the installer will append this file to the app vendored assets here: 'vendor/assets/stylesheets/spree/frontend/all.css'
+*/
+
+.solidus-stripe-payment {
+  padding: 1em 0;
+}
+
+[type="submit"]:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}

data/lib/generators/solidus_stripe/install/templates/app/javascript/controllers/solidus_stripe_confirm_controller.js

@@ -0,0 +1,39 @@
+import { Controller } from "@hotwired/stimulus"
+import { loadStripe } from "@stripe/stripe-js"
+
+export default class extends Controller {
+  static values = {
+    clientSecret: String,
+    publishableKey: String,
+    returnUrl: String,
+    errorBaseUrl: String,
+  }
+
+  async connect() {
+    this.stripe = await loadStripe(this.publishableKeyValue)
+  }
+
+  // action
+  async confirm(e) {
+    // Bail out if not on the confirm method form.
+    if (e.target !== this.element.form) return
+
+    e.preventDefault()
+
+    const { error } = await this.stripe.confirmPayment({
+      clientSecret: this.clientSecretValue,
+      confirmParams: { return_url: this.returnUrlValue },
+    })
+
+    if (error) {
+      // This point will only be reached if there is an immediate error when
+      // confirming the payment. Show error to your customer.
+      const messageParam = `error_message=${encodeURIComponent(error.message)}`
+      location.href = `${this.errorBaseUrlValue}&${messageParam}`
+    } else {
+      // Your customer will be redirected to your `return_url`. For some payment
+      // methods like iDEAL, your customer will be redirected to an intermediate
+      // site first to authorize the payment, then redirected to the `return_url`.
+    }
+  }
+}

data/lib/generators/solidus_stripe/install/templates/app/javascript/controllers/solidus_stripe_payment_controller.js

@@ -0,0 +1,89 @@
+import { Controller } from "@hotwired/stimulus"
+import { loadStripe } from "@stripe/stripe-js"
+
+export default class extends Controller {
+  static values = {
+    clientSecret: String,
+    publishableKey: String,
+    paymentElementOptions: Object,
+
+    // For now we don't have a controller to interact with
+    // and we can't use outlets, so we fallback on acquiring selectors.
+    submitSelector: String,
+    radioSelector: String,
+  }
+
+  static targets = ["paymentElement", "message", "paymentMethodInput"]
+
+  get submitOutletElement() {
+    return document.querySelector(this.submitSelectorValue)
+  }
+
+  get radioOutletElement() {
+    return document.querySelector(this.radioSelectorValue)
+  }
+
+  async connect() {
+    this.stripe = await loadStripe(this.publishableKeyValue)
+    this.setupPaymentElement()
+  }
+
+  // @action
+  async handleSubmit(e) {
+    // Bail out if not on the payment method form.
+    if (e.target !== this.radioOutletElement.form) return
+
+    // Bail out if the current payment method is not selected.
+    if (!this.radioOutletElement.checked) return
+
+    e.preventDefault()
+
+    this.setLoading(true)
+
+    // Trigger form validation and wallet collection
+    const { error: submitError } = await this.elements.submit()
+
+    if (submitError) {
+      this.messageTarget.textContent = submitError.message
+      this.setLoading(false)
+      return
+    }
+
+    // Create the PaymentMethod using the details collected by the Payment Element
+    const { error, paymentMethod } = await this.stripe.createPaymentMethod({
+      elements: this.elements,
+      params: { billing_details: {} },
+    })
+
+    if (error) {
+      if (error.type === "card_error" || error.type === "validation_error") {
+        this.messageTarget.textContent = error.message
+      } else {
+        this.messageTarget.textContent = "An unexpected error occurred."
+      }
+      this.setLoading(false)
+      return
+    }
+
+    this.setLoading(false)
+    this.paymentMethodInputTarget.value = paymentMethod.id
+    this.paymentMethodInputTarget.form.submit()
+  }
+
+  setupPaymentElement() {
+    this.elements = this.stripe.elements(this.paymentElementOptionsValue)
+    this.paymentElement = this.elements.create("payment", { layout: "tabs" })
+    this.paymentElementTarget.innerHTML = "" // Remove child nodes used for loading
+    this.paymentElement.mount(this.paymentElementTarget)
+  }
+
+  setLoading(isLoading) {
+    const element = this.submitOutletElement
+
+    if (isLoading) {
+      element.setAttribute("disabled", "")
+    } else {
+      element.removeAttribute("disabled")
+    }
+  }
+}

data/lib/generators/solidus_stripe/install/templates/app/views/checkouts/existing_payment/_stripe.html.erb

@@ -0,0 +1,16 @@
+<%
+  stripe_payment_method = wallet_payment_source.payment_source.stripe_payment_method
+
+  # https://stripe.com/docs/api/payment_methods/object#payment_method_object-type
+  partial_base = "checkouts/existing_payment/stripe"
+  payment_type = stripe_payment_method.type
+
+  # Fallback on the default partial if a specialized partial is not available.
+  payment_type = 'default' if lookup_context.find_all("#{partial_base}/_#{payment_type}").none?
+%>
+
+<div>
+  <label>
+    <%= render "#{partial_base}/#{payment_type}", stripe_payment_method: stripe_payment_method %>
+  </label>
+</div>

data/lib/generators/solidus_stripe/install/templates/app/views/checkouts/existing_payment/stripe/_card.html.erb

@@ -0,0 +1,8 @@
+<% card = stripe_payment_method.card %>
+<%#
+  Add credit card logos:
+  https://support.stripe.com/questions/where-to-find-logos-for-accepted-credit-card-types
+%>
+💳 <%= card.brand %>
+<span>****&nbsp;****&nbsp;****&nbsp;<%= card.last4 %></span>
+(<%= t 'spree.expiration' %>: <%= card.exp_month %>/<%= card.exp_year %>)

data/lib/generators/solidus_stripe/install/templates/app/views/checkouts/existing_payment/stripe/_default.html.erb

@@ -0,0 +1,7 @@
+<% logger.error(
+  %{Can't find a partial for payments with type #{payment_type} } +
+  %{please add a partial named "#{partial_base}/_#{payment_type}.html.erb".}
+) %>
+
+<%= stripe_payment_method.type.humanize %>
+(<%= time_ago_in_words Time.at(stripe_payment_method.created) %>)

data/lib/generators/solidus_stripe/install/templates/app/views/checkouts/payment/_stripe.html.erb

@@ -0,0 +1,39 @@
+<% payment_element_options = {
+  mode: 'payment',
+  amount: SolidusStripe::MoneyToStripeAmountConverter.to_stripe_amount(
+    current_order.display_order_total_after_store_credit.money.fractional,
+    current_order.currency,
+  ),
+  currency: current_order.currency.downcase,
+  paymentMethodCreation: 'manual',
+  captureMethod: payment_method.auto_capture? ? 'automatic' : 'manual',
+  # Fully customizable with appearance API.
+  # https://stripe.com/docs/elements/appearance-api
+  # appearance: {},
+} %>
+
+<div
+  class="solidus-stripe-payment"
+  data-controller="solidus-stripe-payment"
+  data-solidus-stripe-payment-publishable-key-value="<%= payment_method.preferred_publishable_key %>"
+  data-solidus-stripe-payment-payment-element-options-value="<%= payment_element_options.to_json %>"
+  data-solidus-stripe-payment-radio-selector-value="#order_payments_attributes__payment_method_id_<%= payment_method.id %>"
+  data-solidus-stripe-payment-submit-selector-value="#checkout_form_payment [type='submit']"
+  data-action="submit@window->solidus-stripe-payment#handleSubmit"
+>
+  <input
+    type="hidden"
+    name="payment_source[<%= payment_method.id %>][stripe_payment_method_id]"
+    value=""
+    data-solidus-stripe-payment-target="paymentMethodInput"
+  >
+
+  <div data-solidus-stripe-payment-target="paymentElement">
+    <!-- Elements will create form elements here -->
+    <em><%= t('solidus_stripe.loading') %></em>
+  </div>
+
+  <div data-solidus-stripe-payment-target="message">
+    <!-- Display error/notification messages to your customers here -->
+  </div>
+</div>

data/lib/generators/solidus_stripe/install/templates/app/views/orders/payment_info/_stripe.html.erb

@@ -0,0 +1,20 @@
+<% stripe_payment_method = payment.source.stripe_payment_method %>
+<%= render(
+  "checkouts/existing_payment/stripe/#{stripe_payment_method.type}",
+  stripe_payment_method: stripe_payment_method
+) %>
+
+<% if current_order&.confirm? %>
+  <% stripe_intent =
+    SolidusStripe::PaymentIntent.prepare_for_payment(payment).stripe_intent %>
+
+  <input
+    type="hidden"
+    data-controller="solidus-stripe-confirm"
+    data-solidus-stripe-confirm-publishable-key-value="<%= payment.payment_method.preferred_publishable_key %>"
+    data-solidus-stripe-confirm-client-secret-value="<%= stripe_intent.client_secret %>"
+    data-solidus-stripe-confirm-return-url-value="<%= solidus_stripe.after_confirmation_url(payment.payment_method.slug) %>"
+    data-solidus-stripe-confirm-error-base-url-value="<%= solidus_stripe.after_confirmation_url(payment.payment_method.slug, payment_intent: stripe_intent.id) %>"
+    data-action="submit@window->solidus-stripe-confirm#confirm"
+  >
+<% end %>

data/lib/generators/solidus_stripe/install/templates/config/initializers/solidus_stripe.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+SolidusStripe.configure do |config|
+  # List of webhook events you want to handle.
+  # For instance, if you want to handle the `payment_intent.succeeded` event,
+  # you should add it to the list below. A corresponding
+  # `:"stripe.payment_intent.succeeded"` event will be published in `Spree::Bus`
+  # whenever a `payment_intent.succeeded` event is received from Stripe.
+  # config.webhook_events = %i[payment_intent.succeeded]
+  #
+  # Number of seconds while a webhook event is valid after its creation.
+  # Defaults to the same value as Stripe's default.
+  # config.webhook_signature_tolerance = 150
+  #
+  # Name of the `Spree::RefundReason` used for Stripe-generated refunds.
+  # Defaults to {SolidusStripe::DEFAULT_STRIPE_REFUND_REASON_NAME}. If you
+  # change it, make sure that the corresponding `Spree::RefundReason` exists in
+  # the database with that name.
+  # config.refund_reason_name = "Stripe refund"
+end
+
+if ENV['SOLIDUS_STRIPE_API_KEY']
+  Spree::Config.static_model_preferences.add(
+    'SolidusStripe::PaymentMethod',
+    'solidus_stripe_env_credentials',
+    api_key: ENV.fetch('SOLIDUS_STRIPE_API_KEY'),
+    publishable_key: ENV.fetch('SOLIDUS_STRIPE_PUBLISHABLE_KEY'),
+    test_mode: ENV.fetch('SOLIDUS_STRIPE_API_KEY').start_with?('sk_test_'),
+    webhook_endpoint_signing_secret: ENV.fetch('SOLIDUS_STRIPE_WEBHOOK_SIGNING_SECRET')
+  )
+end

data/lib/solidus_stripe/configuration.rb

@@ -1,10 +1,31 @@
 # frozen_string_literal: true
 
+require "stripe/webhook"
+require "solidus_stripe/seeds"
+
 module SolidusStripe
   class Configuration
-    # Define here the settings for this extension, e.g.:
-    #
-    # attr_accessor :my_setting
+    # @!attribute [rw] webhook_events
+    #  @return [Array<Symbol>] stripe events to handle. You also need to
+    #  register them in the Stripe dashboard. For an event `:foo`, a matching
+    #  `:"stripe.foo"` event will be registered in `Spree::Bus`.
+    attr_accessor :webhook_events
+
+    # @!attribute [rw] webhook_signature_tolerance
+    #  @return [Integer] number of seconds while a webhook event is valid after
+    #  its creation. Defaults to `Stripe::Webhook::DEFAULT_TOLERANCE`.
+    attr_accessor :webhook_signature_tolerance
+
+    # @!attribute [rw] refund_reason_name
+    #   @return [String] `Spree::RefundReason#name` used for Stripe-generated
+    #     refunds. Defaults to {SolidusStripe::Seeds::DEFAULT_STRIPE_REFUND_REASON_NAME}.
+    attr_accessor :refund_reason_name
+
+    def initialize
+      @webhook_events = []
+      @webhook_signature_tolerance = Stripe::Webhook::DEFAULT_TOLERANCE
+      @refund_reason_name = Seeds::DEFAULT_STRIPE_REFUND_REASON_NAME
+    end
   end
 
   class << self

data/lib/solidus_stripe/engine.rb

@@ -7,17 +7,30 @@ module SolidusStripe
   class Engine < Rails::Engine
     include SolidusSupport::EngineExtensions
 
-    isolate_namespace ::Spree
-
+    isolate_namespace SolidusStripe
     engine_name 'solidus_stripe'
 
+    initializer "solidus_stripe.add_payment_method", after: "spree.register.payment_methods" do |app|
+      app.config.spree.payment_methods << 'SolidusStripe::PaymentMethod'
+
+      ::Spree::PermittedAttributes.source_attributes.prepend :stripe_payment_method_id
+    end
+
+    initializer "solidus_stripe.pub_sub", after: "spree.core.pub_sub" do |app|
+      require "solidus_stripe/webhook/event"
+      app.reloader.to_prepare do
+        SolidusStripe::Webhook::Event.register(
+          user_events: SolidusStripe.configuration.webhook_events,
+          bus: Spree::Bus
+        )
+        SolidusStripe::Webhook::PaymentIntentSubscriber.new.subscribe_to(Spree::Bus)
+        SolidusStripe::Webhook::ChargeSubscriber.new.subscribe_to(Spree::Bus)
+      end
+    end
+
     # use rspec for tests
     config.generators do |g|
       g.test_framework :rspec
     end
-
-    initializer "spree.payment_method.add_stripe_credit_card", after: "spree.register.payment_methods" do |app|
-      app.config.spree.payment_methods << "Spree::PaymentMethod::StripeCreditCard"
-    end
   end
 end

data/lib/solidus_stripe/money_to_stripe_amount_converter.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# Helpers to interoperate amounts between Solidus and Stripe.
+#
+# Solidus will provide a "fractional" amount, that is specific for each currency
+# following the configuration defined in the Money gem.
+#
+# Stripe uses the "smallest currency unit", (e.g., 100 cents to charge $1.00 or
+# 100 to charge ¥100, a zero-decimal currency).
+#
+# @see https://stripe.com/docs/currencies#zero-decimal
+#
+# We need to ensure the fractional amount is considering the same number of decimals.
+module SolidusStripe::MoneyToStripeAmountConverter
+  extend ActiveSupport::Concern
+  extend self
+
+  # @api private
+  ZERO_DECIMAL_CURRENCIES = %w[
+    BIF
+    CLP
+    DJF
+    GNF
+    JPY
+    KMF
+    KRW
+    MGA
+    PYG
+    RWF
+    UGX
+    VND
+    VUV
+    XAF
+    XOF
+    XPF
+  ].freeze
+
+  # @api private
+  THREE_DECIMAL_CURRENCIES = %w[
+    BHD
+    JOD
+    KWD
+    OMR
+    TND
+  ].freeze
+
+  # @api private
+  #
+  # Special currencies that are represented in cents but should be
+  # divisible by 100, thus making them integer only.
+  DIVISIBLE_BY_100 = %w[
+    HUF
+    TWD
+    UGX
+  ].freeze
+
+  def to_stripe_amount(fractional, currency)
+    solidus_subunit_to_unit, stripe_subunit_to_unit = subunit_to_unit(currency)
+
+    if stripe_subunit_to_unit == solidus_subunit_to_unit
+      fractional
+    else
+      (fractional / solidus_subunit_to_unit.to_d) * stripe_subunit_to_unit.to_d
+    end
+  end
+
+  def to_solidus_amount(fractional, currency)
+    solidus_subunit_to_unit, stripe_subunit_to_unit = subunit_to_unit(currency)
+
+    if stripe_subunit_to_unit == solidus_subunit_to_unit
+      fractional
+    else
+      (fractional / stripe_subunit_to_unit.to_d) * solidus_subunit_to_unit.to_d
+    end
+  end
+
+  # Transforms a decimal amount into a subunit amount
+  #
+  # @param amount [BigDecimal]
+  # @param currency [String]
+  # @return [Integer]
+  def solidus_decimal_to_subunit(amount, currency)
+    Money.from_amount(amount, currency).fractional
+  end
+
+  # Transforms a subunit amount into a decimal amount
+  #
+  # @param amount [Integer]
+  # @param currency [String]
+  # @return [BigDecimal]
+  def solidus_subunit_to_decimal(amount, currency)
+    Money.new(amount, currency).to_d
+  end
+
+  private
+
+  def subunit_to_unit(currency)
+    solidus_subunit_to_unit = ::Money::Currency.new(currency).subunit_to_unit
+    stripe_subunit_to_unit =
+      case currency.to_s.upcase
+      when *ZERO_DECIMAL_CURRENCIES then 1
+      when *THREE_DECIMAL_CURRENCIES then 1000
+      when *DIVISIBLE_BY_100 then 100
+      else 100
+      end
+
+    [solidus_subunit_to_unit, stripe_subunit_to_unit]
+  end
+end