spree_core 5.5.2 → 5.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c50d137ef2f51b5fbdb5c343c360d805fe8839978386c08902ff3f29873c7e56
-  data.tar.gz: f495c858e04f2c469323c744c5bcdff4c3d23891b85771f44082dc104922de21
+  metadata.gz: 2edebb88f8cab59b634a4bbbae5a24b15feab2d7673ecd521d70a1265b4e7bd0
+  data.tar.gz: 1fa56dfbe5ebd747212b1608490c5414246cfad12e721f49d040c97f8299ef33
 SHA512:
-  metadata.gz: 96e1c8a7b981d143e5aab043ce6d236cd55627ddc28f1e29e573c873440e7515787e0f64f016409b54001c4313eca64b9f71f9f4641ddf3e021741c80300717d
-  data.tar.gz: 6810ea91184c9646922ba3dba4973fd337dfc4068513ead2cc3d198bb5f316798f4f1810eb51b08b50381eecb8603c378d56c3ef5b162c38f6d0f1cb62caf519
+  metadata.gz: 20f0b006c40c37d8e8cbf25d97b99a73e9f3ce72d6a4903f6238aec8cad435f45c1f6517cfb54356732f7c0f69910e1013f45b7a344bc29506c888521661f46a
+  data.tar.gz: c72003a7f9002a1443ef60fa19f70fe6aa4e4acf9f466012101889bd964c7aaf806d9f136fe158453c751d4f11dee74f4c42b9c9e1d39ec82b3994a5293337ee

data/app/jobs/spree/imports/process_group_job.rb

@@ -1,6 +1,10 @@
 module Spree
   module Imports
     class ProcessGroupJob < Spree::Imports::BaseJob
+      # Rows are loaded in slices so a large group never holds every ImportRow
+      # (and its raw CSV data) in memory for the whole job.
+      ROWS_BATCH_SIZE = 100
+
       def perform(import_id, row_ids)
         import = Spree::Import.find(import_id)
         Spree::Current.store = import.store
@@ -8,16 +12,23 @@ module Spree
         mappings = import.mappings.mapped.to_a
         schema_fields = import.schema_fields
         large = import.large_import?
-        # Skip rows already completed on a prior attempt so retries don't double-process them.
-        rows = import.rows.where(id: row_ids).pending_and_failed.order(:row_number)
 
-        if large
-          Spree::Events.disable do
-            rows.each { |row| row.bulk_process!(mappings: mappings, schema_fields: schema_fields) }
-          end
-        else
-          rows.each do |row|
-            row.process!(mappings: mappings, schema_fields: schema_fields)
+        row_ids.each_slice(ROWS_BATCH_SIZE) do |ids|
+          # Skip rows already completed on a prior attempt so retries don't double-process them.
+          rows = import.rows.where(id: ids).pending_and_failed.order(:row_number).to_a
+          # Share the already-loaded import across rows: each row's processor reads
+          # `row.import` (store, ability, lookup cache), and without this every row
+          # lazily loads its own Import instance and rebuilds all of that per row.
+          rows.each { |row| row.association(:import).target = import }
+
+          if large
+            Spree::Events.disable do
+              rows.each { |row| row.bulk_process!(mappings: mappings, schema_fields: schema_fields) }
+            end
+          else
+            rows.each do |row|
+              row.process!(mappings: mappings, schema_fields: schema_fields)
+            end
           end
         end
 

data/app/jobs/spree/imports/process_rows_job.rb

@@ -2,6 +2,7 @@ module Spree
   module Imports
     class ProcessRowsJob < Spree::Imports::BaseJob
       BATCH_SIZE = 100
+      UNGROUPED_KEY = '__ungrouped__'.freeze
 
       def perform(import_id)
         import = Spree::Import.find(import_id)
@@ -27,20 +28,27 @@ module Spree
 
         import.rows.pending_and_failed.order(:row_number).pluck(:id, :data).each do |id, data|
           parsed = JSON.parse(data)
-          key = parsed[file_column].to_s.strip.downcase.presence || '__ungrouped__'
+          key = parsed[file_column].to_s.strip.downcase.presence || UNGROUPED_KEY
           groups[key] << id
         rescue JSON::ParserError
-          groups['__ungrouped__'] << id
+          groups[UNGROUPED_KEY] << id
         end
 
+        # Rows without a group value don't depend on each other, so they don't have
+        # to share a single job — split them into bounded batches. Real groups stay
+        # intact: their rows must run sequentially (product row before variant rows).
+        ungrouped = groups.delete(UNGROUPED_KEY)
+        batches = groups.values
+        ungrouped&.each_slice(BATCH_SIZE) { |row_ids| batches << row_ids }
+
         # Set count before enqueuing so workers can't complete prematurely
         import.update_columns(
-          processing_groups_count: groups.size,
+          processing_groups_count: batches.size,
           completed_groups_count: 0,
           updated_at: Time.current
         )
 
-        groups.each_value { |row_ids| ProcessGroupJob.perform_later(import.id, row_ids) }
+        batches.each { |row_ids| ProcessGroupJob.perform_later(import.id, row_ids) }
       end
 
       def dispatch_batched(import)

data/app/models/spree/import.rb

@@ -245,6 +245,15 @@ module Spree
       @current_ability ||= Spree.ability_class.new(user, { store: store })
     end
 
+    # Per-instance cache shared by row processors within a single processing job.
+    # Group jobs funnel every row through the same Import instance, so lookups of
+    # shared records (tax/shipping categories, option types, metafield definitions)
+    # resolve once per job instead of once per row.
+    # @return [Hash]
+    def row_lookup_cache
+      @row_lookup_cache ||= {}
+    end
+
     def event_serializer_class
       'Spree::Api::V3::ImportSerializer'.safe_constantize
     end

data/app/services/spree/imports/row_processors/base.rb

@@ -20,6 +20,15 @@ module Spree
 
         private
 
+        # Memoizes a shared-record lookup (including nil misses) in the import's
+        # per-job cache so repeated rows don't re-run the same query.
+        def cached_lookup(*key)
+          cache = import.row_lookup_cache
+          return cache[key] if cache.key?(key)
+
+          cache[key] = yield
+        end
+
         def build_schema_hash(row, mappings, schema_fields)
           attributes = {}
           schema_fields.each do |field|

data/app/services/spree/imports/row_processors/product_variant.rb

@@ -123,12 +123,16 @@ module Spree
 
         def prepare_shipping_category
           shipping_category_name = attributes['shipping_category'].strip
-          Spree::ShippingCategory.find_by(name: shipping_category_name)
+          cached_lookup(:shipping_category, shipping_category_name) do
+            Spree::ShippingCategory.find_by(name: shipping_category_name)
+          end
         end
 
         def prepare_tax_category
           tax_category_name = attributes['tax_category'].strip
-          Spree::TaxCategory.find_by(name: tax_category_name)
+          cached_lookup(:tax_category, tax_category_name) do
+            Spree::TaxCategory.find_by(name: tax_category_name)
+          end
         end
 
         def prepare_option_value_variants
@@ -171,27 +175,39 @@ module Spree
         # surfaces via the DB unique index (RecordNotUnique) or the AR uniqueness
         # validator (RecordInvalid with a :taken error on the relevant attribute).
         def find_or_create_option_type!(presentation)
-          Spree::OptionType.search_by_name(presentation).first || Spree::OptionType.create!(presentation: presentation)
-        rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => e
-          raise unless uniqueness_conflict?(e, :name)
+          cached_lookup(:option_type, presentation) do
+            begin
+              Spree::OptionType.search_by_name(presentation).first || Spree::OptionType.create!(presentation: presentation)
+            rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => e
+              raise unless uniqueness_conflict?(e, :name)
 
-          Spree::OptionType.search_by_name(presentation).first!
+              Spree::OptionType.search_by_name(presentation).first!
+            end
+          end
         end
 
         def find_or_create_option_value!(option_type, presentation)
-          option_type.option_values.search_by_name(presentation).first || option_type.option_values.create!(presentation: presentation)
-        rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => e
-          raise unless uniqueness_conflict?(e, :name)
+          cached_lookup(:option_value, option_type.id, presentation) do
+            begin
+              option_type.option_values.search_by_name(presentation).first || option_type.option_values.create!(presentation: presentation)
+            rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => e
+              raise unless uniqueness_conflict?(e, :name)
 
-          option_type.option_values.search_by_name(presentation).first!
+              option_type.option_values.search_by_name(presentation).first!
+            end
+          end
         end
 
         def find_or_create_product_option_type!(option_type)
-          Spree::ProductOptionType.find_or_create_by!(product: product, option_type: option_type)
-        rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => e
-          raise unless uniqueness_conflict?(e, :product_id)
+          cached_lookup(:product_option_type, product.id, option_type.id) do
+            begin
+              Spree::ProductOptionType.find_or_create_by!(product: product, option_type: option_type)
+            rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid => e
+              raise unless uniqueness_conflict?(e, :product_id)
 
-          Spree::ProductOptionType.find_by!(product: product, option_type: option_type)
+              Spree::ProductOptionType.find_by!(product: product, option_type: option_type)
+            end
+          end
         end
 
         # RecordNotUnique is always a uniqueness conflict; RecordInvalid only when the
@@ -245,11 +261,13 @@ module Spree
             namespace, key = product.extract_namespace_and_key(full_key)
 
             # Find or initialize metafield definition
-            metafield_definition = Spree::MetafieldDefinition.find_by(
-              namespace: namespace,
-              key: key,
-              resource_type: product.class.name
-            )
+            metafield_definition = cached_lookup(:metafield_definition, namespace, key, product.class.name) do
+              Spree::MetafieldDefinition.find_by(
+                namespace: namespace,
+                key: key,
+                resource_type: product.class.name
+              )
+            end
 
             next unless metafield_definition
 

data/lib/spree/core/version.rb

@@ -1,5 +1,5 @@
 module Spree
-  VERSION = '5.5.2'.freeze
+  VERSION = '5.5.3'.freeze
 
   def self.version
     VERSION

data/lib/spree/permitted_attributes.rb

@@ -256,7 +256,7 @@ module Spree
     @@stock_item_attributes = [:variant_id, :stock_location_id, :backorderable, :count_on_hand, { metadata: {} }]
 
     @@stock_location_attributes = [
-      :name, :active, :address1, :address2, :city, :zipcode, :company,
+      :name, :admin_name, :active, :address1, :address2, :city, :zipcode, :company,
       :backorderable_default, :state_name, :state_id, :country_id, :phone,
       :propagate_all_variants
     ]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spree_core
 version: !ruby/object:Gem::Version
-  version: 5.5.2
+  version: 5.5.3
 platform: ruby
 authors:
 - Sean Schofield
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-06 00:00:00.000000000 Z
+date: 2026-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n-tasks
@@ -1818,9 +1818,9 @@ licenses:
 - BSD-3-Clause
 metadata:
   bug_tracker_uri: https://github.com/spree/spree/issues
-  changelog_uri: https://github.com/spree/spree/releases/tag/v5.5.2
+  changelog_uri: https://github.com/spree/spree/releases/tag/v5.5.3
   documentation_uri: https://docs.spreecommerce.org/
-  source_code_uri: https://github.com/spree/spree/tree/v5.5.2
+  source_code_uri: https://github.com/spree/spree/tree/v5.5.3
 post_install_message:
 rdoc_options: []
 require_paths: