spree_core 5.4.0.beta → 5.4.0.beta3

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

@@ -1,387 +0,0 @@
----
-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.cart_recalculate_service
-      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
-Spree.page_builder.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.storefront_product_serializer.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/spree/core/controller_helpers/search.rb

@@ -1,17 +0,0 @@
-module Spree
-  module Core
-    module ControllerHelpers
-      module Search
-        def build_searcher(params)
-          Spree::Deprecation.warn("Spree::Core::ControllerHelpers::Search is deprecated and will be removed in Spree 5.5.")
-
-          Spree.searcher_class.new(params).tap do |searcher|
-            searcher.current_user = try_spree_current_user
-            searcher.current_currency = current_currency&.upcase
-            searcher.current_store = current_store
-          end
-        end
-      end
-    end
-  end
-end

data/lib/spree/core/importer/order.rb

@@ -1,244 +0,0 @@
-module Spree
-  module Core
-    module Importer
-      class Order
-        def self.import(user, params)
-          Spree::Deprecation.warn('Spree::Core::Importer::Order is deprecated and will be removed in Spree 5.5. Please use `Spree::Imports::Order` instead.')
-
-          ensure_country_id_from_params params[:ship_address_attributes]
-          ensure_state_id_from_params params[:ship_address_attributes]
-          ensure_country_id_from_params params[:bill_address_attributes]
-          ensure_state_id_from_params params[:bill_address_attributes]
-
-          create_params = params.slice :currency
-          order = Spree::Order.create! create_params
-          order.associate_user!(user)
-
-          shipments_attrs = params.delete(:shipments_attributes)
-
-          create_line_items_from_params(params.delete(:line_items_attributes), order)
-          create_shipments_from_params(shipments_attrs, order)
-          create_adjustments_from_params(params.delete(:adjustments_attributes), order)
-          create_payments_from_params(params.delete(:payments_attributes), order)
-
-          if completed_at = params.delete(:completed_at)
-            order.completed_at = completed_at
-            order.state = 'complete'
-          end
-
-          params.delete(:user_id) unless user.try(:has_spree_role?, 'admin') && params.key?(:user_id)
-
-          order.update!(params)
-
-          order.create_proposed_shipments unless shipments_attrs.present?
-
-          # Really ensure that the order totals & states are correct
-          order.updater.update
-          if shipments_attrs.present?
-            order.shipments.each_with_index do |shipment, index|
-              shipment.update_columns(cost: shipments_attrs[index][:cost].to_f) if shipments_attrs[index][:cost].present?
-            end
-          end
-          order.reload
-        rescue StandardError => e
-          order.destroy if order&.persisted?
-          raise e.message
-        end
-
-        def self.create_shipments_from_params(shipments_hash, order)
-          return [] unless shipments_hash
-
-          shipments_hash.each do |s|
-            shipment = order.shipments.build
-            shipment.tracking       = s[:tracking]
-            shipment.stock_location = Spree::StockLocation.find_by(admin_name: s[:stock_location]) ||
-              Spree::StockLocation.find_by!(name: s[:stock_location])
-            inventory_units = create_inventory_units_from_order_and_params(order, s[:inventory_units])
-
-            inventory_units.each do |inventory_unit|
-              inventory_unit.shipment = shipment
-
-              if s[:shipped_at].present?
-                inventory_unit.pending = false
-                inventory_unit.state = 'shipped'
-              end
-
-              inventory_unit.save!
-            end
-
-            if s[:shipped_at].present?
-              shipment.shipped_at = s[:shipped_at]
-              shipment.state      = 'shipped'
-            end
-
-            shipment.save!
-
-            shipping_method = Spree::ShippingMethod.find_by(name: s[:shipping_method]) ||
-              Spree::ShippingMethod.find_by!(admin_name: s[:shipping_method])
-            rate = shipment.shipping_rates.create!(shipping_method: shipping_method, cost: s[:cost])
-
-            shipment.selected_shipping_rate_id = rate.id
-            shipment.update_amounts
-
-            adjustments = s.delete(:adjustments_attributes)
-            create_adjustments_from_params(adjustments, order, shipment)
-          rescue StandardError => e
-            raise "Order import shipments: #{e.message} #{s}"
-          end
-        end
-
-        def self.create_inventory_units_from_order_and_params(order, inventory_unit_params)
-          inventory_unit_params.each_with_object([]) do |inventory_unit_param, inventory_units|
-            ensure_variant_id_from_params(inventory_unit_param)
-            existing = inventory_units.detect { |unit| unit.variant_id == inventory_unit_param[:variant_id] }
-            if existing
-              existing.quantity += 1
-            else
-              line_item = order.line_items.detect { |ln| ln.variant_id == inventory_unit_param[:variant_id] }
-              inventory_units << InventoryUnit.new(line_item: line_item, order_id: order.id, variant: line_item.variant, quantity: 1)
-            end
-          end
-        end
-
-        def self.create_line_items_from_params(line_items, order)
-          return {} unless line_items
-
-          line_items.each do |line_item|
-            adjustments = line_item.delete(:adjustments_attributes)
-            extra_params = line_item.except(:variant_id, :quantity, :sku)
-            line_item = ensure_variant_id_from_params(line_item)
-            variant = Spree::Variant.find(line_item[:variant_id])
-            line_item = Cart::AddItem.call(order: order, variant: variant, quantity: line_item[:quantity]).value
-            # Raise any errors with saving to prevent import succeeding with line items
-            # failing silently.
-            if extra_params.present?
-              line_item.update!(extra_params)
-            else
-              line_item.save!
-            end
-            create_adjustments_from_params(adjustments, order, line_item)
-          rescue StandardError => e
-            raise "Order import line items: #{e.message} #{line_item}"
-          end
-        end
-
-        def self.create_adjustments_from_params(adjustments, order, adjustable = nil)
-          return [] unless adjustments
-
-          adjustments.each do |a|
-            adjustment = (adjustable || order).adjustments.build(
-              order: order,
-              amount: a[:amount].to_f,
-              label: a[:label],
-              source_type: source_type_from_adjustment(a)
-            )
-            adjustment.save!
-            adjustment.close!
-          rescue StandardError => e
-            raise "Order import adjustments: #{e.message} #{a}"
-          end
-        end
-
-        def self.create_payments_from_params(payments_hash, order)
-          return [] unless payments_hash
-
-          payments_hash.each do |p|
-            payment = order.payments.build order: order
-            payment.amount = p[:amount].to_f
-            # Order API should be using state as that's the normal payment field.
-            # spree_wombat serializes payment state as status so imported orders should fall back to status field.
-            payment.state = p[:state] || p[:status] || 'completed'
-            payment.created_at = p[:created_at] if p[:created_at]
-            payment.payment_method = Spree::PaymentMethod.find_by!(name: p[:payment_method])
-            payment.source = create_source_payment_from_params(p[:source], payment) if p[:source]
-            payment.save!
-          rescue StandardError => e
-            raise "Order import payments: #{e.message} #{p}"
-          end
-        end
-
-        def self.create_source_payment_from_params(source_hash, payment)
-          Spree::CreditCard.create(
-            month: source_hash[:month],
-            year: source_hash[:year],
-            cc_type: source_hash[:cc_type],
-            last_digits: source_hash[:last_digits],
-            name: source_hash[:name],
-            payment_method: payment.payment_method,
-            gateway_customer_profile_id: source_hash[:gateway_customer_profile_id],
-            gateway_payment_profile_id: source_hash[:gateway_payment_profile_id],
-            imported: true
-          )
-        rescue StandardError => e
-          raise "Order import source payments: #{e.message} #{source_hash}"
-        end
-
-        def self.ensure_variant_id_from_params(hash)
-          sku = hash.delete(:sku)
-          unless hash[:variant_id].present?
-            hash[:variant_id] = Spree::Variant.active.find_by!(sku: sku).id
-          end
-          hash
-        rescue ActiveRecord::RecordNotFound => e
-          raise "Ensure order import variant: Variant w/SKU #{sku} not found."
-        rescue StandardError => e
-          raise "Ensure order import variant: #{e.message} #{hash}"
-        end
-
-        def self.ensure_country_id_from_params(address)
-          return if address.nil? || address[:country_id].present? || address[:country].nil?
-
-          begin
-            search = {}
-            if name = address[:country]['name']
-              search[:name] = name
-            elsif iso_name = address[:country]['iso_name']
-              search[:iso_name] = iso_name.upcase
-            elsif iso = address[:country]['iso']
-              search[:iso] = iso.upcase
-            elsif iso3 = address[:country]['iso3']
-              search[:iso3] = iso3.upcase
-            end
-
-            address.delete(:country)
-            address[:country_id] = Spree::Country.where(search).first!.id
-          rescue StandardError => e
-            raise "Ensure order import address country: #{e.message} #{search}"
-          end
-        end
-
-        def self.ensure_state_id_from_params(address)
-          return if address.nil? || address[:state_id].present? || address[:state].nil?
-
-          begin
-            search = {}
-            if name = address[:state]['name']
-              search[:name] = name
-            elsif abbr = address[:state]['abbr']
-              search[:abbr] = abbr.upcase
-            end
-
-            address.delete(:state)
-            search[:country_id] = address[:country_id]
-
-            if state = Spree::State.where(search).first
-              address[:state_id] = state.id
-            else
-              address[:state_name] = search[:name] || search[:abbr]
-            end
-          rescue StandardError => e
-            raise "Ensure order import address state: #{e.message} #{search}"
-          end
-        end
-
-        def self.source_type_from_adjustment(adjustment)
-          if adjustment[:tax]
-            'Spree::TaxRate'
-          elsif adjustment[:promotion]
-            'Spree::PromotionAction'
-          end
-        end
-      end
-    end
-  end
-end

data/lib/spree/core/importer/product.rb

@@ -1,67 +0,0 @@
-module Spree
-  module Core
-    module Importer
-      class Product
-        attr_reader :product, :product_attrs, :variants_attrs, :options_attrs, :store
-
-        def initialize(product, product_params, options = {})
-          Spree::Deprecation.warn('Spree::Core::Importer::Product is deprecated and will be removed in Spree 5.5. Please use `Spree::Imports::Product` instead.')
-
-          @store = options[:store] || Spree::Store.default
-          @product = product || Spree::Product.new(product_params)
-          @product.stores << @store if @product.stores.exclude?(@store)
-
-          @product_attrs = product_params.to_h
-          @variants_attrs = (options[:variants_attrs] || []).map(&:to_h)
-          @options_attrs = options[:options_attrs] || []
-        end
-
-        def create
-          if product.save
-            variants_attrs.each do |variant_attribute|
-              # make sure the product is assigned before the options=
-              product.variants.create({ product: product }.merge(variant_attribute))
-            end
-
-            set_up_options
-          end
-
-          product
-        end
-
-        def update
-          if product.update(product_attrs)
-            variants_attrs.each do |variant_attribute|
-              # update the variant if the id is present in the payload
-              if variant_attribute['id'].present?
-                product.variants.find(variant_attribute['id']).update(variant_attribute)
-              else
-                # make sure the product is assigned before the options=
-                product.variants.create({ product: product }.merge(variant_attribute))
-              end
-            end
-
-            set_up_options
-          end
-
-          product
-        end
-
-        private
-
-        def set_up_options
-          options_attrs.each do |name|
-            option_type = Spree::OptionType.where(name: name).first_or_initialize do |option_type|
-              option_type.presentation = name
-              option_type.save!
-            end
-
-            unless product.option_types.include?(option_type)
-              product.option_types << option_type
-            end
-          end
-        end
-      end
-    end
-  end
-end