solidus_advanced_pricing 0.1.0 → 0.3.0

data/app/models/solidus_advanced_pricing/price_batch.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module SolidusAdvancedPricing
+  # Applies many price rows in one call, keyed on the dimensions a price
+  # legitimately varies on, so re-sending the same payload is a no-op rather
+  # than a pile of duplicates.
+  #
+  # Deliberately generic: it validates and writes prices and reports what it
+  # did. Store policy -- how large a swing is allowed, what gets reindexed,
+  # what gets published on an event bus -- belongs to the host app, which can
+  # hang it off `SolidusAdvancedPricing.config.batch_guard` or act on the
+  # returned results.
+  class PriceBatch
+    MODES = %w[upsert replace].freeze
+
+    # Two rows agreeing on all of these are the same price. `valid_to` is
+    # deliberately absent: extending or shortening a window is an edit to an
+    # existing price, not a different one.
+    NATURAL_KEY = %i[variant_id currency country_iso price_type_id role_id valid_from].freeze
+
+    # Everything a natural-key row may change. Anything in the key is, by
+    # definition, how the row was found, so changing it there is incoherent.
+    UPDATABLE = %i[amount valid_to admin_notes].freeze
+
+    # An `id` names the row outright, so nothing is off-limits except which
+    # variant it hangs off. `price_type_id` is listed but the model refuses to
+    # change it on a persisted price, which surfaces as an ordinary row error.
+    UPDATABLE_BY_ID = %i[amount currency country_iso price_type_id role_id valid_from valid_to admin_notes].freeze
+
+    class TooManyRows < StandardError; end
+
+    class InvalidMode < StandardError; end
+
+    Result = Struct.new(:index, :status, :price_id, :variant_id, :errors, keyword_init: true) do
+      def to_h
+        {index: index, status: status, price_id: price_id, variant_id: variant_id, errors: errors}.compact
+      end
+    end
+
+    attr_reader :results, :mode
+
+    def initialize(rows:, mode: "upsert", dry_run: false, row_limit: nil)
+      @rows = Array(rows)
+      @mode = mode.to_s
+      @dry_run = ActiveModel::Type::Boolean.new.cast(dry_run) || false
+      @row_limit = row_limit || SolidusAdvancedPricing.config.batch_row_limit
+      @results = []
+      @touched_ids = Hash.new { |hash, key| hash[key] = [] }
+
+      raise InvalidMode, "mode must be one of #{MODES.join(", ")}" unless MODES.include?(@mode)
+      raise TooManyRows, "batch is limited to #{@row_limit} rows, got #{@rows.size}" if @rows.size > @row_limit
+    end
+
+    def dry_run? = @dry_run
+
+    def replace? = @mode == "replace"
+
+    def call
+      # A dry run does the real work against the database and throws it away, so
+      # what it reports is what the write would actually do -- validations, type
+      # casting and constraints included -- rather than a guess at it.
+      ActiveRecord::Base.transaction do
+        seen = {}
+
+        @rows.each_with_index do |row, index|
+          apply_row(row.to_h.symbolize_keys, index, seen)
+        end
+
+        apply_replacements if replace?
+
+        # The host app's veto, with every row already written and nothing
+        # committed. Raising from here aborts the whole batch -- which is the
+        # only place a "this moves too many prices too far" rule can see the
+        # finished picture and still stop it.
+        SolidusAdvancedPricing.config.batch_guard&.call(self)
+
+        raise ActiveRecord::Rollback if dry_run?
+      end
+
+      self
+    end
+
+    def summary
+      results.group_by(&:status).transform_values(&:size)
+    end
+
+    private
+
+    # Resolution happens outside the savepoint -- it touches no state, and a
+    # `return` out of a transaction block is a trap worth not setting.
+    # Two ways to name a row, and `id` wins when it is there: it says exactly
+    # which price to change, with no key to assemble and no precision to lose.
+    #
+    # The natural key is what a payload authored somewhere that does not know
+    # Solidus ids -- a supplier feed, a merchandiser's spreadsheet, a backfill
+    # from another system -- has instead. It is also what makes such a payload
+    # re-runnable: without it, a nightly feed has no ids on its rows and would
+    # create a fresh duplicate of every price on every pass.
+    def apply_row(row, index, seen)
+      located = row[:id].present? ? locate_by_id(row) : locate_by_key(row)
+      return record(index, :error, errors: [located]) if located.is_a?(String)
+
+      price, variant_id, price_type_id, dedup, attributes = located
+
+      if seen.key?(dedup)
+        return record(index, :error, variant_id: variant_id,
+          errors: ["duplicate of row #{seen[dedup]}: #{duplicate_reason(dedup)}"])
+      end
+      seen[dedup] = index
+
+      persist(index, price, variant_id, price_type_id, attributes)
+    end
+
+    def duplicate_reason(dedup)
+      if dedup.first == :id
+        "same price id"
+      else
+        "same variant, currency, country, price type, role and valid_from"
+      end
+    end
+
+    def locate_by_id(row)
+      price = ::Spree::Price.kept.find_by(id: row[:id])
+      return "no price with id #{row[:id]}" if price.nil?
+
+      variant = resolve_variant(row) unless row[:variant_id].blank? && row[:sku].blank?
+      return "variant: #{variant}" if variant.is_a?(String)
+      if variant && variant.id != price.variant_id
+        return "price #{price.id} belongs to variant #{price.variant_id}, not #{variant.id}"
+      end
+
+      price_type_id = resolve_price_type_id(row)
+      return "price_type: #{price_type_id}" if price_type_id.is_a?(String)
+
+      attributes = row.slice(*UPDATABLE_BY_ID)
+      attributes[:price_type_id] = price_type_id if row.key?(:price_type_code)
+
+      [price, price.variant_id, price.price_type_id, [:id, price.id], attributes]
+    end
+
+    def locate_by_key(row)
+      variant = resolve_variant(row)
+      return "variant: #{variant}" if variant.is_a?(String)
+
+      price_type_id = resolve_price_type_id(row)
+      return "price_type: #{price_type_id}" if price_type_id.is_a?(String)
+
+      key = natural_key(row, variant, price_type_id)
+      price = find_existing(key) || ::Spree::Price.new(key)
+
+      [price, variant.id, price_type_id, [:key, key], row.slice(*UPDATABLE)]
+    end
+
+    # Each row gets its own savepoint: one bad row must not poison the batch,
+    # and on PostgreSQL a raised constraint error would otherwise abort every
+    # statement that follows it in the transaction.
+    def persist(index, price, variant_id, price_type_id, attributes)
+      ActiveRecord::Base.transaction(requires_new: true) do
+        existing = price.persisted?
+        price.assign_attributes(attributes)
+
+        if existing && !price.changed?
+          touch(variant_id, price_type_id, price.id)
+          record(index, :unchanged, price_id: price.id, variant_id: variant_id)
+        elsif price.save
+          touch(variant_id, price.price_type_id, price.id)
+          record(index, existing ? :updated : :created, price_id: reportable_id(price), variant_id: variant_id)
+        else
+          # Recorded before the rollback on purpose: @results is a Ruby array,
+          # so the savepoint unwinding the row does not unwind the report of it.
+          record(index, :error, variant_id: variant_id, errors: price.errors.full_messages)
+          raise ActiveRecord::Rollback
+        end
+      end
+    end
+
+    def touch(variant_id, price_type_id, price_id)
+      @touched_ids[[variant_id, price_type_id]] << price_id
+    end
+
+    # Only prices of a type the payload actually spoke about, on a variant the
+    # payload actually named, are in scope. A `replace` that named one sale
+    # price must not reach the variant's base price or its wholesale tier.
+    def apply_replacements
+      @touched_ids.each do |(variant_id, price_type_id), kept_ids|
+        stale = ::Spree::Price.kept.where(variant_id: variant_id, price_type_id: price_type_id).where.not(id: kept_ids)
+
+        stale.each do |price|
+          price.discard
+          @results << Result.new(index: nil, status: :deleted, price_id: price.id, variant_id: variant_id)
+        end
+      end
+    end
+
+    def resolve_variant(row)
+      if row[:variant_id].present? && row[:sku].present?
+        return "give variant_id or sku, not both"
+      end
+
+      if row[:variant_id].present?
+        ::Spree::Variant.find_by(id: row[:variant_id]) || "no variant with id #{row[:variant_id]}"
+      elsif row[:sku].present?
+        ::Spree::Variant.find_by(sku: row[:sku]) || "no variant with sku #{row[:sku].inspect}"
+      else
+        "variant_id or sku is required"
+      end
+    end
+
+    # Mirrors the single-price endpoint: a code is portable between databases
+    # where an id is not. Returns a String to signal failure, since nil is the
+    # legitimate value for the untyped base price.
+    def resolve_price_type_id(row)
+      has_code = row.key?(:price_type_code)
+      return "give price_type_id or price_type_code, not both" if has_code && row[:price_type_id].present?
+      return row[:price_type_id].presence && row[:price_type_id].to_i unless has_code
+
+      code = row[:price_type_code]
+      return nil if code.blank?
+
+      SolidusAdvancedPricing.resolve_price_type_id(code)
+    rescue ArgumentError
+      "no price type with code #{code.inspect}"
+    end
+
+    def natural_key(row, variant, price_type_id)
+      valid_from = ::Spree::Price.type_for_attribute(:valid_from).cast(row[:valid_from].presence)
+
+      {
+        variant_id: variant.id,
+        currency: row[:currency].presence || ::Spree::Config.default_pricing_options.currency,
+        country_iso: row[:country_iso].presence,
+        price_type_id: price_type_id,
+        role_id: row[:role_id].presence && row[:role_id].to_i,
+        # Truncated to the second so the key survives a round trip: a client that
+        # read a price back and re-sent its `valid_from` may have dropped the
+        # sub-second part, and treating that as a different price would duplicate
+        # the row -- and in `replace` mode, discard the original.
+        valid_from: valid_from&.change(usec: 0)
+      }
+    end
+
+    # Matching is a one-second window rather than an equality, so a price that
+    # was stored with sub-second precision by some other writer is still found
+    # by a truncated key.
+    def find_existing(key)
+      scope = ::Spree::Price.kept.where(key.except(:valid_from))
+      from = key[:valid_from]
+
+      return scope.find_by(valid_from: nil) if from.nil?
+
+      scope.where(valid_from: from...(from + 1.second)).first
+    end
+
+    # A dry run rolls back, so any id it allocated is about to stop existing.
+    # Reporting it would invite a client to use it.
+    def reportable_id(price)
+      dry_run? ? nil : price.id
+    end
+
+    def record(index, status, price_id: nil, variant_id: nil, errors: nil)
+      @results << Result.new(index: index, status: status, price_id: price_id, variant_id: variant_id, errors: errors)
+    end
+  end
+end

data/app/models/solidus_advanced_pricing/price_selector.rb

@@ -49,7 +49,9 @@ module SolidusAdvancedPricing
     end
 
     def visible_to?(price, customer_role_ids)
-      price.role_id.nil? || customer_role_ids.include?(price.role_id)
+      effective = price.effective_role_id
+
+      effective.nil? || customer_role_ids.include?(effective)
     end
 
     # Country is specificity, not competition: a country-specific price beats the

data/app/models/solidus_advanced_pricing/price_type.rb

@@ -21,6 +21,8 @@ module SolidusAdvancedPricing
       foreign_key: :price_type_id,
       inverse_of: :price_type
 
+    belongs_to :role, class_name: "::Spree::Role", optional: true
+
     # 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

data/app/models/solidus_advanced_pricing/price_type_cache.rb

@@ -6,10 +6,15 @@ module SolidusAdvancedPricing
   # and, later, by Spree::Price.
   module PriceTypeCache
     class << self
+      # Union with type-level defaults: a role that appears only on a price type
+      # (never directly on a price) must still narrow in, or a customer holding
+      # only that role would be filtered out before selection ever runs.
       def pricing_role_ids
         return @pricing_role_ids if defined?(@pricing_role_ids)
 
-        @pricing_role_ids = ::Spree::Price.distinct.pluck(:role_id).compact
+        @pricing_role_ids = (
+          ::Spree::Price.distinct.pluck(:role_id) + PriceType.with_discarded.distinct.pluck(:role_id)
+        ).compact.uniq
       end
 
       # id => position, for the selector's tie-breaker. A handful of rows that
@@ -35,10 +40,23 @@ module SolidusAdvancedPricing
         ids_by_code[code.to_s]
       end
 
+      # id => role_id, for the effective-role fallback. with_discarded matters —
+      # a retired type's default role must still apply to historical prices.
+      def role_ids
+        return @role_ids if defined?(@role_ids)
+
+        @role_ids = PriceType.with_discarded.pluck(:id, :role_id).to_h
+      end
+
+      def role_id_for(price_type_id)
+        role_ids[price_type_id]
+      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)
+        remove_instance_variable(:@role_ids) if defined?(@role_ids)
       end
     end
   end

data/config/locales/en.yml

@@ -6,7 +6,10 @@ en:
   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."
+    base_price: "Base price (no type)"
+    price_type_hint: "Leave as Base price for the standard price. A type is a label for the admin and reporting — it grants no eligibility on its own."
+    role_hint: "Leave blank to inherit the price type's default role, if it has one; otherwise visible to all customers. A price type name alone grants no access control — an employee-only price needs this field, or the type, set."
+    price_type_role_hint: "Prices of this type default to this role unless a price sets its own. Leaving a price's own role blank means it inherits this default — it does not make that price public."
     admin_notes_hint: "Internal only. Never shown to customers."
     validity: "Validity"
   solidus_admin:
@@ -22,6 +25,8 @@ en:
         one: "Price Type"
         other: "Price Types"
     attributes:
+      solidus_advanced_pricing/price_type:
+        role_id: "Default role"
       spree/price:
         price_type_id: "Price Type"
         role_id: "Visible to role"
@@ -36,9 +41,13 @@ en:
               referenced_by_prices: "This price type is still used by one or more prices and cannot be deleted. Retire it instead."
         spree/price:
           attributes:
+            price_type_id:
+              cannot_be_changed: "cannot be changed once the price exists. Discard this price and create a new one with the right type."
+              ambiguous_price_type: "cannot be given as both price_type_id and price_type_code. Send one or the other."
+              unknown_code: "no price type with code %{code}"
             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."
+              referenced_by_prices: "This role is used to target one or more prices or price types and cannot be deleted."

data/config/routes.rb

@@ -3,8 +3,15 @@
 Spree::Core::Engine.routes.draw do
   namespace :api, defaults: {format: "json"} do
     resources :variants, only: [] do
-      resources :prices, only: [:index, :show]
+      resources :prices, only: [:index, :show, :create, :update, :destroy]
     end
+
+    # Not nested under a variant: a batch spans variants, which is the point of it.
+    post "prices/batch", to: "price_batches#create", as: :price_batch
+
+    # Read-only: a client building a price payload needs the codes and ids, but
+    # creating a pricing dimension is an admin act, not an API one.
+    resources :price_types, only: [:index]
   end
 
   namespace :admin do

data/db/migrate/20260923000001_add_role_to_solidus_advanced_pricing_price_types.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class AddRoleToSolidusAdvancedPricingPriceTypes < ActiveRecord::Migration[7.0]
+  def change
+    # :integer, not :bigint — spree_roles.id is int and MySQL rejects mismatched FK precision.
+    add_column :solidus_advanced_pricing_price_types, :role_id, :integer
+    add_index :solidus_advanced_pricing_price_types, :role_id
+    add_foreign_key :solidus_advanced_pricing_price_types, :spree_roles, column: :role_id, on_delete: :restrict
+  end
+end

data/lib/components/admin/solidus_admin/price_types/index/component.rb

@@ -56,6 +56,10 @@ module SolidusAdmin
             {
               header: :position,
               data: ->(price_type) { price_type.position }
+            },
+            {
+              header: :role_id,
+              data: ->(price_type) { price_type.role&.name || t("solidus_advanced_pricing.all_customers") }
             }
           ]
         end

data/lib/controllers/admin/solidus_admin/price_types_controller.rb

@@ -7,7 +7,7 @@ module SolidusAdmin
     def resource_class = SolidusAdvancedPricing::PriceType
 
     def permitted_resource_params
-      params.require(:price_type).permit(:name, :code, :position)
+      params.require(:price_type).permit(:name, :code, :position, :role_id)
     end
 
     # ResourcesController derives these from resource_class.model_name, which for

data/lib/controllers/api/spree/api/price_batches_controller.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Spree
+  module Api
+    class PriceBatchesController < Spree::Api::BaseController
+      rescue_from SolidusAdvancedPricing::PriceBatch::TooManyRows, with: :batch_too_large
+      rescue_from SolidusAdvancedPricing::PriceBatch::InvalidMode, with: :bad_mode
+
+      # Always 200 with a per-row report, never a partial 4xx: a caller that
+      # sent 500 rows and got a bare 422 has no way to know which of them
+      # landed. The 4xx cases here are the ones where no row was even looked at.
+      def create
+        authorize! :create, Spree::Price
+
+        @batch = SolidusAdvancedPricing::PriceBatch.new(
+          rows: batch_rows,
+          mode: params.fetch(:mode, "upsert"),
+          dry_run: params[:dry_run]
+        ).call
+
+        render :create, status: :ok
+      end
+
+      private
+
+      def batch_rows
+        params.require(:prices).map do |row|
+          row.permit(
+            *Spree::PermittedAttributes.price_attributes,
+            :id,
+            :variant_id,
+            :sku,
+            :price_type_code
+          )
+        end
+      end
+
+      def batch_too_large(exception)
+        render json: {error: exception.message}, status: :unprocessable_entity
+      end
+
+      def bad_mode(exception)
+        render json: {error: exception.message}, status: :unprocessable_entity
+      end
+    end
+  end
+end

data/lib/controllers/api/spree/api/price_types_controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Spree
+  module Api
+    class PriceTypesController < Spree::Api::BaseController
+      # Retired types are excluded: this endpoint exists so a client can build a
+      # valid price payload, and a discarded type is no longer a valid choice.
+      # Historical prices still serialize their own type's code via the prices
+      # endpoint, so nothing is hidden from a reader.
+      def index
+        authorize! :index, SolidusAdvancedPricing::PriceType
+        @price_types = SolidusAdvancedPricing::PriceType.accessible_by(current_ability, :index).ordered
+        respond_with(@price_types)
+      end
+    end
+  end
+end

data/lib/controllers/api/spree/api/prices_controller.rb

@@ -15,18 +15,96 @@ module Spree
         respond_with(@price)
       end
 
+      def create
+        authorize! :create, Spree::Price
+
+        @price = variant.prices.new(currency: Spree::Config.default_pricing_options.currency)
+        assign_price_attributes(@price)
+
+        if @price.errors.empty? && @price.save
+          render :show, status: :created
+        else
+          invalid_resource!(@price)
+        end
+      end
+
+      def update
+        # `find` then `authorize!`, rather than an accessible_by scope, so a
+        # caller without rights gets 401 like every other action here instead of
+        # a 404 that reads as "no such price".
+        @price = live_prices.find(params[:id])
+        authorize! :update, @price
+
+        assign_price_attributes(@price)
+
+        if @price.errors.empty? && @price.save
+          render :show
+        else
+          invalid_resource!(@price)
+        end
+      end
+
+      # Soft delete: `discard`, not `destroy`, so the row stays available to
+      # anything reporting on what a variant used to cost.
+      def destroy
+        @price = live_prices.find(params[:id])
+        authorize! :destroy, @price
+
+        @price.discard
+        render plain: nil, status: :no_content
+      end
+
       private
 
       # Lists what exists for this variant; never routed through
       # current_pricing_options, which would filter by the requesting admin's
       # own roles via current_spree_user.
+      #
+      # `Spree::Variant#prices` is declared `-> { with_discarded }` in core, so
+      # the default here has to put `kept` back -- otherwise every listing
+      # includes prices someone deleted. `?show_deleted=true` opts back in, the
+      # same switch core uses on products.
       def scope
-        variant.prices.accessible_by(current_ability, :index)
+        prices = variant.prices.accessible_by(current_ability, :index)
+        params[:show_deleted] ? prices : prices.kept
+      end
+
+      # Writes never reach a discarded price: undeleting is not an API operation,
+      # and silently editing a deleted row is worse than a 404.
+      def live_prices
+        variant.prices.kept
       end
 
       def variant
         @variant ||= Spree::Variant.find(params[:variant_id])
       end
+
+      # `price_type_code` is accepted as an alternative to `price_type_id` because
+      # ids are per-database and codes are not -- a payload written against staging
+      # has to work unchanged against production. An explicit null means the untyped
+      # base price, so a present-but-empty key is meaningful and not the same as an
+      # absent one.
+      def assign_price_attributes(price)
+        attributes = params.require(:price).permit(*Spree::PermittedAttributes.price_attributes, :price_type_code)
+
+        if attributes.key?("price_type_code")
+          code = attributes.delete("price_type_code")
+
+          if attributes.key?("price_type_id")
+            price.errors.add(:price_type_id, :ambiguous_price_type)
+            return
+          end
+
+          begin
+            attributes["price_type_id"] = code.presence && SolidusAdvancedPricing.resolve_price_type_id(code)
+          rescue ArgumentError
+            price.errors.add(:price_type_id, :unknown_code, code: code)
+            return
+          end
+        end
+
+        price.assign_attributes(attributes)
+      end
     end
   end
 end

data/lib/controllers/backend/spree/admin/price_types_controller.rb

@@ -14,7 +14,7 @@ module Spree
       end
 
       def permitted_resource_params
-        params.require(:price_type).permit(:name, :code, :position)
+        params.require(:price_type).permit(:name, :code, :position, :role_id)
       end
 
       # ResourceController derives these from model_class.model_name, which for a

data/lib/solidus_advanced_pricing/configuration.rb

@@ -2,9 +2,20 @@
 
 module SolidusAdvancedPricing
   class Configuration
-    # Define here the settings for this extension, e.g.:
-    #
-    # attr_accessor :my_setting
+    # Largest payload PriceBatch will accept in one call. A synchronous request
+    # has to stay inside the web timeout; anything bigger belongs in a job.
+    attr_writer :batch_row_limit
+
+    # Optional callable invoked by PriceBatch once every row is written and
+    # before the transaction commits, receiving the batch. Raise from it to
+    # abort. This is the seam for store policy -- "refuse a batch that moves
+    # more than N% of prices by more than X%" -- which does not belong in a
+    # general-purpose extension but does need somewhere to stand.
+    attr_accessor :batch_guard
+
+    def batch_row_limit
+      @batch_row_limit ||= 500
+    end
   end
 
   class << self

data/lib/solidus_advanced_pricing/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SolidusAdvancedPricing
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/views/api/spree/api/price_batches/create.json.jbuilder

@@ -0,0 +1,6 @@
+json.mode @batch.mode
+json.dry_run @batch.dry_run?
+json.summary @batch.summary
+json.results(@batch.results) do |result|
+  json.merge! result.to_h
+end

data/lib/views/api/spree/api/price_types/_price_type.json.jbuilder

@@ -0,0 +1 @@
+json.call(price_type, :id, :code, :name, :position, :role_id)

data/lib/views/api/spree/api/price_types/index.json.jbuilder

@@ -0,0 +1,3 @@
+json.price_types(@price_types) do |price_type|
+  json.partial!("spree/api/price_types/price_type", price_type: price_type)
+end

data/lib/views/backend/spree/admin/price_types/_form.html.erb

@@ -17,4 +17,15 @@
       <%= f.number_field :position, class: 'fullwidth' %>
     <% end %>
   </div>
+  <div class="col-6">
+    <%= f.field_container :role do %>
+      <%= f.label :role_id, Spree::Role.model_name.human %>
+      <%= f.collection_select :role_id,
+                              Spree::Role.order(:name),
+                              :id, :name,
+                              { include_blank: t('solidus_advanced_pricing.all_customers') },
+                              { class: 'custom-select fullwidth' } %>
+      <span class="field-hint"><%= t('solidus_advanced_pricing.price_type_role_hint') %></span>
+    <% end %>
+  </div>
 </div>

data/lib/views/backend/spree/admin/price_types/index.html.erb

@@ -12,6 +12,7 @@
       <th><%= SolidusAdvancedPricing::PriceType.human_attribute_name(:name) %></th>
       <th><%= SolidusAdvancedPricing::PriceType.human_attribute_name(:code) %></th>
       <th><%= SolidusAdvancedPricing::PriceType.human_attribute_name(:position) %></th>
+      <th><%= SolidusAdvancedPricing::PriceType.human_attribute_name(:role_id) %></th>
       <th class="actions"></th>
     </tr>
   </thead>
@@ -21,6 +22,7 @@
         <td><%= price_type.name %></td>
         <td><%= price_type.code %></td>
         <td><%= price_type.position %></td>
+        <td><%= price_type.role&.name || t('solidus_advanced_pricing.all_customers') %></td>
         <td class="actions">
           <%= link_to_edit price_type, no_text: true %>
           <%= link_to_delete price_type, no_text: true %>