spree_core 5.6.1 → 6.0.0.beta1

data/app/services/spree/sample_data/import_builder.rb

@@ -3,22 +3,26 @@ module Spree
     # Creates the `Spree::Import` record for a sample CSV, attaching the file
     # but processing nothing — the two runners differ only in what they do next.
     class ImportBuilder
+      # @param attributes [Hash] anything else the import type needs before it
+      #   runs — a price-list import's `preferred_price_list_id`, say
       # @return [Spree::Import] persisted, unprocessed
-      def self.call(csv_path:, import_class:, store: nil, user: nil, inline: false, skip_events: false)
+      def self.call(csv_path:, import_class:, store: nil, user: nil, inline: false, skip_events: false, attributes: {})
         store ||= Spree::Store.default
         # An admin of the target store, not `admin_user_class.first` — in a
         # multi-store or multi-tenant app that global first can belong to a
         # different store entirely.
         user ||= store.users.first
 
-        raise 'No admin user found. Please run seeds first.' unless user
+        raise 'No admin user found for the store. Complete first-run setup, or seed with ADMIN_EMAIL/ADMIN_PASSWORD set.' unless user
 
-        import = import_class.new(owner: store, user: user)
+        import = import_class.new(store: store, user: user, **attributes)
         # Persisted before save: the processing jobs reload the record, so these
         # have to travel with it rather than live on the instance.
         import.preferred_inline = inline
         import.preferred_skip_events = skip_events
-        import.number = import.generate_permalink(import_class)
+        # Saved with `validate: false` below, which skips the before_validation
+        # that normally numbers the record.
+        import.generate_number
         import.attachment.attach(
           io: File.open(csv_path),
           filename: File.basename(csv_path),

data/app/services/spree/sample_data/import_runner.rb

@@ -19,14 +19,17 @@ module Spree
       #
       # @return [Spree::ServiceModule::Result] wrapping the import — completed
       #   when inline, queued otherwise
-      def call(csv_path:, import_class:, store: nil, user: nil, inline: false, skip_events: false)
+      def call(csv_path:, import_class:, store: nil, user: nil, inline: false, skip_events: false, attributes: {})
         import = Spree::SampleData::ImportBuilder.call(
           csv_path: csv_path, import_class: import_class, store: store, user: user,
-          inline: inline, skip_events: skip_events
+          inline: inline, skip_events: skip_events, attributes: attributes
         )
 
-        import.start_mapping
-        import.complete_mapping
+        mapping = Spree.import_start_mapping_workflow.call(import: import)
+        return failure(import, mapping.error) if mapping.failure?
+
+        completed = Spree.import_complete_mapping_workflow.call(import: import)
+        return failure(import, completed.error) if completed.failure?
 
         success(import.reload)
       end

data/app/services/spree/sample_data/loader.rb

@@ -14,27 +14,36 @@ module Spree
               puts 'Loading sample configuration data...'
               load_configuration_data
 
-              puts 'Loading sample markets...'
-              load_ruby_file('markets')
-
               puts 'Loading sample channels...'
               load_ruby_file('channels')
 
-              puts 'Loading sample metafield definitions...'
-              load_ruby_file('metafield_definitions')
+              puts 'Loading sample custom_field definitions...'
+              load_ruby_file('custom_field_definitions')
 
               puts 'Loading sample options...'
               load_ruby_file('options')
 
+              puts 'Loading sample product types...'
+              load_ruby_file('product_types')
+
               puts 'Loading sample products...'
               load_products
 
+              puts 'Attaching the sample digital product file...'
+              load_ruby_file('digital_products')
+
               puts 'Publishing sample products on the default channel...'
               publish_sample_products(Spree::Store.default)
 
               puts 'Loading sample product translations...'
               load_product_translations
 
+              puts 'Linking product types to categories...'
+              load_ruby_file('product_type_categories')
+
+              puts 'Loading sample collections...'
+              load_ruby_file('collections')
+
               puts 'Loading sample customers...'
               load_customers
 
@@ -56,7 +65,7 @@ module Spree
       private
 
       def load_configuration_data
-        load_ruby_file('shipping_methods')
+        load_ruby_file('fulfillment')
         load_ruby_file('payment_methods')
         load_ruby_file('promotions')
       end

data/app/services/spree/search_provider/custom_field_schema.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Spree
+  module SearchProvider
+    # Product custom_field definitions that participate in search/sort.
+    class CustomFieldSchema
+      # Ransack-style predicates accepted per field type. Mirrors the operator
+      # sets the admin dashboard's filter panel offers for string/number columns
+      # (see packages/dashboard-core/src/components/table-toolbar.tsx).
+      TEXT_FILTER_PREDICATES = %w[i_cont cont eq not_eq start end present blank].freeze
+      NUMBER_FILTER_PREDICATES = %w[eq gt gteq lt lteq present blank].freeze
+
+      # Longest first so a key ending in +_i_cont+ isn't mis-split as the
+      # shorter +_cont+ against a definition keyed +..._i+.
+      ORDERED_FILTER_PREDICATES = (TEXT_FILTER_PREDICATES | NUMBER_FILTER_PREDICATES).
+                                  sort_by { |predicate| -predicate.length }.freeze
+
+      attr_reader :store
+
+      # @param store [Spree::Store] the store whose custom-field schema this
+      #   describes — definitions are store-owned, so two stores have their own
+      #   filter vocabularies.
+      def initialize(store)
+        @store = store
+      end
+
+      # @return [Hash{String => Spree::CustomFieldDefinition}]
+      def entries
+        @entries ||= product_definitions.index_by(&:filter_key)
+      end
+
+      # @return [Array<String>]
+      def searchable_attribute_keys
+        @searchable_attribute_keys ||= entries.each_value.filter_map do |definition|
+          definition.filter_key if definition.searchable?
+        end
+      end
+
+      # @return [Array<String>]
+      def sortable_attribute_keys
+        @sortable_attribute_keys ||= entries.each_value.filter_map do |definition|
+          definition.filter_key if definition.sortable?
+        end
+      end
+
+      # @param attribute_key [String]
+      # @return [Spree::CustomFieldDefinition, nil]
+      def entry_for(attribute_key)
+        entries[attribute_key.to_s]
+      end
+
+      # Every schema attribute accepts filters — values are already indexed
+      # for search/sort, so filtering rides on the same document keys.
+      #
+      # @return [Array<String>]
+      def filterable_attribute_keys
+        @filterable_attribute_keys ||= entries.keys
+      end
+
+      # @return [Array<String>]
+      def sort_ids
+        @sort_ids ||= sortable_attribute_keys.flat_map { |key| [key, "-#{key}"] }
+      end
+
+      # @return [Array<Hash>] +{ id:, label: }+
+      def sort_options
+        @sort_options ||= entries.each_value.select(&:sortable?).flat_map do |definition|
+          key = definition.filter_key
+          name = definition.label.presence || key
+
+          [
+            { id: key, label: sort_option_label(name, definition.field_type, :asc) },
+            { id: "-#{key}", label: sort_option_label(name, definition.field_type, :desc) }
+          ]
+        end
+      end
+
+      # @param sort [String, nil]
+      # @return [Hash, nil] { attribute:, direction: 'asc'|'desc' }
+      def parse_sort(sort)
+        value = sort.to_s.strip
+        return if value.blank?
+
+        attribute = value.delete_prefix('-')
+        definition = entry_for(attribute)
+        return unless definition&.sortable?
+
+        {
+          attribute: attribute,
+          direction: value.start_with?('-') ? 'desc' : 'asc'
+        }
+      end
+
+      # Splits a Ransack-style predicate key (e.g. +cf_custom_label_i_cont+)
+      # into the definition it targets and the predicate. Both search keys and
+      # predicates contain underscores, so predicates are tried longest-first —
+      # otherwise +cf_x_i_cont+ would resolve as key +x_i+ with predicate
+      # +cont+. A key that itself ends in a predicate name (+..._eq_eq+) is
+      # only reachable if the shorter split names a real definition.
+      #
+      # @param key [String, Symbol]
+      # @return [Hash, nil] +{ definition:, predicate: }+
+      def parse_filter(key)
+        value = key.to_s
+        return unless value.start_with?('cf_')
+
+        ORDERED_FILTER_PREDICATES.each do |predicate|
+          next unless value.end_with?("_#{predicate}")
+
+          definition = entries[value.delete_suffix("_#{predicate}")]
+          next unless definition && filter_predicates_for(definition.field_type).include?(predicate)
+
+          return { definition: definition, predicate: predicate }
+        end
+
+        nil
+      end
+
+      # @param field_type [String]
+      # @return [Array<String>]
+      def filter_predicates_for(field_type)
+        field_type == 'number' ? NUMBER_FILTER_PREDICATES : TEXT_FILTER_PREDICATES
+      end
+
+      # Stamp for Store API filters cache keys.
+      #
+      # @return [String]
+      def schema_version
+        @schema_version ||= [
+          entries.size,
+          entries.each_value.filter_map(&:updated_at).max&.utc&.iso8601(6)
+        ].join('-')
+      end
+
+      private
+
+      def product_definitions
+        scope = store.custom_field_definitions.for_resource_type('Spree::Product')
+        scope.where(searchable: true).or(scope.where(sortable: true))
+      end
+
+      def sort_option_label(name, field_type, direction)
+        suffix =
+          if field_type == 'number'
+            direction == :asc ? Spree.t(:sort_low_to_high) : Spree.t(:sort_high_to_low)
+          else
+            direction == :asc ? Spree.t(:sort_a_to_z) : Spree.t(:sort_z_to_a)
+          end
+        "#{name} (#{suffix})"
+      end
+    end
+  end
+end

data/app/services/spree/seeds/admin_user.rb

@@ -1,23 +1,83 @@
 module Spree
   module Seeds
+    # Creates the first admin user — but only when ADMIN_EMAIL and
+    # ADMIN_PASSWORD are both explicitly set (CI, worktrees, scripted
+    # installs). Without them, no dummy account is minted: a one-time setup
+    # token is generated instead and the printed setup URL claims the
+    # installation through the dashboard's first-run screen
+    # (docs/plans/6.0-store-context-and-first-run-setup.md).
     class AdminUser
       prepend Spree::ServiceModule::Base
 
       def call
-        if Spree.admin_user_class.present? && Spree.admin_user_class.count.zero?
-          user = Spree.admin_user_class.create!(
-            email: ENV.fetch('ADMIN_EMAIL', 'spree@example.com'),
-            password: ENV.fetch('ADMIN_PASSWORD', 'spree123'),
-            password_confirmation: ENV.fetch('ADMIN_PASSWORD', 'spree123'),
-            first_name: ENV.fetch('ADMIN_FIRST_NAME', 'Spree'),
-            last_name: ENV.fetch('ADMIN_LAST_NAME', 'Admin')
-          )
-          user.save!
-
-          store = Spree::Store.default
-          store&.add_user(user) if store&.persisted?
+        return if Spree.admin_user_class.blank?
+        return unless Spree.admin_user_class.count.zero?
+
+        if ENV['ADMIN_EMAIL'].present? && ENV['ADMIN_PASSWORD'].present?
+          create_admin_from_env
+        else
+          announce_setup_url
         end
       end
+
+      private
+
+      def create_admin_from_env
+        user = Spree.admin_user_class.create!(
+          email: ENV['ADMIN_EMAIL'],
+          password: ENV['ADMIN_PASSWORD'],
+          password_confirmation: ENV['ADMIN_PASSWORD'],
+          first_name: ENV.fetch('ADMIN_FIRST_NAME', 'Spree'),
+          last_name: ENV.fetch('ADMIN_LAST_NAME', 'Admin')
+        )
+
+        store = Spree::Store.default
+        return unless store&.persisted?
+
+        store.add_user(user)
+        provision_store_defaults(store)
+      end
+
+      # This install never sees the setup screen, so the country question is
+      # answered by the environment instead — defaulting to the US, which is
+      # what these installs got when the seeds hardcoded it.
+      def provision_store_defaults(store)
+        country = Spree::Country.by_iso(ENV.fetch('STORE_COUNTRY', 'US')) || Spree::Country.by_iso('US')
+
+        Spree::Stores::ProvisionDefaults.call(
+          store: store,
+          country: country,
+          locale: ENV['STORE_LOCALE'].presence,
+          currency: ENV['STORE_CURRENCY'].presence
+        )
+      end
+
+      # The setup token lives on the default store (has_secure_token, set at
+      # creation), so a repeated `db:seed` reprints the same URL. Stores
+      # predating the column get one generated here.
+      def announce_setup_url
+        store = Spree::Store.default
+        return if store.nil? || !store.persisted?
+
+        store.regenerate_setup_token if store.setup_token.blank?
+
+        message = <<~MSG
+
+          ==> No admin account yet. Start your app, then open this link to
+              create the first admin account:
+
+              #{store.setup_url}
+
+              (Run `bin/rails spree:setup:token` to print it again.)
+
+        MSG
+
+        # The URL goes to stdout only — the token is a claim-this-installation
+        # credential, and Rails.logger typically feeds a log aggregator with a
+        # far wider audience than the person running the seed.
+        puts message unless Rails.env.test?
+        Rails.logger&.info('No admin account yet — run `bin/rails spree:setup:token` to print the setup link.')
+      end
     end
   end
 end

data/app/services/spree/seeds/all.rb

@@ -6,31 +6,42 @@ module Spree
       def call
         Spree::Events.disable do
           ActiveRecord::Base.no_touching do
-            # GEO
-            Countries.call
-            States.call
-            Zones.call
-
-            # user roles
-            Roles.call
+            # GEO — countries and states are reference data supplied by the
+            # countries gem, and zones are migration-only, so none of them
+            # are seeded.
 
             # additional data
-            ReturnsEnvironment.call
-            ShippingCategories.call
-            StoreCreditCategories.call
             TaxCategories.call
-            DigitalDelivery.call
 
-            # store & stock location
+            # store & channels
             Stores.call
             Channels.call
-            StockLocations.call
+            # Roles are store-owned, so they can only be seeded once a store
+            # exists — every store gets its own immutable admin role.
+            Roles.call
+            # Store-scoped, so it can only run once a store exists.
+            DigitalDelivery.call
+            # The warehouse, delivery zones and pickup are not seeded: their
+            # shape depends on which country the shop sells from, and nobody
+            # has answered that yet. Spree::Stores::ProvisionDefaults builds
+            # them from the merchant's answer — at first-run setup, or here
+            # when ADMIN_EMAIL/ADMIN_PASSWORD name an install that skips it.
             AdminUser.call
 
             # add store resources
             PaymentMethods.call
+            TaxCategories.call
+            ProductTypes.call
             CustomerGroups.call
+            ReturnsEnvironment.call
+            # The marketplace's catch-all rate, at the bottom of the list so
+            # narrower rates added later resolve ahead of it.
+            CommissionRates.call
+            # What a new seller has to do before this marketplace will let
+            # them trade. Runs after stores for the same reason roles do.
+            SellerRequirements.call
             ApiKeys.call
+            SavedReports.call
             AllowedOrigins.call
           end
         end

data/app/services/spree/seeds/commission_rates.rb

@@ -0,0 +1,53 @@
+module Spree
+  module Seeds
+    # The marketplace's own commission rate, at the bottom of the list.
+    #
+    # Only one rate is seeded, and deliberately so. The list is the precedence
+    # — resolution walks it top-down and stops at the first match — so what a
+    # marketplace needs out of the box is a floor that catches everything,
+    # with room above it for the narrower rates an operator adds later.
+    #
+    # That gives the order merchants asked for without hardcoding a ladder:
+    # a new product-, category- or seller-targeted rate is created at the top
+    # of the list (see Spree::CommissionRate), so it lands above this one and
+    # ahead of anything more general already there. Reordering afterwards is
+    # dragging a row.
+    #
+    # Seeding empty placeholder rates for each dimension would be worse than
+    # nothing: a rate with no rules charges every sale, so three of them would
+    # each shadow everything below.
+    #
+    # Disabled on arrival — a marketplace that has not set its terms should
+    # charge nothing rather than a number core invented. Enabling it and
+    # setting the value is the operator's first commission decision.
+    class CommissionRates
+      prepend Spree::ServiceModule::Base
+
+      DEFAULT_CODE = 'marketplace-default'.freeze
+
+      def call
+        Spree::Store.find_each do |store|
+          # Live rows only, matching the partial unique index: an operator who
+          # deleted the seeded fallback gets it back on the next run rather
+          # than being left with no bottom-of-list catch-all forever.
+          next if store.commission_rates.exists?(code: DEFAULT_CODE)
+
+          rate = store.commission_rates.create!(
+            name: Spree.t('seed.commission_rates.marketplace_default'),
+            code: DEFAULT_CODE,
+            kind: 'percentage',
+            value: 0,
+            enabled: false
+          )
+
+          # New rates are born at the top, which is right for one an operator
+          # adds and wrong for this one: it matches every sale, so anywhere but
+          # the bottom leaves the rates below it unreachable. A store seeded
+          # after it already has rates would otherwise have them all shadowed
+          # the moment this was enabled.
+          rate.move_to_bottom
+        end
+      end
+    end
+  end
+end

data/app/services/spree/seeds/digital_delivery.rb

@@ -4,16 +4,26 @@ module Spree
       prepend Spree::ServiceModule::Base
 
       def call
-        digital_shipping_category = Spree::ShippingCategory.find_or_create_by!(name: 'Digital')
-        zones = Spree::Zone.all
+        Spree::Store.all.find_each do |store|
+          create_for(store)
+        end
+      end
+
+      private
+
+      def create_for(store)
+        # Digital goods are a distinct product set, so they get their own
+        # profile; assigning a product to it is what makes it digital.
+        profile = Spree::DeliveryProfiles::Digital.find_by(store: store) ||
+                  Spree::DeliveryProfiles::Digital.create!(store: store, name: I18n.t('spree.seed.delivery_profiles.digital'))
 
-        digital_shipping_method = Spree::ShippingMethod.find_or_initialize_by(name: Spree.t('digital.digital_delivery'))
+        digital_delivery_method = Spree::DeliveryMethod.find_or_initialize_by(name: Spree.t('digital.digital_delivery'), store: store)
 
-        digital_shipping_method.display_on = 'both'
-        digital_shipping_method.shipping_categories = [digital_shipping_category]
-        digital_shipping_method.calculator ||= Spree::Calculator::Shipping::DigitalDelivery.create!
-        digital_shipping_method.zones = zones
-        digital_shipping_method.save!
+        digital_delivery_method.delivery_profile = profile
+        digital_delivery_method.storefront_visible = true
+        digital_delivery_method.fulfillment_provider = 'Spree::FulfillmentProvider::Digital'
+        digital_delivery_method.calculator ||= Spree::Calculator::Shipping::DigitalDelivery.create!
+        digital_delivery_method.save!
       end
     end
   end

data/app/services/spree/seeds/product_types.rb

@@ -0,0 +1,23 @@
+module Spree
+  module Seeds
+    class ProductTypes
+      prepend Spree::ServiceModule::Base
+
+      def call
+        Spree::Store.all.find_each do |store|
+          Spree::ProductType.where(store: store).find_or_create_by!(name: I18n.t('spree.seed.product_types.default'))
+          Spree::ProductType.where(store: store).find_or_create_by!(name: I18n.t('spree.seed.product_types.digital')) do |product_type|
+            product_type.delivery_profile = digital_profile_for(store)
+          end
+        end
+      end
+
+      private
+
+      def digital_profile_for(store)
+        Spree::DeliveryProfiles::Digital.find_by(store: store) ||
+          Spree::DeliveryProfiles::Digital.create!(store: store, name: I18n.t('spree.seed.delivery_profiles.digital'))
+      end
+    end
+  end
+end

data/app/services/spree/seeds/returns_environment.rb

@@ -3,24 +3,52 @@ module Spree
     class ReturnsEnvironment
       prepend Spree::ServiceModule::Base
 
+      RETURN_REASONS = [
+        'Better price available',
+        'Missed estimated delivery date',
+        'Missing parts or accessories',
+        'Damaged/Defective',
+        'Different from what was ordered',
+        'Different from description',
+        'No longer needed/wanted',
+        'Accidental order',
+        'Unauthorized purchase'
+      ].freeze
+
+      # Why an order was called off before it shipped — a different question
+      # from why goods came back; see Spree::OrderCancellationReason.
+      ORDER_CANCELLATION_REASONS = [
+        'Customer changed their mind',
+        'Payment declined',
+        'Suspected fraud',
+        'Out of stock',
+        'Duplicate order',
+        'Staff error',
+        'Order expired'
+      ].freeze
+
+      # Why the merchant got it wrong, rather than why the customer changed
+      # their mind — see Spree::ClaimReason.
+      CLAIM_REASONS = [
+        'Arrived damaged',
+        'Never arrived',
+        'Wrong item sent',
+        'Missing item from order',
+        'Item not as described'
+      ].freeze
+
       def call
-        Spree::RefundReason.find_or_create_by!(name: 'Return processing', mutable: false)
-        [
-          'Better price available',
-          'Missed estimated delivery date',
-          'Missing parts or accessories',
-          'Damaged/Defective',
-          'Different from what was ordered',
-          'Different from description',
-          'No longer needed/wanted',
-          'Accidental order',
-          'Unauthorized purchase',
-        ].each do |name|
-          Spree::ReturnAuthorizationReason.find_or_create_by!(name: name)
+        # Every vocabulary is store-owned, so every store gets its own.
+        Spree::Store.all.find_each do |store|
+          # Through the model helper, not a literal — the workflows look this
+          # row up by the same constant, so a hard-coded string here would
+          # silently create a second, unfindable reason if the name ever moves.
+          Spree::RefundReason.return_processing_reason(store)
+
+          RETURN_REASONS.each { |name| Spree::ReturnReason.where(store: store).find_or_create_by!(name: name) }
+          CLAIM_REASONS.each { |name| Spree::ClaimReason.where(store: store).find_or_create_by!(name: name) }
+          ORDER_CANCELLATION_REASONS.each { |name| Spree::OrderCancellationReason.where(store: store).find_or_create_by!(name: name) }
         end
-        Spree::ReimbursementType.find_or_create_by!(name: 'Store Credit', type: 'Spree::ReimbursementType::StoreCredit')
-        Spree::ReimbursementType.find_or_create_by!(name: 'Exchange', type: 'Spree::ReimbursementType::Exchange')
-        Spree::ReimbursementType.find_or_create_by!(name: 'Original payment', type: 'Spree::ReimbursementType::OriginalPayment')
       end
     end
   end

data/app/services/spree/seeds/roles.rb

@@ -3,8 +3,13 @@ module Spree
     class Roles
       prepend Spree::ServiceModule::Base
 
+      # A role belongs to what it governs, so every store gets its own
+      # immutable admin.
       def call
-        Spree::Role.where(name: 'admin').first_or_create!
+        Spree::Store.find_each do |store|
+          admin = Spree::Role.default_admin_role(store)
+          admin.update_column(:mutable, false) if admin.read_attribute(:mutable)
+        end
       end
     end
   end