solidus_advanced_pricing 0.1.0

data/README.md

@@ -0,0 +1,377 @@
+# Solidus Advanced Pricing
+
+[![CircleCI](https://circleci.com/gh/solidusio-contrib/solidus_advanced_pricing.svg?style=shield)](https://circleci.com/gh/solidusio-contrib/solidus_advanced_pricing)
+[![codecov](https://codecov.io/gh/solidusio-contrib/solidus_advanced_pricing/branch/main/graph/badge.svg)](https://codecov.io/gh/solidusio-contrib/solidus_advanced_pricing)
+
+Adds price types, role-targeting, validity windows and admin notes to `Spree::Price`,
+so a variant can carry several competing prices — a wholesale tier, a scheduled sale,
+an employee price — and have the right one selected automatically.
+
+This gem is for prices that *are* a different amount. See
+[Relationship to solidus_promotions](#relationship-to-solidus_promotions) below if what
+you actually want is a discount.
+
+## Requirements
+
+- Solidus **4.5** or newer (`< 5`)
+- Rails 7.0–7.2
+- Ruby 3.1 or newer
+
+Tested on PostgreSQL, MySQL and SQLite.
+
+### Backporting to Solidus 4.0–4.4
+
+The 4.5 floor exists for one reason: the solidus_admin price types screen inherits from
+`SolidusAdmin::ResourcesController`, which was added in Solidus 4.5. Everything else —
+the model layer, price selection, the legacy backend, and the API — works from Solidus
+4.0.
+
+The seams for a backport are deliberately still in place:
+
+- `config/routes.rb` and `lib/solidus_advanced_pricing/engine.rb` each guard the
+  solidus_admin route and menu entry on `Spree.solidus_gem_version >= "4.5"`, so both
+  disable themselves on older versions rather than raising.
+- The `Gemfile` only installs `solidus_admin` when `SOLIDUS_BRANCH` is `main` or `v4.5+`.
+- `spec/features/admin/solidus_admin_price_types_spec.rb` and
+  `spec/lib/solidus_advanced_pricing/engine_spec.rb` skip when
+  `SolidusAdmin::ResourcesController` is undefined.
+
+So a backport is: lower the floor in the gemspec, add the older versions back to the CI
+matrix in `.github/workflows/test.yml`, and the solidus_admin half stays dormant below
+4.5 on its own. It was green on 4.1–4.4 that way before the floor was raised.
+
+## Installation
+
+Add solidus_advanced_pricing to your Gemfile:
+
+```shell
+bundle add solidus_advanced_pricing
+```
+
+Then run the installation generator:
+
+```shell
+bin/rails generate solidus_advanced_pricing:install
+```
+
+The generator:
+
+- Copies `config/initializers/solidus_advanced_pricing.rb`, which registers
+  `SolidusAdvancedPricing::PriceSelector` as `Spree::Config.variant_price_selector_class`.
+  This is what makes pricing type/role/validity-aware; without it the gem's columns exist
+  but are never consulted.
+- Copies this gem's three migrations into your app.
+- Offers to run `bin/rails db:migrate` for you.
+
+Those migrations add the columns described below to `spree_prices` and seed six
+price types (`wholesale`, `sale`, `clearance`, `employee`, `map`, `promotional`). Nothing about existing
+pricing behavior changes until you start setting the new columns — see
+[Backward compatibility](#backward-compatibility).
+
+`map` (minimum advertised price) and MSRP are easy to confuse but behave oppositely
+under cheapest-wins. MAP is a price you are *required* to sell at, so it is a real
+selling price and will be selected — a MAP-restricted variant often has no untyped
+base price at all. MSRP (not seeded here; add your own type if you want one) is a
+suggested price items are typically never sold at; because it sits *above* the
+selling price, cheapest-wins never selects it, which makes it a natural compare-at
+value for `price_of_type`.
+
+## What it adds to `Spree::Price`
+
+| Column | Type | Meaning |
+|---|---|---|
+| `price_type_id` | bigint, nullable | Belongs to `SolidusAdvancedPricing::PriceType`. `nil` means the untyped base price — exactly as `role_id: nil` means every customer. |
+| `role_id` | integer, nullable | Belongs to `Spree::Role`. `nil` means visible to everyone, including guests. |
+| `valid_from` | datetime, nullable | Window opens here. `nil` means always open. |
+| `valid_to` | datetime, nullable | Window closes here, **exclusive** — a price is valid up to but not including this instant, so a window ending at midnight and the next one starting at midnight don't both match. `nil` means never closes. |
+| `admin_notes` | text, nullable | Internal only. Never shown to customers; see [API](#api) for exactly who can see it. |
+
+`price_type_id`, `role_id`, `valid_from` and `valid_to` are all optional. `valid_to`
+must be after `valid_from` when both are set.
+
+## A price type is not access control
+
+**Setting a price's `price_type` to `employee` does nothing on its own.** Type and
+role are independent columns. A price typed `employee` with `role_id` left blank is
+visible to every customer, guests included — the name is just a label for the admin
+UI and reporting; it grants no eligibility by itself. Two of the six seeded types,
+`wholesale` and `employee`, exist specifically to invite this mistake.
+
+If a price should only be available to a specific group, you must **also** set `role`:
+
+```ruby
+employee_role = Spree::Role.find_or_create_by!(name: "employee")
+employee_type = SolidusAdvancedPricing::PriceType.find_by(code: "employee")
+
+variant.prices.create!(
+  amount: 45,
+  currency: "USD",
+  price_type: employee_type,
+  role: employee_role
+)
+```
+
+With both fields set, a guest or any customer without the `employee` role still sees
+the ordinary price; only a customer holding that role sees $45.
+
+## How a price is chosen
+
+For a given variant, currency, and requesting customer, `PriceSelector` picks a price
+in three steps:
+
+1. **Filter.** A price survives only if: its currency matches exactly; the current
+   time falls inside its validity window (or it has none); and it's visible to the
+   customer — `role_id` is blank, or the customer holds that role. If a price type is
+   pinned (see [Admin vs. customer lookups](#admin-vs-customer-lookups) below),
+   non-matching types are dropped here too.
+2. **Country specificity.** Among what survives, a price matching the customer's
+   country beats every country-agnostic (`country_iso: nil`) price — **even when the
+   agnostic price is cheaper.** This matches core Solidus behavior.
+3. **Cheapest wins.** Within the winning country bucket, the lowest `amount` is
+   selected. Ties are broken by price type position (lower `position` wins), then by
+   most recently updated, then by highest id.
+
+### Role is eligibility, never specificity
+
+A role only decides *whether* a price is a candidate, never how strongly it competes
+once it is one. A role-targeted price set **above** the untargeted price will never
+apply, because step 3 always takes the cheapest survivor:
+
+```
+Retail (no role):     $100
+Wholesale (wholesale): $120
+```
+
+A wholesale customer still pays $100 — their role makes the $120 price *eligible*,
+but the untargeted $100 price is cheaper and wins. This is intended, and it's the one
+genuinely surprising consequence of the design: if you want a role to guarantee a
+better price, that price has to actually be cheaper than what an untargeted customer
+would pay.
+
+### Admin vs. customer lookups
+
+`price_type_id` has three meaningful states in a pricing lookup:
+
+| `price_type_id` | Meaning |
+|---|---|
+| `nil` | Untyped base prices only. |
+| an integer id | Only that type. |
+| `:any` | No type filter — every type competes. |
+
+`SolidusAdvancedPricing::PricingOptions.default_price_attributes` pins
+`price_type_id` to `nil` and `role_id` to `nil`. This is what
+`Spree::Variant#default_price_or_build` and the admin price form build against, so an
+admin always edits the untyped base price rather than accidentally landing on a
+cheaper sale or wholesale row.
+
+Customer-facing lookups (`PricingOptions.from_line_item`, `.from_context`) set
+`price_type_id` to `:any` instead — every type competes — and populate
+`customer_role_ids` from the current user's roles, so the full set of eligible prices
+is considered. `:any` is a selector-only sentinel; it never reaches `Spree::Price`
+as a column value (`PricingOptions#search_arguments` strips it before querying).
+
+## Backward compatibility
+
+A store with no typed, windowed, or role-targeted prices — i.e. one that has only run
+the migrations and never set the new columns beyond their defaults — behaves exactly
+like core Solidus. This is pinned by
+[`spec/models/spree/backward_compatibility_spec.rb`](spec/models/spree/backward_compatibility_spec.rb).
+
+One real consequence to be aware of: if a variant's *only* prices all have validity
+windows and none is currently open, `variant.price` returns `nil` — the same thing
+core does when no price matches at all, not an error. Keep at least one open-ended
+(`valid_from`/`valid_to` both blank) base price per variant if you don't want a
+variant to become unpriced outside its scheduled windows.
+
+A second consequence: when a variant has no untyped base price at all (a MAP-only
+variant, for example), `variant.price` / `default_price` (and therefore
+`display_price`, `display_amount` and `has_default_price?`) fall back to the
+cheapest eligible typed price instead of returning nothing, so the admin never
+shows a blank price field. The fallback only relaxes the type filter — currency,
+the validity window and role visibility still apply, so a variant whose only typed
+price is expired or role-targeted still comes back unpriced. `base_price`
+deliberately does **not** fall back: it is the compare-at value shown next to the
+current price, and if it silently became equal to the current price there would
+be nothing left to strike through.
+
+## Caching
+
+Pricing lookups are cached, and the cache key includes:
+
+- the attributes core already keys on (currency, country, etc.)
+- the customer's *pricing-relevant* roles
+- a coarse time bucket
+
+The role component is mandatory, not optional: without it, the first customer to
+resolve a variant's price — guest or not — would have that price cached and served to
+everyone else who hits the same key, including a guest being served a role-gated
+wholesale price.
+
+Roles are narrowed to only those roles that some price actually references
+(`SolidusAdvancedPricing::PriceTypeCache.pricing_role_ids`), not the customer's full
+role list. This keeps cache key cardinality low without affecting which price is
+selected.
+
+The time bucket width is controlled by:
+
+```ruby
+Spree::Config.advanced_pricing_cache_granularity = 60 # seconds, default
+```
+
+Setting it to `0` disables the time component of the cache key entirely. This trades
+a slightly more precise validity boundary for cheaper caching: a price whose window
+just closed can keep being served from cache until something else invalidates the
+key. The default of 60 seconds bounds how stale a validity-window transition can be.
+
+## Admin
+
+**Legacy backend** (`solidus_backend`) gets the full experience:
+
+- The price form gains price type, role, validity (`valid_from`/`valid_to`), and
+  admin notes fields, added via Deface overrides
+  (`app/overrides/spree/admin/prices/_form/add_advanced_fields.html.erb.deface`).
+- The prices tables (both the single-variant and master-variant listings) gain
+  columns for type, role, and validity.
+- Price types get full CRUD at `/admin/price_types` (`spree.admin_price_types_path`),
+  linked from the settings sidebar (Deface override on
+  `spree/admin/shared/_configuration_menu`).
+
+**solidus_admin** gets a **price types index only**
+(`SolidusAdmin::PriceTypes::Index::Component`, at `solidus_admin.price_types_path`),
+linked from the main navigation (registered via `SolidusAdmin::Config.menu_items`
+in `lib/solidus_advanced_pricing/engine.rb`) whenever `solidus_admin` is mounted.
+It inherits from `SolidusAdmin::ResourcesController`, which is why the gem requires
+Solidus 4.5 (see Requirements).
+Its rows link back to the legacy backend for edit/new; per-variant price management
+stays entirely in the legacy backend. This is deliberate: upstream Solidus's new
+admin has no prices screen of its own yet, and building one here would mean guessing
+at a design that hasn't landed upstream. Be aware that this component is built
+against pre-1.0 `solidus_admin` internals (`SolidusAdmin::UI::Pages::Index::Component`,
+`SolidusAdmin::ResourcesController`) and may need updating when you upgrade
+`solidus_admin`.
+
+## API
+
+```
+GET /api/variants/:variant_id/prices
+GET /api/variants/:variant_id/prices/:id
+```
+
+Each price is serialized with its advanced attributes — `price_type_code`,
+`price_type_name`, `role_id`, `valid_from`, `valid_to` — and `admin_notes` is included
+only for a caller who can update that price.
+
+**This endpoint is admin-facing.** Core's `DefaultCustomer` permission set (what every
+non-admin API token gets) grants no rights on `Spree::Price` at all, so a non-admin
+token receives `401 Unauthorized` on the whole endpoint, not a filtered response.
+Headless storefronts do not need this endpoint for normal pricing: core's variants
+endpoint already serializes `price` and `display_price` through this gem's selector
+automatically, because the selector is registered globally via
+`Spree::Config.variant_price_selector_class`.
+
+## Storefront: compare-at (strikethrough) pricing
+
+`Spree::Variant#price_of_type` and `#base_price` fetch a specific typed price
+alongside the customer's normal price, so a storefront can render a struck-through
+"was" price next to an active sale:
+
+```erb
+<% base    = variant.base_price(current_pricing_options) %>
+<% current = variant.price_for_options(current_pricing_options) %>
+
+<% if base && current && base.amount > current.amount %>
+  <s><%= base.display_amount %></s>
+<% end %>
+<%= current.display_amount %>
+```
+
+`price_of_type` takes the same pricing options as `price_for_options`, so the
+comparison price respects the customer's currency, country, roles, and the current
+time — not an admin-context lookup. `nil` means the base (untyped) price, which is
+what `base_price` passes under the hood. `price_of_type` also accepts a `PriceType`
+record, an id, or a type code (e.g. `variant.price_of_type("sale", current_pricing_options)`);
+an unresolvable code raises `ArgumentError` rather than silently falling back to the
+base price.
+
+## Known limitations
+
+- **Search and taxon filtering ignore validity windows.** `search_arguments`
+  (`SolidusAdvancedPricing::PricingOptions#search_arguments`), which core's product
+  search and taxon filtering query directly, is a plain equality hash passed to
+  `Spree::Price.where(...)`. It can express type and role but has no way to express
+  "and the validity window contains now." A variant whose only price expired
+  yesterday can still appear in search results, even though
+  `Spree::Variant#price_for_options` correctly returns `nil` for it and
+  `Spree::Variant.with_prices` (used by listings that call it directly) correctly
+  excludes it. Closing this gap would require overriding the two core search call
+  sites as well, which this gem does not currently do.
+- **No role exclusion.** Only inclusion is expressible via `role_id`. "Everyone
+  except employees" cannot be written directly — approximate it with one targeted
+  price per role you *do* want to include.
+- **One role per price.** `role_id` targets a single `Spree::Role`. A customer may
+  hold several roles and will see every price targeted at any role they hold (the
+  cheapest of them wins, per [how a price is chosen](#how-a-price-is-chosen)) — but a
+  single price row can't itself target more than one role.
+
+## Relationship to solidus_promotions
+
+This gem is for prices that genuinely *are* a different amount for a given customer
+or window: wholesale tiers, price lists, a scheduled rollover to a sale price. It
+does not reimplement promotion machinery — no codes, no usage limits, no stacking
+rules. A `sale`-typed price with a validity window is a perfectly good way to model a
+time-boxed sale here.
+
+For discounting an existing price — percentage or fixed-amount off, promo codes,
+usage limits, stacking behavior — use
+[`solidus_promotions`](https://github.com/solidusio/solidus_promotions) instead.
+`solidus_promotions` does ship `Benefits::AdvertisePrice` and price-level conditions,
+and it can look similar to what this gem does on the surface, but a promotion
+*discounts* a price rather than replacing it. For B2B-style pricing that is the wrong
+semantics: the retail price still leaks (it's the "was" price the discount is
+computed from), and the sale reports as promotional revenue rather than as the
+customer's actual price. Use this gem when the price itself should simply be
+different for that customer or window.
+
+## Development
+
+```shell
+bin/rake extension:test_app
+bundle exec rspec
+```
+
+To run [Rubocop](https://github.com/bbatsov/rubocop) static code analysis run
+
+```shell
+bundle exec rubocop
+```
+
+When testing your application's integration with this extension you may use its factories.
+You can load Solidus core factories along with this extension's factories using this statement:
+
+```ruby
+SolidusDevSupport::TestingSupport::Factories.load_for(SolidusAdvancedPricing::Engine)
+```
+
+### Running the sandbox
+
+To run this extension in a sandboxed Solidus application, you can run `bin/sandbox`. The path for
+the sandbox app is `./sandbox` and `bin/rails` will forward any Rails commands to
+`sandbox/bin/rails`.
+
+Here's an example:
+
+```
+$ bin/rails server
+=> Booting Puma
+=> Rails 6.0.2.1 application starting in development
+* Listening on tcp://127.0.0.1:3000
+Use Ctrl-C to stop
+```
+
+### Releasing new versions
+
+Please refer to the [dedicated page](https://github.com/solidusio/solidus/wiki/How-to-release-extensions) in the Solidus wiki.
+
+## License
+
+Copyright (c) 2026 Patrick McMorran, released under the New BSD License.

data/Rakefile

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "solidus_dev_support/rake_tasks"
+SolidusDevSupport::RakeTasks.install
+
+task default: "extension:specs"
+
+# The stock dummy app template (spree/testing_support, as of solidus_dev_support
+# 2.12) predates solidus_admin and neither mounts its engine nor builds its
+# assets, so a freshly generated dummy app 404s on every admin page. Both fixes
+# below only apply when solidus_admin is actually a dependency of this gem.
+if Rake::Task.task_defined?("extension:test_app") && Gem.loaded_specs.key?("solidus_admin")
+  Rake::Task["extension:test_app"].enhance do
+    dummy_root = File.expand_path("spec/dummy", __dir__)
+
+    # solidus_admin ships a precompiled tailwind.css in the released gem, but the
+    # git-source checkout used in dev/CI omits it (built only by `rake release`).
+    # Without it, Sprockets raises FileNotFound for any admin page. A stub is
+    # sufficient here since these specs don't assert on styling.
+    tailwind_css = File.join(dummy_root, "app/assets/builds/solidus_admin/tailwind.css")
+    unless File.exist?(tailwind_css)
+      require "fileutils"
+      FileUtils.mkdir_p(File.dirname(tailwind_css))
+      FileUtils.touch(tailwind_css)
+    end
+
+    # Per the solidus_admin README, SolidusAdmin::Engine must be mounted *before*
+    # Spree::Core::Engine so its routes take precedence over the legacy backend's
+    # for any resource both admins define (otherwise Spree::Core::Engine, mounted
+    # at '/', claims every request first and solidus_admin is never reached).
+    routes_path = File.join(dummy_root, "config/routes.rb")
+    routes = File.read(routes_path)
+    unless routes.include?("SolidusAdmin::Engine")
+      File.write(routes_path, routes.sub(
+        "Rails.application.routes.draw do",
+        "Rails.application.routes.draw do\n  mount SolidusAdmin::Engine, at: '/admin' if defined?(SolidusAdmin::Engine)"
+      ))
+    end
+  end
+end

data/app/assets/javascripts/spree/backend/solidus_advanced_pricing.js

@@ -0,0 +1,2 @@
+// Placeholder manifest file.
+// the installer will append this file to the app vendored assets here: vendor/assets/javascripts/spree/backend/all.js'

data/app/assets/javascripts/spree/frontend/solidus_advanced_pricing.js

@@ -0,0 +1,2 @@
+// Placeholder manifest file.
+// the installer will append this file to the app vendored assets here: vendor/assets/javascripts/spree/frontend/all.js'

data/app/assets/stylesheets/spree/backend/solidus_advanced_pricing.css

@@ -0,0 +1,4 @@
+/*
+Placeholder manifest file.
+the installer will append this file to the app vendored assets here: 'vendor/assets/stylesheets/spree/backend/all.css'
+*/

data/app/assets/stylesheets/spree/frontend/solidus_advanced_pricing.css

@@ -0,0 +1,4 @@
+/*
+Placeholder manifest file.
+the installer will append this file to the app vendored assets here: 'vendor/assets/stylesheets/spree/frontend/all.css'
+*/

data/app/decorators/models/solidus_advanced_pricing/spree/app_configuration_decorator.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SolidusAdvancedPricing
+  module Spree
+    module AppConfigurationDecorator
+      def self.prepended(base)
+        return if base.defined_preferences.include?(:advanced_pricing_cache_granularity)
+
+        # Seconds of granularity for the time component of pricing cache keys.
+        # 0 omits time from the key entirely; prices may then be cached past their window.
+        base.preference :advanced_pricing_cache_granularity, :integer, default: 60
+      end
+
+      ::Spree::AppConfiguration.prepend self
+    end
+  end
+end

data/app/decorators/models/solidus_advanced_pricing/spree/permitted_attributes_decorator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SolidusAdvancedPricing
+  module Spree
+    module PermittedAttributesDecorator
+      # `prepend`ing PermittedAttributes.singleton_class hands `prepended` the
+      # singleton class itself, and mattr_accessor rejects being called on
+      # one ("module attributes should be defined directly on class, not
+      # singleton") -- so the accessor is defined on the module directly.
+      #
+      # Not a module-level constant: solidus_support `load`s this file on
+      # every to_prepare, which would otherwise warn on every reload
+      # ("already initialized constant").
+      def self.prepended(_base)
+        target = ::Spree::PermittedAttributes
+
+        unless target.respond_to?(:price_attributes)
+          target.mattr_accessor(:price_attributes) { [:amount, :currency, :country_iso] }
+        end
+
+        target.price_attributes |= [:price_type_id, :role_id, :valid_from, :valid_to, :admin_notes]
+      end
+
+      ::Spree::PermittedAttributes.singleton_class.prepend self
+    end
+  end
+end

data/app/decorators/models/solidus_advanced_pricing/spree/price_decorator.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module SolidusAdvancedPricing
+  module Spree
+    module PriceDecorator
+      def self.prepended(base)
+        # solidus_support reloads decorators via bare `load` on every to_prepare;
+        # re-running this method would redefine the association and its
+        # callbacks (valid_to_after_valid_from, after_commit) each time.
+        return if base.reflect_on_association(:price_type)
+
+        # with_discarded: a price keeps its type after an admin retires it.
+        # optional: true because price_type_id nil is a real value here — the
+        # untyped base price — not a validation gap.
+        base.belongs_to :price_type,
+          -> { with_discarded },
+          class_name: "SolidusAdvancedPricing::PriceType",
+          inverse_of: :prices,
+          optional: true
+
+        base.belongs_to :role,
+          class_name: "::Spree::Role",
+          optional: true
+
+        base.validate :valid_to_after_valid_from
+
+        # valid_to is exclusive so a window ending at midnight and the next one starting at midnight do not both match.
+        base.scope :valid_at, ->(time) {
+          where(arel_table[:valid_from].eq(nil).or(arel_table[:valid_from].lteq(time)))
+            .where(arel_table[:valid_to].eq(nil).or(arel_table[:valid_to].gt(time)))
+        }
+
+        base.scope :visible_to_roles, ->(role_ids) {
+          where(role_id: [nil, *role_ids])
+        }
+
+        base.scope :for_price_type, ->(price_type) {
+          where(price_type_id: price_type)
+        }
+
+        base.after_commit { SolidusAdvancedPricing::PriceTypeCache.clear }
+      end
+
+      private
+
+      def valid_to_after_valid_from
+        return if valid_from.blank? || valid_to.blank?
+        return if valid_to > valid_from
+
+        errors.add(:valid_to, :must_be_after_valid_from)
+      end
+
+      ::Spree::Price.prepend self
+    end
+  end
+end

data/app/decorators/models/solidus_advanced_pricing/spree/role_decorator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module SolidusAdvancedPricing
+  module Spree
+    module RoleDecorator
+      def self.prepended(base)
+        # No re-run guard needed: unlike belongs_to, a symbol-filtered callback
+        # dedupes on re-registration, so this is already safe under to_prepare reloads.
+        base.before_destroy :prevent_destroying_referenced_role
+      end
+
+      private
+
+      def prevent_destroying_referenced_role
+        return unless ::Spree::Price.with_discarded.exists?(role_id: id)
+
+        errors.add(:base, :referenced_by_prices)
+        throw :abort
+      end
+
+      ::Spree::Role.prepend self
+    end
+  end
+end

data/app/decorators/models/solidus_advanced_pricing/spree/variant_decorator.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SolidusAdvancedPricing
+  module Spree
+    module VariantDecorator
+      def self.prepended(base)
+        base.singleton_class.prepend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Core checks only currency and country, so an expired or role-targeted
+        # price still makes a variant look purchasable in listings.
+        def with_prices(pricing_options = ::Spree::Config.default_pricing_options)
+          relation = ::Spree::Price
+            .where(::Spree::Variant.arel_table[:id].eq(::Spree::Price.arel_table[:variant_id]))
+            .where(currency: pricing_options.currency)
+            .where(country_iso: [pricing_options.country_iso, nil].uniq)
+
+          relation = relation.valid_at(pricing_options.at) if pricing_options.try(:at)
+          if pricing_options.respond_to?(:customer_role_ids)
+            relation = relation.visible_to_roles(pricing_options.customer_role_ids)
+          end
+
+          where(relation.arel.exists)
+        end
+      end
+
+      # nil means the untyped base price. Accepts a PriceType, an id, or a code.
+      def price_of_type(price_type, pricing_options = ::Spree::Config.default_pricing_options)
+        price_selector.price_for_options(
+          pricing_options.with(price_type_id: SolidusAdvancedPricing.resolve_price_type_id(price_type))
+        )
+      end
+
+      # The untyped price a sale or role-targeted price undercuts -- the value to
+      # strike through in a storefront.
+      def base_price(pricing_options = ::Spree::Config.default_pricing_options)
+        price_of_type(nil, pricing_options)
+      end
+
+      # A MAP-restricted variant may carry no untyped price at all; fall back so
+      # variant.price is never blank when some price exists.
+      def default_price
+        super || price_selector.price_for_options(
+          ::Spree::Config.default_pricing_options.with(price_type_id: :any)
+        )
+      end
+
+      ::Spree::Variant.prepend self
+    end
+  end
+end