spree_core 5.6.0 → 6.0.0.beta1

data/app/services/spree/stores/provision_defaults.rb

@@ -0,0 +1,269 @@
+module Spree
+  module Stores
+    # Creates the per-store defaults whose shape depends on where the shop is:
+    # the default market, the warehouse, the delivery zones and their methods,
+    # and pickup. The seeds cannot build these, because when they run nobody
+    # has said which country the shop sells from yet — so they are built here,
+    # from the merchant's answer, rather than seeded as US and rewritten later.
+    #
+    # Two callers only (docs/plans/6.0-store-context-and-first-run-setup.md):
+    # the first-run setup endpoint, and the env-credential branch of
+    # Spree::Seeds::AdminUser. Never wire this to a settings screen — run
+    # against a configured store it reads as a data reset.
+    class ProvisionDefaults
+      prepend Spree::ServiceModule::Base
+
+      DOMESTIC_AMOUNT = 5
+      INTERNATIONAL_AMOUNT = 20
+
+      # @param store [Spree::Store] the store to provision, already persisted
+      # @param country [Spree::Country] where the shop ships from
+      # @param locale [String, nil] storefront locale; defaults to the
+      #   country's own language when Spree translates it, then English
+      # @param currency [String, nil] ISO 4217 code; defaults to the country's
+      #   own currency. Merchants who ship from one country and price in
+      #   another currency pass it explicitly.
+      # @return [Spree::Store] the store, reloaded
+      def call(store:, country:, locale: nil, currency: nil)
+        @store = store
+        @country = country
+        @currency = resolve_currency(currency, country)
+        @locale = resolve_locale(locale, country)
+
+        ApplicationRecord.transaction do
+          update_default_market
+          provision_stock_location
+          provision_delivery_zones
+          provision_package_type
+          provision_pickup
+          restate_seeded_calculators
+        end
+
+        store.reload
+      end
+
+      private
+
+      attr_reader :store, :country, :currency, :locale
+
+      # An unknown code falls back rather than raising: callers validate before
+      # calling, and a seed reading STORE_CURRENCY from the environment should
+      # not fail an install over a typo.
+      def resolve_currency(requested, country)
+        found = ::Money::Currency.find(requested.to_s.strip) if requested.present?
+
+        found&.iso_code || country.default_currency.presence || 'USD'
+      end
+
+      # An explicit locale is honored as given — a host app may ship its own
+      # translations. Only the *derived* default is filtered: falling back to
+      # a country's official language that Spree has no strings for would set
+      # a storefront to a language with nothing behind it, and it is not one
+      # the setup screen ever offers. Installs without spree_i18n know only
+      # English, so filtering there would flatten every country to it.
+      def resolve_locale(requested, country)
+        return requested if requested.present?
+
+        derived = country.default_locale.presence
+        return 'en' if derived.blank?
+
+        translated = Spree.available_locales.map { |locale| locale.to_s.split('-').first }.uniq
+        return derived if translated.size <= 1 || translated.include?(derived)
+
+        (country.official_locales & translated).first || 'en'
+      end
+
+      # The store's own country/currency/locale columns are not the source of
+      # truth once a market exists — Spree::Stores::Markets reads through the
+      # default market — so the market is what gets written. The columns are
+      # kept in step for the stores that have no market yet.
+      def update_default_market
+        store.update_columns(
+          default_country_code: country.iso,
+          default_currency: currency,
+          default_locale: locale,
+          updated_at: Time.current
+        )
+        adopt_admin_locale
+        store.association(:default_market).reset
+
+        market = store.default_market
+        return if market.nil?
+
+        market.name = country.name
+        market.currency = currency
+        market.default_locale = locale
+        market.country_codes = [country.iso]
+        market.save!
+
+        store.association(:default_market).reset
+      end
+
+      # The merchant is asked for one language, and expects it to apply to the
+      # back office as well as the storefront — those are separate settings,
+      # and setting only the storefront one leaves the dashboard in English.
+      # This is the store-wide default, the weakest of the three tiers: an
+      # admin's own choice still wins, and Settings can change it later.
+      #
+      # Written even when the dashboard ships no translations for it. Whether
+      # a language has an admin bundle is the dashboard's own fact, not one
+      # this side can check without going stale — an unsupported code is
+      # ignored there and falls back to English, and starts working on its
+      # own if a bundle lands later.
+      def adopt_admin_locale
+        return if store.preferred_admin_locale.present?
+
+        store.preferred_admin_locale = locale
+        store.save!
+      end
+
+      # Match on identity alone: folding the other attributes into the finder
+      # made re-running fail once anything edited them.
+      def provision_stock_location
+        # first_party, so a seller who happened to name a location the same
+        # thing is never adopted as the store's own.
+        location = store.stock_locations.first_party.
+                   where(name: Spree.t(:default_stock_location_name)).first_or_initialize
+        location.propagate_all_variants = false if location.new_record?
+        location.country_code = country.iso
+        if location.persisted? && location.will_save_change_to_country_code?
+          location.assign_attributes(address1: nil, address2: nil, city: nil,
+                                     state_code: nil, state_name: nil,
+                                     zipcode: nil, phone: nil)
+        end
+        location.active = true
+        location.default = true
+        location.save!
+      end
+
+      # Shopify-style defaults: the store's own country ships cheaply,
+      # everywhere else ships at the international rate.
+      def provision_delivery_zones
+        profile = store.default_delivery_profile ||
+                  Spree::DeliveryProfiles::Shipping.create!(store: store, name: 'General', default: true)
+
+        domestic = store.delivery_zones.where(name: 'Domestic').first_or_initialize
+        domestic.description = country.name
+        domestic.delivery_profile = profile
+        domestic.save!
+        sync_zone_countries(domestic, [country.iso])
+
+        international = store.delivery_zones.where(name: 'International').first_or_initialize
+        international.description = 'Everywhere else'
+        international.delivery_profile = profile
+        international.save!
+        sync_zone_countries(international, Spree::Country.all.map(&:iso) - [country.iso])
+
+        create_method('Standard', domestic, DOMESTIC_AMOUNT)
+        create_method('International Shipping', international, INTERNATIONAL_AMOUNT)
+      end
+
+      # Rewrites membership so re-running with a different country cannot
+      # leave the previous country's rows behind on both zones.
+      def sync_zone_countries(zone, isos)
+        existing = zone.members.where(member_type: 'country')
+        existing.where.not(country_code: isos).delete_all
+
+        missing = isos - existing.reload.pluck(:country_code)
+        return if missing.empty?
+
+        now = Time.current
+        Spree::DeliveryZoneMember.insert_all(
+          missing.map do |iso|
+            {
+              delivery_zone_id: zone.id,
+              member_type: 'country',
+              country_code: iso,
+              created_at: now,
+              updated_at: now
+            }
+          end
+        )
+      end
+
+      def create_method(name, zone, amount)
+        delivery_method = store.delivery_methods.where(name: name).first_or_initialize
+        delivery_method.delivery_profile = zone.delivery_profile
+        delivery_method.delivery_zone = zone
+        delivery_method.calculator ||= Spree::Calculator::Shipping::FlatRate.new
+        delivery_method.calculator.preferences = { amount: amount, currency: currency }
+        delivery_method.save!
+      end
+
+      # The box the store ships parcels in. Its tare rides on every quote and
+      # its dimensions feed dimensional-weight pricing, so without one a
+      # carrier is asked to price a parcel with no size — which under-charges
+      # anything bulky but light, silently.
+      #
+      # Sized in the unit the store already implies rather than converted, so
+      # the numbers read as a merchant would write them. Skipped when the
+      # store already has a default, so a merchant's own box is never
+      # replaced and re-running is harmless.
+      def provision_package_type
+        return if store.default_package_type.present?
+
+        metric = store.metric_unit_system?
+        weight_unit = store.preferred_weight_unit
+
+        store.package_types.create!(
+          name: Spree.t('package_types.default_name'),
+          kind: 'box',
+          default: true,
+          length: metric ? 30 : 12,
+          width: metric ? 23 : 9,
+          height: metric ? 10 : 4,
+          dimensions_unit: metric ? 'cm' : 'in',
+          # The unit system and the weight unit are separate preferences, so a
+          # metric store can still weigh in pounds. Stating half a pound as
+          # `0.5` under a `kg` label — or the reverse — would misreport the
+          # tare on every quote, so the figure is converted rather than assumed.
+          weight: Spree::Measurement.convert_weight(0.5, from: 'lb', to: weight_unit).round(3),
+          weight_unit: weight_unit
+        )
+      end
+
+      # Collection at a merchant counter. Rides the store's default profile
+      # (the same physical goods ship or get collected) with no zone — pickup
+      # has no destination, only an origin, and the Pickup provider decides
+      # which locations can hand goods over.
+      def provision_pickup
+        profile = store.default_delivery_profile
+        return if profile.nil?
+
+        # A counter to collect from is what makes pickup real, so the store's
+        # default location opens for collection unless one already has.
+        if store.stock_locations.first_party.where(pickup_enabled: true).none?
+          store.stock_locations.first_party.find_by(default: true)&.update!(pickup_enabled: true)
+        end
+        return if store.stock_locations.first_party.where(pickup_enabled: true).none?
+
+        delivery_method = store.delivery_methods.where(name: Spree.t('pickup.store_pickup')).first_or_initialize
+        delivery_method.delivery_profile = profile
+        delivery_method.storefront_visible = true
+        delivery_method.fulfillment_provider = 'Spree::FulfillmentProvider::Pickup'
+        delivery_method.calculator ||= Spree::Calculator::Shipping::FlatRate.new
+        delivery_method.calculator.preferences = { amount: 0, currency: currency }
+        delivery_method.save!
+
+        # No configured counters means every pickup-enabled location, which
+        # is what a fresh store wants; seeding the links would freeze the set.
+      end
+
+      # Methods seeded before the country was known (digital delivery) captured
+      # the store's then-current currency as their calculator default, so they
+      # would still quote in dollars on a store that turned out to sell from
+      # Zurich. Only the seeded zero-amount defaults are restated — a merchant's
+      # own priced methods are never rewritten.
+      def restate_seeded_calculators
+        store.delivery_methods.includes(:calculator).find_each do |delivery_method|
+          calculator = delivery_method.calculator
+          next unless calculator.respond_to?(:preferred_currency)
+          next if calculator.preferred_currency == currency
+          next unless calculator.preferences[:amount].to_f.zero?
+
+          calculator.update!(preferences: calculator.preferences.merge(currency: currency))
+        end
+      end
+    end
+  end
+end

data/app/services/spree/tax/resolve_exemptions.rb

@@ -0,0 +1,44 @@
+module Spree
+  module Tax
+    # Assembles the exemption evidence for a sale, handed to the tax provider
+    # as +estimate+'s +exemptions:+ input.
+    #
+    # Reads the certificates the buyer's company holds for where the goods are
+    # going. Only active ones count — verified, and not past their date — so
+    # lifecycle is a filter here rather than something the provider has to
+    # reason about. Multiple certificates mean multiple entries; one claim
+    # reaching an item is enough to exempt it.
+    #
+    # A consumer sale, or a cart with no destination yet, resolves nothing and
+    # is taxed normally. Inventing a claim would be worse than collecting the
+    # tax.
+    #
+    # Swap through +Spree.tax_resolve_exemptions_service+ to read certificates
+    # that live somewhere else — a provider's own store (Avalara keeps them),
+    # or wherever the merchant already keeps them.
+    class ResolveExemptions
+      prepend Spree::ServiceModule::Base
+
+      # @param order [Spree::Cart, Spree::Order]
+      # @return [Array<Spree::TaxExemption>]
+      def call(order:)
+        # The legal entity, never the node itself: a division holds no
+        # certificates, and reading its own would silently lose the exemption.
+        company = order.company_legal_entity
+        address = order.tax_address
+        return success([]) if company.nil? || address.nil?
+
+        success(
+          company.tax_exemption_certificates.active.for_address(address).map do |certificate|
+            Spree::TaxExemption.new(
+              reason_code: certificate.reason_code,
+              certificate_number: certificate.certificate_number,
+              country_code: certificate.country_code,
+              state_code: certificate.state_code
+            )
+          end
+        )
+      end
+    end
+  end
+end

data/app/services/spree/tax/unusable_exemption_error.rb

@@ -0,0 +1,8 @@
+module Spree
+  module Tax
+    # Raised for reporting when an exemption reaches core in a state that would
+    # widen rather than narrow a claim. Reported, never raised at the customer:
+    # the sale continues with tax charged.
+    class UnusableExemptionError < StandardError; end
+  end
+end

data/app/services/spree/tax_identifiers/validate.rb

@@ -0,0 +1,77 @@
+module Spree
+  module TaxIdentifiers
+    class ValidationError < StandardError; end
+
+    # The only writer of the validation columns. Writes with +update_columns+ so
+    # recording a verdict cannot re-trigger the callback that asked for it.
+    class Validate
+      prepend Spree::ServiceModule::Base
+
+      # @param tax_identifier [Spree::TaxIdentifier]
+      # @return [Spree::TaxIdentifier]
+      def call(tax_identifier:)
+        # What this run is answering about. The buyer can change the number while
+        # a check is in flight, and a verdict about the old one must not be
+        # written over the new one — see #persist.
+        @checked = tax_identifier.slice(:kind, :value)
+
+        # Absent, or named by an entry that no longer loads — a gem dropped
+        # while a check was already queued. Both mean the same thing here as a
+        # deregistration does, and neither is a registry that failed to answer,
+        # so they must not be recorded as an outage.
+        validator_class = Spree.tax_identifier_validators[tax_identifier.kind].presence&.to_s&.safe_constantize
+        return persist(tax_identifier, unsupported_result) if validator_class.nil?
+
+        # Nothing should enqueue a check for a format-only validator, since
+        # TaxIdentifier#validatable? reports false for one. Belt and braces all
+        # the same: it must not surface as a job that crashes. A validator
+        # predating the predicate is assumed to ask, as it always did.
+        if validator_class.respond_to?(:checks_registry?) && !validator_class.checks_registry?
+          return persist(tax_identifier, unsupported_result)
+        end
+
+        result = validator_class.new.call(tax_identifier: tax_identifier)
+        persist(tax_identifier, result)
+      rescue StandardError => error
+        # A number nobody could check is not a number known to be wrong, so it
+        # is recorded as unanswered rather than rejected — and recorded rather
+        # than left on the `pending` the enqueue stamped. Reported rather than
+        # raised, as a failed geocode is.
+        Rails.error.report(
+          ValidationError.new("Cannot validate tax identifier ID: #{tax_identifier.id} (#{error.message})"),
+          handled: false,
+          context: { tax_identifier_id: tax_identifier.id, kind: tax_identifier.kind },
+          source: 'spree.core'
+        )
+        persist(tax_identifier, unavailable_result(error.message))
+        failure(tax_identifier, error.message)
+      end
+
+      private
+
+      # Re-read before writing. A slower check for a number the buyer has since
+      # replaced would otherwise stamp its verdict onto the new one — reporting
+      # a registration as verified when nothing has verified it, which is what
+      # decides reverse charge. The row is already `pending` from the write that
+      # replaced it, and its own check is on the way.
+      def persist(tax_identifier, result)
+        return failure(tax_identifier, result.errors.full_messages.to_sentence) unless result.valid?
+
+        current = tax_identifier.class.find_by(id: tax_identifier.id)
+        return success(tax_identifier) if current.nil?
+        return success(tax_identifier) if current.slice(:kind, :value) != @checked
+
+        current.update_columns(result.to_columns.merge(updated_at: Time.current))
+        success(current)
+      end
+
+      def unsupported_result
+        Spree::TaxIdentifiers::ValidationResult.new(status: 'unsupported', checked_at: Time.current)
+      end
+
+      def unavailable_result(message)
+        Spree::TaxIdentifiers::ValidationResult.new(status: 'unavailable', message: message, checked_at: Time.current)
+      end
+    end
+  end
+end

data/app/services/spree/taxons/add_products.rb

@@ -1,50 +1,17 @@
 module Spree
   module Taxons
+    # @deprecated Renamed to Spree::Categories::AddProducts in 6.0. This shim keeps
+    #   the old `taxons:` keyword working by delegating to the renamed service;
+    #   removed in 6.1.
     class AddProducts
       prepend Spree::ServiceModule::Base
 
-      # Creates classifications for the given taxons and products in bulk.
-      #
-      # @param taxons [Array<Spree::Taxon>]
+      # @param taxons [Array<Spree::Category>]
       # @param products [Array<Spree::Product>]
       # @return [Spree::ServiceModule::Base::Result]
       def call(taxons:, products:)
-        return if taxons.blank? || products.blank?
-
-        # build the params for the insert_all
-        classifications_params = taxons.pluck(:id).flat_map do |taxon_id|
-          position = Spree::Classification.where(taxon_id: taxon_id).count
-
-          products.pluck(:id).map do |product_id|
-            {
-              taxon_id: taxon_id,
-              product_id: product_id,
-              position: (position += 1),
-              created_at: Time.current,
-              updated_at: Time.current
-            }
-          end
-        end
-        # doing a quick insert_all here to avoid the overhead of instantiating
-        Spree::Classification.insert_all(classifications_params)
-
-        # update counter caches
-        taxon_ids = taxons.pluck(:id)
-        product_ids = products.pluck(:id)
-        taxon_ids.each { |id| Spree::Taxon.reset_counters(id, :classifications) }
-        product_ids.each { |id| Spree::Product.reset_counters(id, :classifications) }
-        # Recompute the descendant-inclusive products_count for the taxons and
-        # their ancestors (bulk insert skips Classification callbacks).
-        Spree::Taxon.recalculate_products_count(taxon_ids)
-
-        # clear cache & index products
-        Spree::Product.where(id: product_ids).touch_all
-        products.each(&:enqueue_search_index)
-
-        Spree::Taxon.where(id: taxon_ids).touch_all
-        Spree::Taxons::TouchFeaturedSections.call(taxon_ids: taxon_ids) if defined?(Spree::Taxons::TouchFeaturedSections)
-
-        success(true)
+        Spree::Deprecation.warn('Spree::Taxons::AddProducts is deprecated and will be removed in Spree 6.1. Use Spree::Categories::AddProducts instead.')
+        Spree::Categories::AddProducts.call(categories: taxons, products: products)
       end
     end
   end

data/app/services/spree/taxons/regenerate_products.rb

@@ -1,63 +1,18 @@
 module Spree
   module Taxons
+    # @deprecated Categories are manual in 6.0 and no longer regenerate membership
+    #   from rules — that behavior moved to Spree::Collection. There is no faithful
+    #   category target, so this shim warns and no-ops (returns the given taxon).
+    #   Use Spree::Collections::RegenerateProducts for collections. Removed in 6.1.
     class RegenerateProducts
       prepend ::Spree::ServiceModule::Base
 
-      def call(taxon:)
-        return if taxon.nil?
-        return if taxon.destroyed?
-        return if taxon.manual?
-
-        previous_products_ids = taxon.classifications.order(position: :asc).pluck(:product_id)
-
-        # https://api.rubyonrails.org/classes/ActiveRecord/Associations/CollectionProxy.html#method-i-delete_all
-        # we don't want to run destroy_all here to avoid callbacks
-        # default dependent value is nullify and that won't work for us
-        taxon.classifications.delete_all(:delete_all)
-
-        products_matching_rules = taxon.products_matching_rules
-        product_ids_to_insert = products_matching_rules.ids
-
-        previous_filtered_products_ids = previous_products_ids & product_ids_to_insert
-        max_products_position = previous_filtered_products_ids.size || 0
-
-        if product_ids_to_insert.any?
-          records_to_insert = product_ids_to_insert.map do |product_id|
-            position = previous_filtered_products_ids.index(product_id)
-            position = position.present? ? position + 1 : max_products_position += 1
-
-            classification_attributes(product_id, taxon, position)
-          end
-
-          Spree::Classification.insert_all(records_to_insert)
-
-          # expire product cache
-          products = Spree::Product.where(id: (previous_products_ids + product_ids_to_insert).uniq)
-          products.touch_all
-          products.each(&:enqueue_search_index)
-        end
-
-        # update counter caches
-        # Check if taxon still exists (may have been destroyed)
-        Spree::Taxon.reset_counters(taxon.id, :classifications)
-        all_product_ids = (previous_products_ids + product_ids_to_insert).uniq
-        existing_product_ids = Spree::Product.where(id: all_product_ids).pluck(:id)
-        existing_product_ids.each { |id| Spree::Product.reset_counters(id, :classifications) }
-
+      # @param taxon [Spree::Category] accepted for signature compatibility; ignored
+      # @return [Spree::ServiceModule::Base::Result]
+      def call(taxon: nil)
+        Spree::Deprecation.warn('Spree::Taxons::RegenerateProducts is deprecated and does nothing in Spree 6.0 — categories are manual. Rule-based membership moved to Spree::Collection; use Spree::Collections::RegenerateProducts. Removed in 6.1.')
         success(taxon)
       end
-
-      private
-
-      def classification_attributes(product_id, taxon, position)
-        {
-          product_id: product_id,
-          taxon_id: taxon.id,
-          position: position,
-          created_at: Time.current,
-          updated_at: Time.current
-        }
-      end
     end
   end
 end

data/app/services/spree/taxons/remove_products.rb

@@ -1,71 +1,17 @@
 module Spree
   module Taxons
+    # @deprecated Renamed to Spree::Categories::RemoveProducts in 6.0. This shim keeps
+    #   the old `taxons:` keyword working by delegating to the renamed service;
+    #   removed in 6.1.
     class RemoveProducts
       prepend Spree::ServiceModule::Base
 
-      # Removes the given products from the given taxons.
-      #
-      # @param taxons [Array<Spree::Taxon>]
+      # @param taxons [Array<Spree::Category>]
       # @param products [Array<Spree::Product>]
       # @return [Spree::ServiceModule::Base::Result]
       def call(taxons:, products:)
-        return if taxons.blank? || products.blank?
-
-        taxon_ids = taxons.pluck(:id)
-        product_ids = products.pluck(:id)
-
-        ApplicationRecord.transaction do
-          taxon_ids.each do |taxon_id|
-            Spree::Classification.where(taxon_id: taxon_id, product_id: product_ids).delete_all
-          end
-
-          classifications_params = taxon_ids.flat_map do |taxon_id|
-            position = 0
-            existing_product_ids = Spree::Classification.where(taxon_id: taxon_id).pluck(:product_id)
-
-            existing_product_ids.map do |product_id|
-              {
-                taxon_id: taxon_id,
-                product_id: product_id,
-                position: (position += 1),
-                created_at: Time.current,
-                updated_at: Time.current
-              }
-            end
-          end
-
-          if classifications_params.any?
-            opts = {}
-            opts[:unique_by] = :index_spree_products_taxons_on_product_id_and_taxon_id unless mysql_adapter?
-
-            Spree::Classification.upsert_all(
-              classifications_params,
-              **opts
-            )
-          end
-        end
-
-        # update counter caches
-        taxon_ids.each { |id| Spree::Taxon.reset_counters(id, :classifications) }
-        product_ids.each { |id| Spree::Product.reset_counters(id, :classifications) }
-        # Recompute the descendant-inclusive products_count for the taxons and
-        # their ancestors (delete_all skips Classification callbacks).
-        Spree::Taxon.recalculate_products_count(taxon_ids)
-
-        # clear cache & index products
-        Spree::Product.where(id: product_ids).touch_all
-        products.each(&:enqueue_search_index)
-
-        Spree::Taxon.where(id: taxon_ids).touch_all
-        Spree::Taxons::TouchFeaturedSections.call(taxon_ids: taxon_ids) if defined?(Spree::Taxons::TouchFeaturedSections)
-
-        success(true)
-      end
-
-      private
-
-      def mysql_adapter?
-        ActiveRecord::Base.connection.adapter_name.downcase.include?('mysql')
+        Spree::Deprecation.warn('Spree::Taxons::RemoveProducts is deprecated and will be removed in Spree 6.1. Use Spree::Categories::RemoveProducts instead.')
+        Spree::Categories::RemoveProducts.call(categories: taxons, products: products)
       end
     end
   end

data/app/services/spree/variants/remove_line_items.rb

@@ -4,7 +4,12 @@ module Spree
       prepend Spree::ServiceModule::Base
 
       def call(variant:)
-        variant.line_items.joins(:order).where(spree_orders: { state: Spree::Order::LINE_ITEM_REMOVABLE_STATES }).find_each do |line_item|
+        # Removable = still mutable: any cart-owned line, or a line on an
+        # uncompleted, uncanceled order (drafts).
+        variant.line_items.where.not(cart_id: nil).find_each do |line_item|
+          Spree::Variants::RemoveLineItemJob.perform_later(line_item: line_item)
+        end
+        variant.line_items.joins(:order).merge(Spree::Order.incomplete.not_canceled).find_each do |line_item|
           Spree::Variants::RemoveLineItemJob.perform_later(line_item: line_item)
         end
 

data/app/subscribers/spree/event_log_subscriber.rb

@@ -9,7 +9,7 @@ module Spree
   # Rails.application.config.filter_parameters.
   #
   # @example Output
-  #   [Spree Event] order.completed | payload: {"id"=>1} | 0.5ms
+  #   [Spree Event] order.placed | payload: {"id"=>1} | 0.5ms
   #
   class EventLogSubscriber
     NAMESPACE = 'spree'

data/app/subscribers/spree/order_commission_subscriber.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Spree
+  # Charges commission once an order is placed.
+  #
+  # Synchronous, like the other placement side effects, because the commission
+  # lines are what a seller is told they owe: a marketplace that showed an
+  # order before its commission existed would be showing an incomplete book,
+  # and the work is a handful of rows against already-loaded records.
+  #
+  # Idempotency is the service's own — an order that already carries commission
+  # is left alone — so a replayed event cannot charge a seller twice.
+  class OrderCommissionSubscriber < Spree::Subscriber
+    subscribes_to 'order.placed', async: false
+
+    def handle(event)
+      order = Spree::Order.find_by_prefix_id(event.payload['id'])
+      return unless order
+
+      Spree.commissions_commission_order_service.call(order: order)
+    end
+  end
+end