solidus_advanced_pricing 0.1.0

data/app/models/solidus_advanced_pricing/price_selector.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module SolidusAdvancedPricing
+  # Filter -> country bucket -> cheapest. Role is eligibility only, never specificity:
+  # a role-targeted price set above the untargeted price therefore never applies.
+  class PriceSelector < ::Spree::Variant::PriceSelector
+    def self.pricing_options_class
+      SolidusAdvancedPricing::PricingOptions
+    end
+
+    def price_for_options(price_options)
+      candidates = eligible_prices(price_options)
+      return nil if candidates.empty?
+
+      cheapest(bucket_by_country(candidates, price_options.country_iso))
+    end
+
+    private
+
+    def eligible_prices(price_options)
+      wanted_type = price_options.desired_attributes[:price_type_id]
+
+      variant.prices.select do |price|
+        kept?(price) &&
+          price.currency == price_options.currency &&
+          matches_type?(price, wanted_type) &&
+          valid_at?(price, price_options.at) &&
+          visible_to?(price, price_options.customer_role_ids)
+      end
+    end
+
+    def kept?(price)
+      variant.discarded? || price.kept?
+    end
+
+    # nil = untyped base prices only (the admin's view); :any = every type competes
+    # (a customer's view); an id = that type only.
+    def matches_type?(price, wanted_type)
+      return true if wanted_type == :any
+
+      price.price_type_id == wanted_type
+    end
+
+    def valid_at?(price, time)
+      return true if time.nil?
+
+      (price.valid_from.nil? || price.valid_from <= time) &&
+        (price.valid_to.nil? || price.valid_to > time)
+    end
+
+    def visible_to?(price, customer_role_ids)
+      price.role_id.nil? || customer_role_ids.include?(price.role_id)
+    end
+
+    # Country is specificity, not competition: a country-specific price beats the
+    # any-country fallback even when the fallback is cheaper.
+    def bucket_by_country(candidates, country_iso)
+      specific = candidates.select { |price| price.country_iso == country_iso && !price.country_iso.nil? }
+      specific.presence || candidates.select { |price| price.country_iso.nil? }
+    end
+
+    def cheapest(candidates)
+      candidates.min_by do |price|
+        [
+          price.amount,
+          SolidusAdvancedPricing::PriceTypeCache.position_for(price.price_type_id),
+          -(price.updated_at || Time.zone.now).to_i,
+          -(price.id || Float::INFINITY)
+        ]
+      end
+    end
+  end
+end

data/app/models/solidus_advanced_pricing/price_type.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module SolidusAdvancedPricing
+  # Discarding a type hides it from admin dropdowns but leaves historical
+  # prices resolvable through it; prices are never reassigned when a type is
+  # retired, so a retired type's code stays reserved rather than reusable.
+  # `::Spree::Base` etc. are qualified from the root: the
+  # `solidus_advanced_pricing/spree` decorator namespace shadows the bare
+  # `Spree` constant here otherwise (Zeitwerk const-shadowing gotcha).
+  class PriceType < ::Spree::Base
+    include ::Spree::SoftDeletable
+
+    self.table_name = "solidus_advanced_pricing_price_types"
+
+    # Needed for the solidus_admin index search box (name_or_code_cont); Ransack
+    # denies any attribute not explicitly allowed here.
+    self.allowed_ransackable_attributes = %w[name code]
+
+    has_many :prices,
+      class_name: "::Spree::Price",
+      foreign_key: :price_type_id,
+      inverse_of: :price_type
+
+    # Not `dependent: :restrict_with_error` — that check is default-scoped and
+    # misses discarded prices, which then trip the FK on DELETE.
+    before_destroy :prevent_destroying_referenced_type
+
+    before_validation :normalize_code
+
+    validates :name, presence: true
+    # Codes are normalized to lowercase so a plain unique index IS the rule on
+    # PostgreSQL, MySQL and SQLite alike. `case_sensitive: false` would have the
+    # validator and the index disagree on PG/SQLite, letting `insert_all` create
+    # two rows differing only in case.
+    validates :code, presence: true, uniqueness: {case_sensitive: true}
+
+    scope :ordered, -> { order(:position, :id) }
+
+    SEEDS = [
+      {code: "wholesale", name: "Wholesale", position: 1},
+      {code: "sale", name: "Sale", position: 2},
+      {code: "clearance", name: "Clearance", position: 3},
+      {code: "employee", name: "Employee", position: 4},
+      {code: "map", name: "MAP", position: 5},
+      {code: "promotional", name: "Promotional", position: 6}
+    ].freeze
+
+    # Idempotent. Used by the test suite and available to stores for re-seeding.
+    # The migration deliberately does NOT call this — a historical migration must
+    # not depend on current app code — so the two lists may drift, which is fine:
+    # the migration is history, this is the present.
+    def self.seed!
+      SEEDS.each do |attrs|
+        with_discarded.find_or_create_by!(code: attrs[:code]) do |price_type|
+          price_type.name = attrs[:name]
+          price_type.position = attrs[:position]
+        end
+      end
+    end
+
+    def to_s
+      name
+    end
+
+    after_commit { SolidusAdvancedPricing::PriceTypeCache.clear }
+
+    private
+
+    def normalize_code
+      self.code = code&.strip&.downcase.presence
+    end
+
+    def prevent_destroying_referenced_type
+      return unless prices.with_discarded.exists?
+
+      errors.add(:base, :referenced_by_prices)
+      throw :abort
+    end
+  end
+end

data/app/models/solidus_advanced_pricing/price_type_cache.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SolidusAdvancedPricing
+  # Process-local memoization for values read on every pricing lookup.
+  # Cleared by PriceType's after_save/after_destroy/after_discard callbacks
+  # and, later, by Spree::Price.
+  module PriceTypeCache
+    class << self
+      def pricing_role_ids
+        return @pricing_role_ids if defined?(@pricing_role_ids)
+
+        @pricing_role_ids = ::Spree::Price.distinct.pluck(:role_id).compact
+      end
+
+      # id => position, for the selector's tie-breaker. A handful of rows that
+      # change almost never, so one memoized map beats a query per candidate price.
+      def positions
+        return @positions if defined?(@positions)
+
+        @positions = PriceType.with_discarded.pluck(:id, :position).to_h
+      end
+
+      def position_for(price_type_id)
+        positions.fetch(price_type_id, 0)
+      end
+
+      # code => id. Handful of rows that change almost never.
+      def ids_by_code
+        return @ids_by_code if defined?(@ids_by_code)
+
+        @ids_by_code = PriceType.with_discarded.pluck(:code, :id).to_h
+      end
+
+      def id_for(code)
+        ids_by_code[code.to_s]
+      end
+
+      def clear
+        remove_instance_variable(:@pricing_role_ids) if defined?(@pricing_role_ids)
+        remove_instance_variable(:@positions) if defined?(@positions)
+        remove_instance_variable(:@ids_by_code) if defined?(@ids_by_code)
+      end
+    end
+  end
+end

data/app/models/solidus_advanced_pricing/pricing_options.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module SolidusAdvancedPricing
+  # desired_attributes describes the price being sought and may hold only assignable
+  # Spree::Price columns, because core calls prices.build(default_price_attributes).
+  # at/customer_role_ids describe who is asking and live outside that hash.
+  class PricingOptions < ::Spree::Variant::PricingOptions
+    attr_reader :at, :customer_role_ids
+
+    def self.default_price_attributes
+      super.merge(
+        price_type_id: nil,
+        role_id: nil
+      )
+    end
+
+    # price_type_id: :any means "no type filter, every type competes". nil, the
+    # default set by default_price_attributes above, means "untyped base prices
+    # only" and must not leak into a customer-facing lookup, or a sale price
+    # could never be selected.
+    def self.from_line_item(line_item)
+      options = super
+      new(
+        options.desired_attributes.merge(
+          price_type_id: :any,
+          customer_role_ids: pricing_relevant_role_ids(line_item.order&.user)
+        )
+      )
+    end
+
+    # price_type_id: :any (see from_line_item above).
+    def self.from_context(context)
+      options = super
+      new(
+        options.desired_attributes.merge(
+          price_type_id: :any,
+          customer_role_ids: pricing_relevant_role_ids(context.try(:current_spree_user))
+        )
+      )
+    end
+
+    def self.from_price(price)
+      new(
+        currency: price.currency,
+        country_iso: price.country_iso,
+        price_type_id: price.price_type_id,
+        role_id: price.role_id
+      )
+    end
+
+    # Narrowed to roles some price actually uses: selection is unaffected, but it
+    # collapses cache key cardinality (Task 12).
+    def self.pricing_relevant_role_ids(user)
+      return [] if user.nil?
+
+      user.spree_role_ids & SolidusAdvancedPricing::PriceTypeCache.pricing_role_ids
+    end
+
+    def initialize(desired_attributes = {})
+      attributes = desired_attributes.dup
+      @at = attributes.key?(:at) ? attributes.delete(:at) : Time.current
+      @customer_role_ids = Array(attributes.delete(:customer_role_ids))
+      super(attributes)
+    end
+
+    # Core keys only on desired_attributes; customer context lives outside it, so
+    # without this a role-targeted price would be cached and served to a guest.
+    def cache_key
+      [super, roles_cache_component, time_cache_component].compact.join("/")
+    end
+
+    # nil is a real filter now (price_type_id IS NULL matches untyped base prices)
+    # and is kept; :any means no type filter at all, so it's stripped instead —
+    # it's a selector-only sentinel and not a column value `where` could use.
+    def search_arguments
+      arguments = desired_attributes.dup
+      arguments[:country_iso] = [desired_attributes[:country_iso], nil].flatten.uniq
+      arguments[:role_id] = [nil, *customer_role_ids].uniq
+      arguments.delete(:price_type_id) if desired_attributes[:price_type_id] == :any
+      arguments
+    end
+
+    # at and customer_role_ids live outside desired_attributes, so they have to be
+    # carried explicitly or a derived lookup silently becomes an admin one.
+    def with(**overrides)
+      self.class.new(
+        desired_attributes.merge(at: at, customer_role_ids: customer_role_ids).merge(overrides)
+      )
+    end
+
+    private
+
+    def roles_cache_component
+      return "r-none" if customer_role_ids.empty?
+
+      "r-#{customer_role_ids.sort.join("-")}"
+    end
+
+    def time_cache_component
+      granularity = ::Spree::Config.advanced_pricing_cache_granularity.to_i
+      return nil if granularity <= 0
+      return nil if at.nil?
+
+      "t-#{at.to_i / granularity}"
+    end
+  end
+end

data/app/overrides/spree/admin/prices/_form/add_advanced_fields.html.erb.deface

@@ -0,0 +1,2 @@
+<!-- insert_bottom "[data-hook='admin_product_price_form']" -->
+<%= render 'spree/admin/prices/advanced_fields', f: f %>

data/app/overrides/spree/admin/prices/_master_variant_table/add_advanced_columns.html.erb.deface

@@ -0,0 +1,2 @@
+<!-- insert_before "[data-hook='prices_row'] td.actions" -->
+<%= render 'spree/admin/prices/advanced_columns', price: price %>

data/app/overrides/spree/admin/prices/_master_variant_table/add_advanced_headers.html.erb.deface

@@ -0,0 +1,4 @@
+<!-- insert_before "[data-hook='master_prices_header'] th.actions" -->
+<th><%= SolidusAdvancedPricing::PriceType.model_name.human %></th>
+<th><%= Spree::Price.human_attribute_name(:role_id) %></th>
+<th><%= t('solidus_advanced_pricing.validity') %></th>

data/app/overrides/spree/admin/prices/_table/add_advanced_columns.html.erb.deface

@@ -0,0 +1,2 @@
+<!-- insert_before "[data-hook='prices_row'] td.actions" -->
+<%= render 'spree/admin/prices/advanced_columns', price: price %>

data/app/overrides/spree/admin/prices/_table/add_advanced_headers.html.erb.deface

@@ -0,0 +1,4 @@
+<!-- insert_before "[data-hook='prices_header'] th.actions" -->
+<th><%= SolidusAdvancedPricing::PriceType.model_name.human %></th>
+<th><%= Spree::Price.human_attribute_name(:role_id) %></th>
+<th><%= t('solidus_advanced_pricing.validity') %></th>

data/app/overrides/spree/admin/shared/_configuration_menu/add_price_types_link.html.erb.deface

@@ -0,0 +1,4 @@
+<!-- insert_bottom "[data-hook='admin_configurations_sidebar_menu']" -->
+<% if can?(:manage, SolidusAdvancedPricing::PriceType) %>
+  <%= settings_tab_item t('solidus_advanced_pricing.price_types'), spree.admin_price_types_path %>
+<% end %>

data/bin/console

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "solidus_advanced_pricing"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+$LOAD_PATH.unshift(*Dir["#{__dir__}/../app/*"])
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/rails

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+if %w[g generate].include? ARGV.first
+  exec "#{__dir__}/rails-engine", *ARGV
+else
+  exec "#{__dir__}/rails-sandbox", *ARGV
+end

data/bin/rails-engine

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('..', __dir__)
+ENGINE_PATH = File.expand_path('../lib/solidus_advanced_pricing/engine', __dir__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require 'rails/all'
+require 'rails/engine/commands'

data/bin/rails-sandbox

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+app_root = "sandbox"
+
+unless File.exist? "#{app_root}/bin/rails"
+  warn "Creating the sandbox app..."
+  Dir.chdir "#{__dir__}/.." do
+    system "#{__dir__}/sandbox" or begin
+      warn "Automatic creation of the sandbox app failed"
+      exit 1
+    end
+  end
+end
+
+Dir.chdir app_root
+exec "bin/rails", *ARGV

data/bin/rake

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/bin/sandbox

@@ -0,0 +1,85 @@
+#!/usr/bin/env bash
+
+set -e
+test -z "${DEBUG+empty_string}" || set -x
+
+test "$DB" = "sqlite" && export DB="sqlite3"
+
+if [ -z "$PAYMENT_METHOD" ]
+then
+  PAYMENT_METHOD="none"
+fi
+
+if [ -z "$SOLIDUS_BRANCH" ]
+then
+  echo "~~> Use 'export SOLIDUS_BRANCH=[main|v4.0|...]' to control the Solidus branch"
+  SOLIDUS_BRANCH="main"
+fi
+echo "~~> Using branch $SOLIDUS_BRANCH of solidus"
+
+extension_name="solidus_advanced_pricing"
+
+# Stay away from the bundler env of the containing extension.
+function unbundled {
+  ruby -rbundler -e'
+      Bundler.with_unbundled_env {system *ARGV}' -- \
+        env BUNDLE_SUPPRESS_INSTALL_USING_MESSAGES=true $@
+}
+
+echo "~~~> Removing the old sandbox"
+rm -rf ./sandbox
+
+echo "~~~> Creating a pristine Rails app"
+rails_version=`bundle exec ruby -e'require "rails"; puts Rails.version'`
+rails _${rails_version}_ new sandbox \
+  --database="${DB:-sqlite3}" \
+  --skip-git \
+  --skip-keeps \
+  --skip-rc \
+  --skip-bootsnap \
+  --skip-test
+
+if [ ! -d "sandbox" ]; then
+  echo 'sandbox rails application failed'
+  exit 1
+fi
+
+echo "~~~> Adding solidus (with i18n) to the Gemfile"
+cd ./sandbox
+cat <<RUBY >> Gemfile
+gem 'solidus', github: 'solidusio/solidus', branch: '$SOLIDUS_BRANCH'
+gem 'rails-i18n'
+gem 'solidus_i18n'
+gem 'solidus_auth_devise'
+
+gem '$extension_name', path: '..'
+
+group :test, :development do
+  platforms :mri do
+    gem 'pry-byebug'
+  end
+end
+RUBY
+
+echo "Generating manifest file"
+mkdir -p app/assets/config
+cat <<MANIFESTJS > app/assets/config/manifest.js
+//= link_tree ../images
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css
+MANIFESTJS
+
+unbundled bundle install --gemfile Gemfile
+
+unbundled bundle exec rake db:drop db:create
+
+unbundled bundle exec rails generate solidus:install \
+  --auto-accept \
+  $@
+
+unbundled bundle exec rails generate solidus:auth:install --auto-run-migrations
+unbundled bundle exec rails generate ${extension_name}:install --auto-run-migrations
+
+echo
+echo "🚀 Sandbox app successfully created for $extension_name!"
+echo "🧪 This app is intended for test purposes."

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+gem install bundler --conservative
+bundle update
+bin/rake clobber

data/config/locales/en.yml

@@ -0,0 +1,44 @@
+# Sample localization file for English. Add more files in this directory for other locales.
+# See https://github.com/svenfuchs/rails-i18n/tree/master/rails%2Flocale for starting points.
+
+en:
+  hello: Hello world
+  solidus_advanced_pricing:
+    price_types: "Price Types"
+    all_customers: "All customers"
+    role_hint: "Leave blank for all customers. A price type name alone grants no access control — an employee-only price needs this field set."
+    admin_notes_hint: "Internal only. Never shown to customers."
+    validity: "Validity"
+  solidus_admin:
+    menu_item:
+      price_types: "Price Types"
+    price_types:
+      title: "Price Types"
+      destroy:
+        success: "Price types were successfully removed."
+  activerecord:
+    models:
+      solidus_advanced_pricing/price_type:
+        one: "Price Type"
+        other: "Price Types"
+    attributes:
+      spree/price:
+        price_type_id: "Price Type"
+        role_id: "Visible to role"
+        valid_from: "Valid from"
+        valid_to: "Valid to"
+        admin_notes: "Admin notes"
+    errors:
+      models:
+        solidus_advanced_pricing/price_type:
+          attributes:
+            base:
+              referenced_by_prices: "This price type is still used by one or more prices and cannot be deleted. Retire it instead."
+        spree/price:
+          attributes:
+            valid_to:
+              must_be_after_valid_from: "must be after the valid from date"
+        spree/role:
+          attributes:
+            base:
+              referenced_by_prices: "This role is used to target one or more prices and cannot be deleted."

data/config/routes.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+Spree::Core::Engine.routes.draw do
+  namespace :api, defaults: {format: "json"} do
+    resources :variants, only: [] do
+      resources :prices, only: [:index, :show]
+    end
+  end
+
+  namespace :admin do
+    resources :price_types, except: [:show]
+  end
+end
+
+# SolidusAdmin::ResourcesController, which our controller inherits from, only exists
+# from Solidus 4.5 -- solidus_admin itself ships from 4.3. Version check rather than
+# a constant check: routes are drawn before solidus_admin's autoloads are ready.
+if defined?(SolidusAdmin::Engine) && Spree.solidus_gem_version >= Gem::Version.new("4.5")
+  SolidusAdmin::Engine.routes.draw do
+    # admin_resources is added via `extend` on the Mapper instance solidus_admin's
+    # own routes.rb draws with -- a separate `draw` call like this one gets its
+    # own Mapper, so it isn't inherited and has to be required/extended again.
+    require "solidus_admin/admin_resources"
+    extend SolidusAdmin::AdminResources
+
+    # :index and the batch :destroy only -- SolidusAdmin::Engine is mounted
+    # before Spree::Core::Engine (see spec/dummy's routes.rb), so a wider set
+    # here (e.g. :new, :edit) would shadow the legacy backend's own working
+    # forms at the same /admin/price_types/... paths with a 404, since this
+    # gem intentionally doesn't implement solidus_admin new/edit components
+    # for price types.
+    admin_resources :price_types, only: [:index, :destroy]
+  end
+end

data/db/migrate/20260915000001_create_solidus_advanced_pricing_price_types.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class CreateSolidusAdvancedPricingPriceTypes < ActiveRecord::Migration[7.0]
+  def change
+    create_table :solidus_advanced_pricing_price_types do |t|
+      t.string :name, null: false
+      t.string :code, null: false
+      t.integer :position, null: false, default: 0
+      t.datetime :deleted_at
+      t.timestamps
+    end
+
+    add_index :solidus_advanced_pricing_price_types, :code, unique: true
+    add_index :solidus_advanced_pricing_price_types, :deleted_at
+  end
+end

data/db/migrate/20260915000002_seed_solidus_advanced_pricing_price_types.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class SeedSolidusAdvancedPricingPriceTypes < ActiveRecord::Migration[7.0]
+  SEEDS = [
+    {code: "wholesale", name: "Wholesale", position: 1},
+    {code: "sale", name: "Sale", position: 2},
+    {code: "clearance", name: "Clearance", position: 3},
+    {code: "employee", name: "Employee", position: 4},
+    {code: "map", name: "MAP", position: 5},
+    {code: "promotional", name: "Promotional", position: 6}
+  ].freeze
+
+  def up
+    now = Time.current
+
+    SEEDS.each do |attrs|
+      next if price_types.where(code: attrs[:code]).exists?
+
+      price_types.insert_all([attrs.merge(created_at: now, updated_at: now)])
+    end
+  end
+
+  def down
+    price_types.where(code: SEEDS.map { |attrs| attrs[:code] }).delete_all
+  end
+
+  private
+
+  def price_types
+    @price_types ||= Class.new(ActiveRecord::Base) do
+      self.table_name = "solidus_advanced_pricing_price_types"
+    end
+  end
+end

data/db/migrate/20260915000003_add_advanced_pricing_to_spree_prices.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class AddAdvancedPricingToSpreePrices < ActiveRecord::Migration[7.0]
+  def change
+    add_column :spree_prices, :price_type_id, :bigint
+    # :integer, not :bigint — spree_roles.id is int and MySQL rejects mismatched FK precision.
+    add_column :spree_prices, :role_id, :integer
+    add_column :spree_prices, :valid_from, :datetime
+    add_column :spree_prices, :valid_to, :datetime
+    add_column :spree_prices, :admin_notes, :text
+
+    add_index :spree_prices, :price_type_id
+    add_index :spree_prices, :role_id
+    add_index :spree_prices,
+      [:variant_id, :currency, :country_iso],
+      name: "index_spree_prices_on_advanced_pricing_lookup"
+
+    add_foreign_key :spree_prices, :solidus_advanced_pricing_price_types, column: :price_type_id, on_delete: :restrict
+    add_foreign_key :spree_prices, :spree_roles, column: :role_id, on_delete: :restrict
+  end
+end