spree_core 5.1.8 → 5.2.0.rc1

data/db/migrate/20250730102644_add_missing_unique_indexes_to_spree_option_types_and_values.rb

@@ -0,0 +1,40 @@
+class AddMissingUniqueIndexesToSpreeOptionTypesAndValues < ActiveRecord::Migration[7.2]
+  def change
+    # we don't need to run this migration in multi-tenant mode as it's already handled there
+    return if defined?(SpreeMultiTenant)
+
+    # Rename duplicated option types
+    duplicates = Spree::OptionType.select(:name).group(:name).having('COUNT(*) > 1').reorder('').pluck(:name)
+
+    duplicates.each do |duplicate_name|
+      option_types = Spree::OptionType.where(name: duplicate_name)
+
+      option_types.each_with_index do |option_type, index|
+        next if index == 0 # Keep the first one unchanged
+
+        new_name = "#{duplicate_name}_#{index}"
+        option_type.update_columns(name: new_name, updated_at: Time.current)
+      end
+    end
+
+    # Handle duplicates in spree_option_values
+    duplicates = Spree::OptionValue.select(:option_type_id, :name).group(:option_type_id, :name).having('COUNT(*) > 1').reorder('')
+
+    duplicates.each do |dup|
+      option_values = Spree::OptionValue.where(option_type_id: dup.option_type_id, name: dup.name)
+
+      option_values.each_with_index do |option_value, index|
+        next if index == 0 # Keep the first one unchanged
+
+        new_name = "#{option_value.name}_#{index}"
+        option_value.update_columns(name: new_name, updated_at: Time.current)
+      end
+    end
+
+    # Add indexes
+    remove_index :spree_option_types, :name, if_exists: true
+    add_index :spree_option_types, :name, unique: true, if_not_exists: true
+
+    add_index :spree_option_values, %i[option_type_id name], unique: true, if_not_exists: true
+  end
+end

data/db/migrate/20250730154601_add_unique_index_on_spree_properties_name.rb

@@ -0,0 +1,24 @@
+class AddUniqueIndexOnSpreePropertiesName < ActiveRecord::Migration[7.2]
+  def change
+    # we don't need to run this migration in multi-tenant mode as it's already handled there
+    return if defined?(SpreeMultiTenant)
+
+    # Rename duplicated properties
+    duplicates = Spree::Property.select(:name).group(:name).having('COUNT(*) > 1').reorder('').pluck(:name)
+
+    duplicates.each do |duplicate_name|
+      properties = Spree::Property.where(name: duplicate_name)
+
+      properties.each_with_index do |property, index|
+        next if index == 0 # Keep the first one unchanged
+
+        new_name = "#{duplicate_name}_#{index}"
+        property.update_columns(name: new_name, updated_at: Time.current)
+      end
+    end
+
+    # Add indexes
+    remove_index :spree_properties, :name, if_exists: true
+    add_index :spree_properties, :name, unique: true, if_not_exists: true
+  end
+end

data/db/migrate/20250811112056_create_spree_policies.rb

@@ -0,0 +1,22 @@
+class CreateSpreePolicies < ActiveRecord::Migration[7.2]
+  def change
+    create_table :spree_policies do |t|
+      t.belongs_to :store, null: false
+      t.string :slug, null: false
+      t.string :name, null: false
+
+      t.timestamps
+    end
+
+    add_index :spree_policies, [:store_id, :slug], unique: true
+    create_table :spree_policy_translations do |t|
+      t.string :locale, null: false
+      t.string :name
+      t.references :spree_policy, null: false
+
+      t.timestamps
+    end
+
+    add_index :spree_policy_translations, [:spree_policy_id, :locale], unique: true
+  end
+end

data/db/migrate/20250821211705_fix_unique_index_on_spree_order_promotions.rb

@@ -0,0 +1,20 @@
+class FixUniqueIndexOnSpreeOrderPromotions < ActiveRecord::Migration[7.2]
+  def change
+    remove_index :spree_order_promotions, name: 'index_spree_order_promotions_on_promotion_id_and_order_id', if_exists: true
+
+    # Remove duplicate records before adding unique index
+    duplicates = Spree::OrderPromotion.select(:promotion_id, :order_id).group(:promotion_id, :order_id).having('COUNT(*) > 1').reorder('').pluck(:promotion_id, :order_id)
+
+    duplicates.each do |duplicate_promotion_id, duplicate_order_id|
+      order_promotions = Spree::OrderPromotion.where(promotion_id: duplicate_promotion_id, order_id: duplicate_order_id)
+
+      order_promotions.each_with_index do |order_promotion, index|
+        next if index == 0 # Keep the first one unchanged
+
+        order_promotion.destroy
+      end
+    end
+
+    add_index :spree_order_promotions, [:promotion_id, :order_id], unique: true, name: 'index_spree_order_promotions_on_promotion_id_and_order_id'
+  end
+end

data/db/migrate/20250825175217_add_missing_page_builder_indexes.rb

@@ -0,0 +1,7 @@
+class AddMissingPageBuilderIndexes < ActiveRecord::Migration[7.2]
+  def change
+    add_index :spree_themes, %w[store_id default], name: 'index_spree_themes_on_store_id_and_default', if_not_exists: true
+    add_index :spree_page_links, %w[parent_type parent_id position], name: 'index_spree_page_links_parent_with_position', if_not_exists: true
+    add_index :spree_page_blocks, :deleted_at, if_not_exists: true
+  end
+end

data/db/migrate/20250826093602_create_spree_newsletter_subscribers.rb

@@ -0,0 +1,12 @@
+class CreateSpreeNewsletterSubscribers < ActiveRecord::Migration[7.2]
+  def change
+    create_table :spree_newsletter_subscribers do |t|
+      t.string :email, index: { unique: true }, null: false
+      t.references :user, index: true
+      t.datetime :verified_at, index: true
+      t.string :verification_token, index: { unique: true }
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20250902143122_fix_policies_store_association.rb

@@ -0,0 +1,18 @@
+class FixPoliciesStoreAssociation < ActiveRecord::Migration[7.2]
+  def change
+    add_reference :spree_policies, :owner, polymorphic: true, index: true
+
+    Spree::Policy.reset_column_information
+    Spree::Policy.all.each do |policy|
+      policy.update(owner_id: policy.store_id, owner_type: 'Spree::Store')
+    end
+
+    remove_index :spree_policies, [:store_id, :slug], unique: true, if_exists: true
+    remove_index :spree_policies, [:store_id, :position], if_exists: true
+    remove_column :spree_policies, :store_id, if_exists: true
+    remove_column :spree_policies, :show_in_checkout_footer, if_exists: true
+    remove_column :spree_policies, :position, if_exists: true
+
+    add_index :spree_policies, [:owner_id, :owner_type, :slug], unique: true
+  end
+end

data/db/migrate/20250911205659_add_missing_index_on_spree_products_promotionable.rb

@@ -0,0 +1,5 @@
+class AddMissingIndexOnSpreeProductsPromotionable < ActiveRecord::Migration[7.2]
+  def change
+    add_index :spree_products, :promotionable, if_not_exists: true
+  end
+end

data/db/migrate/20250913130044_add_page_links_counter_cache_to_spree_stores.rb

@@ -0,0 +1,10 @@
+class AddPageLinksCounterCacheToSpreeStores < ActiveRecord::Migration[7.2]
+  def change
+    add_column :spree_stores, :page_links_count, :integer, default: 0, null: false
+
+    Spree::Store.reset_column_information
+    Spree::Store.find_each do |store|
+      Spree::Store.reset_counters(store.id, :links)
+    end
+  end
+end

data/db/migrate/20250914101955_add_missing_indexes_on_spree_adjustments.rb

@@ -0,0 +1,6 @@
+class AddMissingIndexesOnSpreeAdjustments < ActiveRecord::Migration[7.2]
+  def change
+    add_index :spree_adjustments, :source_type, if_not_exists: true
+    add_index :spree_adjustments, :amount, if_not_exists: true
+  end
+end

data/db/migrate/20250915093930_add_metadata_to_spree_newsletter_subscribers.rb

@@ -0,0 +1,20 @@
+class AddMetadataToSpreeNewsletterSubscribers < ActiveRecord::Migration[7.2]
+  def up
+    change_table :spree_newsletter_subscribers do |t|
+      if t.respond_to? :jsonb
+        t.jsonb :public_metadata
+        t.jsonb :private_metadata
+      else
+        t.json :public_metadata
+        t.json :private_metadata
+      end
+    end
+  end
+
+  def down
+    change_table :spree_newsletter_subscribers do |t|
+      t.remove :public_metadata
+      t.remove :private_metadata
+    end
+  end
+end

data/db/migrate/20250923141845_create_spree_imports.rb

@@ -0,0 +1,47 @@
+class CreateSpreeImports < ActiveRecord::Migration[7.2]
+  def change
+    create_table :spree_imports do |t|
+      t.belongs_to :user, null: false
+      t.belongs_to :owner, polymorphic: true, null: false
+
+      t.string :status, null: false, index: true
+
+      t.string :number, limit: 32, null: false, index: { unique: true }
+      t.string :type, null: false, index: true
+
+      t.text :processing_errors
+
+      t.text :preferences
+
+      t.integer :rows_count, null: false, default: 0
+
+      t.timestamps
+    end
+
+    create_table :spree_import_rows do |t|
+      t.belongs_to :import, null: false
+      t.belongs_to :item, polymorphic: true
+
+      t.string :status, null: false, index: true
+      t.integer :row_number, null: false
+
+      t.text :data, null: false
+      t.text :validation_errors
+
+      t.timestamps
+    end
+
+    add_index :spree_import_rows, [:import_id, :row_number], unique: true
+
+    create_table :spree_import_mappings do |t|
+      t.belongs_to :import, null: false
+
+      t.string :schema_field, null: false
+      t.string :file_column, index: true
+
+      t.timestamps
+    end
+
+    add_index :spree_import_mappings, [:import_id, :schema_field], unique: true
+  end
+end

data/lib/generators/spree/cursor_rules/cursor_rules_generator.rb

@@ -0,0 +1,19 @@
+module Spree
+  class CursorRulesGenerator < Rails::Generators::Base
+    desc 'Set up Cursor Rules - copies all Spree cursor rules to .cursor/rules directory'
+
+    def self.source_paths
+      paths = superclass.source_paths
+      paths << File.expand_path('templates', __dir__)
+      paths.flatten
+    end
+
+    def create_cursor_rules_directory
+      empty_directory '.cursor/rules'
+    end
+
+    def copy_cursor_rules
+      copy_file 'spree_rules.mdc', '.cursor/rules/spree_rules.mdc'
+    end
+  end
+end

data/lib/generators/spree/cursor_rules/templates/spree_rules.mdc

@@ -0,0 +1,387 @@
+---
+alwaysApply: true
+---
+
+# Cursor Rules for Spree Commerce Development
+
+## General Development Guidelines
+
+### Framework & Architecture
+
+- Spree is built on Ruby on Rails and follows MVC architecture
+- All Spree code must be namespaced under `Spree::` module
+- Spree is distributed as Rails engines with separate gems (core, admin, api, storefront, emails, etc.)
+- Follow Rails conventions and the Rails Security Guide
+- Prefer Rails idioms and standard patterns over custom solutions
+
+### Code Organization
+
+- Place all models in `app/models/spree/` directory
+- Place all controllers in `app/controllers/spree/` directory  
+- Place all views in `app/views/spree/` directory
+- Place all services in `app/services/spree/` directory
+- Place all mailers in `app/mailers/spree/` directory
+- Place all API serializers in `app/serializers/spree/` directory
+- Place all helpers in `app/helpers/spree/` directory
+- Place all jobs in `app/jobs/spree/` directory
+- Place all presenters in `app/presenters/spree/` directory
+- Use consistent file naming: `spree/product.rb` for `Spree::Product` class
+- Group related functionality into concerns when appropriate
+- Do not call `Spree::User` directly, use `Spree.user_class` instead
+- Do not call `Spree::AdminUser` directly, use `Spree.admin_user_class` instead
+
+## Naming Conventions & Structure
+
+### Classes & Modules
+
+```ruby
+# ✅ Correct naming
+module Spree
+  class Product < Spree.base_class
+  end
+end
+
+module Spree
+  module Admin
+    class ProductsController < ResourceController
+    end
+  end
+end
+
+# ❌ Incorrect - missing namespace
+class Product < ApplicationRecord
+end
+```
+
+Always inherit from `Spree.base_class` when creating models.
+
+### File Paths
+
+- Models: `app/models/spree/product.rb`
+- Controllers: `app/controllers/spree/admin/products_controller.rb`
+- Views: `app/views/spree/admin/products/`
+- Decorators: `app/models/spree/product_decorator.rb`
+
+## Model Development
+
+### Model Patterns
+
+- Use ActiveRecord associations appropriately, always pass `class_name` and `dependent` options
+- Implement concerns for shared functionality
+- Use scopes for reusable query patterns
+- Include `Spree::Metafields` concern for models that need metadata support
+
+```ruby
+# ✅ Good model structure
+class Spree::Product < Spree.base_class
+  include Spree::Metafields
+  
+  has_many :variants, class_name: 'Spree::Variant', dependent: :destroy
+  has_many :product_properties, class_name: 'Spree::ProductProperty', dependent: :destroy
+  has_many :properties, through: :product_properties, source: :property
+  
+  scope :available, -> { where(available_on: ..Time.current) }
+  
+  validates :name, presence: true
+  validates :slug, presence: true, uniqueness: { scope: spree_base_uniqueness_scope }
+end
+```
+
+For uniqueness validation, always use `scope: spree_base_uniqueness_scope`
+
+## Controller Development
+
+### Controller Inheritance
+
+- Admin controllers inherit from `Spree::Admin::ResourceController` which handles most of CRUD operations
+- API controllers inherit from `Spree::Api::V2::BaseController`
+- Storefront controllers inherit from `Spree::StoreController`
+
+### Parameter Handling
+
+- Always use strong parameters
+
+```ruby
+# ✅ Proper parameter handling
+def permitted_product_params
+  params.require(:product).permit(:name, :description, :price)
+end
+```
+
+## Customization & Extensions
+
+### Spree::Dependencies System (Preferred Method)
+
+Dependencies allow you to replace parts of Spree core with custom implementations. This is the preferred method for customization.
+
+#### Global Customization
+
+In `config/initializers/spree.rb`:
+
+```ruby
+# Single service replacement
+Spree::Dependencies.cart_add_item_service = 'MyAddToCartService'
+
+# Or using block syntax
+Spree.dependencies do |dependencies|
+  dependencies.cart_add_item_service = 'MyAddToCartService'
+  dependencies.checkout_complete_service = 'MyCheckoutCompleteService'
+end
+```
+
+#### API Level Customization
+
+```ruby
+# Storefront API specific
+Spree::Api::Dependencies.storefront_cart_serializer = 'MyCartSerializer'
+Spree::Api::Dependencies.storefront_cart_add_item_service = 'MyAddToCartService'
+
+# Platform API specific
+Spree::Api::Dependencies.platform_product_serializer = 'MyProductSerializer'
+```
+
+#### Service Implementation
+
+```ruby
+# ✅ Proper service inheritance
+class MyAddToCartService < Spree::Cart::AddItem
+  def call(order:, variant:, quantity: nil, public_metadata: {}, private_metadata: {}, options: {})
+    ApplicationRecord.transaction do
+      run :add_to_line_item
+      run Spree::Dependencies.cart_recalculate_service.constantize
+      run :update_external_system
+    end
+  end
+
+  private
+
+  def update_external_system(result)
+    # Custom logic here
+  end
+end
+```
+
+#### Available Injection Points
+
+Common dependencies you can override:
+- Cart services: `cart_add_item_service`, `cart_update_service`, `cart_remove_item_service`
+- Checkout services: `checkout_next_service`, `checkout_complete_service`
+- Order services: `order_approve_service`, `order_cancel_service`
+- Payment services: `payment_create_service`, `payment_process_service`
+- Ability classes: `ability_class`
+- Serializers: Various API serializers for different endpoints
+
+### Decorators (Use Sparingly)
+
+Decorators should be a last resort - they make upgrades difficult. Use `Module.prepend` pattern for decorators.
+
+#### Model Decorators
+
+```ruby
+# ✅ Proper decorator structure
+module Spree
+  module ProductDecorator
+    def self.prepended(base)
+      base.has_many :videos, class_name: 'Spree::Video', dependent: :destroy
+      base.before_validation :strip_whitespaces
+    end
+
+    def custom_name
+      name.upcase
+    end
+
+    private
+
+    def strip_whitespaces
+      self.name = name.strip if name.present?
+    end
+  end
+
+  Product.prepend(ProductDecorator)
+end
+```
+
+#### Controller Decorators
+
+```ruby
+# ✅ Controller decorator with dependency injection
+module Spree
+  module Admin
+    module ProductsControllerDecorator
+      def self.prepended(base)
+        base.before_action :load_custom_data, only: [:show, :edit]
+      end
+
+      def custom_action
+        # Custom action implementation
+      end
+
+      private
+
+      def load_custom_data
+        @custom_data = fetch_custom_data
+      end
+    end
+
+    ProductsController.prepend(ProductsControllerDecorator)
+  end
+end
+```
+
+### View Customization
+
+#### Admin Panel Injection Points
+
+Use partial injection for admin customization:
+
+```ruby
+# In config/initializers/spree.rb
+Rails.application.config.spree_admin.head_partials << 'spree/admin/shared/custom_head'
+Rails.application.config.spree_admin.body_end_partials << 'spree/admin/shared/custom_footer'
+```
+
+Available injection points:
+- `head_partials` - Injects into `<head>` tag
+- `body_start_partials` - Injects at start of `<body>`
+- `body_end_partials` - Injects at end of `<body>`
+
+#### Storefront Themes
+
+Create custom themes for storefront customization:
+
+```bash
+bin/rails g spree:storefront:theme MyTheme
+```
+
+```ruby
+# Register theme in config/initializers/spree.rb
+Rails.application.config.spree.themes << Spree::Themes::MyTheme
+```
+
+#### View Overrides
+
+Override specific views by creating files in your app:
+
+```
+app/views/themes/my_theme/spree/products/index.html.erb
+```
+
+Do not override views for admin, only for storefront. Avoid overriding any views for Checkout or Cart.
+
+### Authentication Integration
+
+```ruby
+# In config/initializers/spree.rb
+Spree.user_class = 'User'
+Spree.admin_user_class = 'AdminUser'
+
+# Custom authentication
+Rails.application.config.to_prepare do
+  Spree::ApplicationController.include MyAuthenticationModule
+end
+```
+
+## Testing Guidelines
+
+### Test Structure
+
+- Use RSpec for testing
+- Place specs in `spec/` directory following Rails conventions
+- Use Spree's testing helpers and factories
+
+```ruby
+# ✅ Proper test structure
+require 'spec_helper'
+
+RSpec.describe Spree::Product, type: :model do
+  let(:product) { create(:product) }
+  
+  describe '#available?' do
+    it 'returns true when product is available' do
+      expect(product.available?).to be true
+    end
+  end
+end
+```
+
+### Factory Usage
+
+```ruby
+# Use Spree factories
+create(:product, name: 'Test Product')
+create(:order_with_line_items)
+create(:user)
+```
+
+## Performance & Security
+
+### Database Queries
+
+- Use includes/joins to avoid N+1 queries
+- Add database indexes for frequently queried fields
+- Use counter caches for associations that are counted frequently
+
+### Security
+
+- Always use strong parameters in controllers
+- Sanitize user input
+- Use Spree's built-in authorization system (CanCanCan)
+- Validate file uploads and restrict file types
+
+## Common Patterns
+
+### Service Objects
+
+```ruby
+# ✅ Spree service pattern
+module Spree
+  class MyCustomService
+    prepend Spree::ServiceModule::Base
+
+    def call(param1:, param2: nil)
+      # Service logic here
+      success(result_data)
+    rescue StandardError => e
+      failure(e.message)
+    end
+  end
+end
+```
+
+### API Development
+
+```ruby
+# ✅ Custom API endpoint
+module Spree
+  module Api
+    module V2
+      class CustomController < Spree::Api::V2::BaseController
+        def index
+          render json: serialized_collection
+        end
+
+        private
+
+        def serialized_collection
+          Spree::Api::Dependencies.storefront_product_serializer.constantize.new(
+            collection,
+            include: resource_includes,
+            fields: sparse_fields
+          ).serializable_hash
+        end
+      end
+    end
+  end
+end
+```
+
+## Avoid These Patterns
+
+❌ Direct inheritance from Rails classes without Spree namespace
+❌ Monkey patching without using decorators or dependencies
+❌ Hard-coding configuration values
+❌ Direct SQL queries without using ActiveRecord
+❌ Creating models outside Spree namespace when extending core functionality
+❌ Using class_eval decorators (use Module.prepend instead)
+❌ Overriding entire view files when partial injection would work
+❌ Modifying core Spree files directly

data/lib/generators/spree/dummy/dummy_generator.rb

@@ -38,7 +38,6 @@ module Spree
       opts[:skip_spring] = true
       opts[:skip_test] = true
       opts[:skip_bootsnap] = true
-      opts[:skip_asset_pipeline] = true # skip installing propshaft, we're still using sprockets as a dependency
       opts[:skip_docker] = true
       opts[:skip_rubocop] = true
       opts[:skip_brakeman] = true

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

@@ -29,6 +29,11 @@ end
 # Default is nil and your application host will be used
 # Spree.cdn_host = 'cdn.example.com'
 
+# Multi-store setup
+# You need to set a wildcard `root_domain` on the store to enable multi-store setup
+# all new stores will be created in a subdomain of the root domain, eg. store1.lvh.me, store2.lvh.me, etc.
+# Spree.root_domain = ENV.fetch('SPREE_ROOT_DOMAIN', 'lvh.me')
+
 # Use a different service for storage (S3, google, etc)
 # unless Rails.env.test?
 #   Spree.private_storage_service_name = :amazon_public # public assets, such as product images

data/lib/spree/core/configuration.rb

@@ -50,6 +50,7 @@ module Spree
       preference :mailer_logo, :string, deprecated: true
       preference :max_level_in_taxons_menu, :integer, deprecated: true
       preference :non_expiring_credit_types, :array, default: []
+      preference :product_properties_enabled, :boolean, default: false # enable legacy product properties
       preference :products_per_page, :integer, default: 12
       preference :require_master_price, :boolean, default: false
       preference :restock_inventory, :boolean, default: true # Determines if a return item is restocked automatically once it has been received