solidus_advanced_pricing 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3dd5e3bb515d712553025000029ebf739470339c09c0a615b70084a134ceff3c
-  data.tar.gz: 065ce411b91483ac3e6b3ef13f09144d5015c986cc27fbbff9c1544bf4978355
+  metadata.gz: 0feded43570200af31d61d2822614677e232d696b480196576c0651edafee278
+  data.tar.gz: 20b1184e197fc387a095d5af68b7936fc894ccd213b6386a259bff8f0e77e6e5
 SHA512:
-  metadata.gz: 740e98329afaa1a757bde107a9ea231d22b4a3c92ae0840b0a3ea9462b0d6227b3d93acfc05a4c27a43ec285b4e0fc02b99056f3352950e6047ac7919a975c56
-  data.tar.gz: e4426d9b9fac0bda2db9a87f228f424ced485a16003c5ec220dfa845756cdf87c637605f2c8e6fe0f4802149b9f16f6207efab762b43db73e0510f2ab25bea13
+  metadata.gz: c2a90ff27650243c41246a0dfa7b9cd1b6a672c73060dcf6abcaf007f101baefdf3d627c28301ac06e576b1a7bb1a4f9602135935a6cbe2327ea62918fa20d20
+  data.tar.gz: 5b57c0ee2ef362b15e377db52ebd80c1624db43c3c94d69846e8e93bfacb7ce17864766f35cb9ee56c8113a424b3afb5a6d550be20b18872eefa6f8bd04ef595

data/.gitignore

@@ -19,3 +19,4 @@ spec/examples.txt
 .rvmrc
 .ruby-version
 .ruby-gemset
+docs/superpowers

data/CHANGELOG.md

@@ -1,3 +1,118 @@
 # Changelog
 
-See https://github.com/solidusio-contrib/solidus_advanced_pricing/releases or OLD_CHANGELOG.md for older versions.
+All notable changes to this project are documented here. The format is based on
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.3.0] - 2026-09-23
+
+### Added
+
+- **Write endpoints for prices.** `POST`, `PATCH` and `DELETE` on
+  `/api/variants/:variant_id/prices`, so prices can be administered over the API rather
+  than only read. `DELETE` soft-deletes.
+- **`price_type_code` is accepted anywhere `price_type_id` is** on a price payload. Ids
+  are per-database and codes are not, so a payload written against staging works unchanged
+  against production. Sending both is a `422`; an explicit null means the untyped base
+  price.
+- **`GET /api/price_types`**, listing the types a price payload may reference with their
+  ids, codes, names, positions and default roles. Read-only and admin-authorized.
+- **Batch writes: `POST /api/prices/batch`** and the `SolidusAdvancedPricing::PriceBatch`
+  service behind it. Many prices across many variants in one call, matched on the natural
+  key (variant, currency, country, price type, role, `valid_from`) so re-sending a payload
+  is a no-op rather than a pile of duplicates. Always answers `200` with a per-row report.
+  - `dry_run: true` runs the real work in a transaction and rolls it back, so the report
+    reflects what the write would do rather than a guess at it.
+  - A row carrying `id` names that price outright: `variant_id`/`sku` become optional and
+    are checked rather than applied, natural-key fields such as `currency`, `role_id` and
+    `valid_from` become editable, and an unknown or deleted `id` is a row error rather than
+    a new price.
+  - `mode: "replace"` also discards prices the payload left out — scoped to price types and
+    variants the payload actually named.
+  - Rows are applied independently in savepoints, so one bad row does not take the batch
+    down and a row-wise retry is possible.
+  - `SolidusAdvancedPricing.config.batch_row_limit` (default 500) and
+    `config.batch_guard`, a callable invoked with every row written and nothing committed,
+    which may raise to abort. The seam for store policy that does not belong in the gem.
+- `currency` now defaults to `Spree::Config.default_pricing_options.currency` when a
+  created price omits it.
+
+### Fixed
+
+- **`GET /api/variants/:variant_id/prices` listed soft-deleted prices.**
+  `Spree::Variant#prices` is declared `-> { with_discarded }` in core, which the endpoint
+  inherited, so anything an admin had deleted still came back. Deleted prices are now
+  excluded by default; `?show_deleted=true` opts back in.
+
+### Changed
+
+- **`price_type` is now immutable on a persisted price**, raising a validation error
+  instead of silently retyping the row. The admin form has disabled that select since
+  0.2.0; this closes the same gap at the model layer so the API cannot route around it.
+  Re-sending an unchanged `price_type_id` is still fine. Code that deliberately retypes an
+  existing price must now discard it and create a replacement, or use `update_columns` to
+  bypass validation in a data migration.
+
+## [0.2.0] - 2026-09-23
+
+### Added
+
+- Price types can carry a **default role**. A price with no role of its own inherits its
+  type's role, so a type like `employee` can be targeted once instead of on every price.
+  A price's own role still wins when set. This is the recommended way to avoid publishing
+  a role-named price to everyone.
+- `map` and `promotional` price types are now seeded, bringing the set to six.
+
+### Fixed
+
+- **An untyped price could not be created in the admin.** The price type select had no
+  blank option, and defaulted to its first entry — so every price created through the UI
+  was silently typed `wholesale`. A regression from making `price_type_id` nullable in
+  0.1.0.
+- **Validity windows lost their time.** `valid_from` and `valid_to` are datetime columns,
+  but the form used Solidus' `.datepicker` class, which is initialised as flatpickr
+  without `enableTime` and can only produce a date. Any time an admin set was dropped to
+  midnight. Now rendered as native `datetime-local` inputs.
+- Deleting a `Spree::Role` referenced by a price type's default role raised a raw foreign
+  key violation instead of being blocked with an error.
+
+### Changed
+
+- **The price type is now locked once a price exists**, matching how core treats the
+  country field. Changing which pricing dimension an existing row belongs to reinterprets
+  historical data rather than correcting it.
+
+## [0.1.0] - 2026-09-23
+
+Initial release.
+
+### Added
+
+- **Price types** — an admin-managed model with a code, name and position. `price_type_id`
+  on `spree_prices` is nullable; `NULL` means the untyped base price.
+- **Validity windows** — optional `valid_from` / `valid_to` on each price. `valid_to` is
+  exclusive.
+- **Role targeting** — an optional `Spree::Role` per price. Blank means every customer,
+  guests included. Role is *eligibility only*, never specificity: a role-targeted price set
+  above the untargeted price never applies.
+- **`admin_notes`** — internal commentary on a price, never rendered to customers.
+- A `PriceSelector` and `PricingOptions` registered through
+  `Spree::Config.variant_price_selector_class`: filter by currency, type, window and role;
+  prefer the country-specific bucket over the any-country fallback; cheapest wins.
+- `Spree::Variant#price_of_type` and `#base_price` for compare-at (strikethrough) display.
+- `Spree::Variant.with_prices` now honours validity windows and role targeting, so a
+  variant whose only price has expired no longer counts as purchasable.
+- Full legacy backend admin: price fields, table columns, a price types CRUD, and a
+  settings sidebar link. A price types index for `solidus_admin`.
+- `GET /api/variants/:variant_id/prices` — admin-facing; `admin_notes` is exposed only to
+  a user who can update the price.
+
+### Security
+
+- Pricing cache keys include the customer's pricing-relevant roles and a coarse time
+  bucket. Without the role component a role-targeted price would be cached and served to
+  guests.
+
+[0.3.0]: https://github.com/fcpeuro/solidus_advanced_pricing/compare/v0.2.0...v0.3.0
+[0.2.0]: https://github.com/fcpeuro/solidus_advanced_pricing/compare/v0.1.0...v0.2.0
+[0.1.0]: https://github.com/fcpeuro/solidus_advanced_pricing/releases/tag/v0.1.0

data/README.md

@@ -80,8 +80,8 @@ value for `price_of_type`.
 
 | 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. |
+| `price_type_id` | bigint, nullable | Belongs to `SolidusAdvancedPricing::PriceType`. `nil` means the untyped base price — exactly as `role_id: nil` means "inherit from the type" (see below). |
+| `role_id` | integer, nullable | Belongs to `Spree::Role`. `nil` does **not** mean "public" — it means the price's visibility is inherited from its price type, if any. See [Effective role](#effective-role) below. |
 | `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. |
@@ -89,15 +89,61 @@ value for `price_of_type`.
 `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
+`SolidusAdvancedPricing::PriceType` also carries a nullable `role_id` of its own —
+the type's *default* role. See [Effective role](#effective-role).
 
-**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.
+## Effective role
 
-If a price should only be available to a specific group, you must **also** set `role`:
+A price's visibility to a customer is never decided by its own `role_id` alone. It is
+decided by its **effective role**:
+
+```ruby
+price.role_id || price.price_type&.role_id
+```
+
+**`nil` on a price's own `role_id` means "inherit from the type," not "explicitly
+public."** If the price has no type, or its type has no default role, the effective
+role is `nil` and the price is visible to everyone, including guests — exactly as
+before this feature existed. But once a price type carries a default role, every
+price of that type inherits it unless the price sets its own `role_id`.
+
+The deliberate consequence: **if the `employee` type has a default role, you cannot
+make an employee-typed price public.** Its `role_id` is either blank (inherits the
+type's role) or set to some other role (its own, more specific, targeting) — there is
+no value that means "ignore the type's default and show this to everyone." That
+tradeoff is the point. It turns this gem's biggest footgun — a price typed `employee`
+with no role, visible to every customer including guests — into something a store
+fixes once, on the type, instead of something every price author must remember.
+
+Stores are **not** seeded with any type-level defaults; all six seeded types
+(`wholesale`, `sale`, `clearance`, `employee`, `map`, `promotional`) ship with
+`role_id: nil`, because the correct role for, say, `employee` doesn't exist in every
+store. Set it yourself once eligibility should be automatic:
+
+```ruby
+employee_role = Spree::Role.find_or_create_by!(name: "employee")
+employee_type = SolidusAdvancedPricing::PriceType.find_by(code: "employee")
+employee_type.update!(role: employee_role)
+
+# Every price typed `employee`, existing or future, is now visible only to
+# customers holding the `employee` role -- no per-price role_id required.
+variant.prices.create!(amount: 45, currency: "USD", price_type: employee_type)
+```
+
+## A price type is not access control by default
+
+**Setting a price's `price_type` to `employee` does nothing on its own unless the
+type itself carries a default role.** Type and role are independent columns until a
+store links them via the type's `role_id`. A price typed `employee`, with the type
+having no default role and the price's own `role_id` left blank, is visible to every
+customer, guests included — the type name alone 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 — and setting a
+default role on the type (above) is the recommended way to close it for good, rather
+than remembering to set `role_id` on every price of that type.
+
+If you'd rather target one specific price without touching the type, set `role`
+directly on it:
 
 ```ruby
 employee_role = Spree::Role.find_or_create_by!(name: "employee")
@@ -112,7 +158,9 @@ variant.prices.create!(
 ```
 
 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.
+the ordinary price; only a customer holding that role sees $45. This still works
+exactly as before even once the type has its own default role — an explicit
+`role_id` on the price always wins over the type's.
 
 ## How a price is chosen
 
@@ -121,9 +169,10 @@ 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.
+   customer — its [effective role](#effective-role) 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.
@@ -253,15 +302,20 @@ against pre-1.0 `solidus_admin` internals (`SolidusAdmin::UI::Pages::Index::Comp
 ## API
 
 ```
-GET /api/variants/:variant_id/prices
-GET /api/variants/:variant_id/prices/:id
+GET    /api/variants/:variant_id/prices
+GET    /api/variants/:variant_id/prices/:id
+POST   /api/variants/:variant_id/prices
+PATCH  /api/variants/:variant_id/prices/:id
+DELETE /api/variants/:variant_id/prices/:id
+
+GET    /api/price_types
 ```
 
 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
+**These endpoints are 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
@@ -269,6 +323,179 @@ endpoint already serializes `price` and `display_price` through this gem's selec
 automatically, because the selector is registered globally via
 `Spree::Config.variant_price_selector_class`.
 
+### Writing prices
+
+```shell
+curl -X POST https://store.example/api/variants/42/prices \
+  -H "Authorization: Bearer $SPREE_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{"price": {"amount": "35.00", "price_type_code": "sale",
+                 "valid_from": "2026-11-27T00:00:00Z",
+                 "valid_to": "2026-12-02T00:00:00Z"}}'
+```
+
+- **`price_type_code` is accepted anywhere `price_type_id` is**, and is the better choice
+  for anything scripted: ids differ between your staging and production databases, codes
+  do not. Sending both is a `422`. Sending `price_type_code: null` (or `""`) means the
+  untyped base price, the same as omitting `price_type_id`.
+- **`currency` defaults to `Spree::Config.default_pricing_options.currency`** when the
+  payload omits it.
+- **`price_type` cannot be changed once a price exists.** The admin form has disabled that
+  select on persisted prices since 0.2.0, and the model now enforces it, so the API can't
+  route around it. Retyping a row reinterprets history instead of correcting it; to fix a
+  mistyped price, delete it and create the right one. Re-sending the *same*
+  `price_type_id` on an update is fine, so ordinary read-modify-write clients are
+  unaffected.
+- **`DELETE` soft-deletes** (sets `deleted_at`), so the row stays available to anything
+  reporting on what a variant used to cost. Deleted prices are excluded from the listing;
+  pass `?show_deleted=true` to include them. Writes never reach a deleted price — updating
+  one is a `404`.
+
+Remember that the selector takes the **cheapest** eligible price
+([how a price is chosen](#how-a-price-is-chosen)). A role-targeted price written *above*
+the untargeted price will never apply, and the API will not warn you about it.
+
+Nothing here stops you deleting a variant's only open-ended price, which leaves that
+variant unpriced outside its remaining windows (see
+[Backward compatibility](#backward-compatibility)). If that matters to your store, assert
+it on your side.
+
+### Batch writes
+
+```
+POST /api/prices/batch
+```
+
+One call, many prices, across many variants. Always answers `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.
+
+```shell
+curl -X POST https://store.example/api/prices/batch \
+  -H "Authorization: Bearer $SPREE_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+        "mode": "upsert",
+        "dry_run": true,
+        "prices": [
+          {"sku": "ABC-123", "amount": "35.00", "price_type_code": "sale"},
+          {"sku": "DEF-456", "amount": "45.00", "price_type_code": "sale"},
+          {"id": 907, "amount": "29.99"}
+        ]
+      }'
+```
+
+```json
+{
+  "mode": "upsert",
+  "dry_run": true,
+  "summary": {"created": 1, "updated": 1},
+  "results": [
+    {"index": 0, "status": "created", "variant_id": 42},
+    {"index": 1, "status": "updated", "price_id": 907, "variant_id": 43}
+  ]
+}
+```
+
+Each row takes the same attributes as a single price, plus `id` and `sku`. Per-row
+`status` is `created`, `updated`, `unchanged`, `deleted` or `error`; an `error` row carries
+`errors` and nothing was written for it.
+
+**Send it as JSON.** Form encoding cannot represent an array of hashes whose rows have
+different keys — Rack starts a new hash only when it meets a key it has already seen, so
+`[{"id": 1, "amount": 2}, {"variant_id": 3, "amount": 4}]` arrives as
+`[{"id": 1, "amount": 2, "variant_id": 3}, {"amount": 4}]`. Set
+`Content-Type: application/json`.
+
+#### Naming a row: `id`, or the natural key
+
+**If a row carries `id`, that is the price it changes** — nothing is inferred, nothing can
+be mismatched, and `variant_id`/`sku` become optional (the price already knows its
+variant; supply one and it is checked, not applied). An `id` that does not exist, or that
+has been deleted, is an `error` on that row rather than a new price. This is the right
+shape for read-modify-write: fetch the prices, change what you need, send them back.
+
+**Without an `id`, the row is matched on the natural key** — variant, currency, country,
+price type, role and `valid_from`. Those are the dimensions a price legitimately varies
+on, so an upsert on them is unambiguous, and re-sending the same payload is a no-op rather
+than a pile of duplicates.
+
+That second path is not redundant with the first. A payload authored where Solidus ids are
+unknown — a supplier feed, a merchandiser's spreadsheet, a backfill from another system —
+has no ids to send, and `id`-or-create alone would make every re-run duplicate the whole
+file. The natural key is what makes a nightly feed idempotent.
+
+`valid_to` is deliberately *not* in the key: extending or shortening a window edits the
+price you already have. `valid_from` is matched to the second, because a client that read a
+price back and re-sent its `valid_from` may have dropped the sub-second part in
+serialization, and treating that as a different price would duplicate the row — and under
+`replace`, discard the original. Sending the `id` sidesteps that question entirely.
+
+Two rows in one payload naming the same price — by `id` or by key — are an `error` on the
+second, not a silent last-one-wins.
+
+Fields in the natural key (`currency`, `country_iso`, `role_id`, `valid_from`) can only be
+*changed* by a row that names the price by `id`; on a keyed row they are how the price was
+found. `price_type` cannot be changed either way — see
+[Writing prices](#writing-prices).
+
+#### Modes
+
+- **`upsert`** (default) creates or updates the rows you send and touches nothing else.
+- **`replace`** additionally discards prices the payload *left out* — but only of a price
+  type the payload named, on a variant the payload named. A `replace` that sends one sale
+  price will not reach that variant's base price or its wholesale tier, and will not reach
+  any other variant. Deleted rows appear in the report with `status: "deleted"`.
+
+#### `dry_run`
+
+`dry_run: true` does the real work against the database inside a transaction and rolls it
+back, so the report reflects what the write would actually do — validations, type casting
+and constraints included — rather than a guess at it. Ids are omitted from `created` rows
+on a dry run, since they are about to stop existing.
+
+**Use it.** The failure mode of a bulk price load is a silent one.
+
+#### Atomicity
+
+Rows are applied independently, each in its own savepoint: one bad row does not take the
+batch down, and the successful rows are committed. This is what makes a row-wise retry
+possible. If you need all-or-nothing, run the payload with `dry_run: true` first and only
+send it for real once the report is clean.
+
+#### Limits and store policy
+
+`Spree::Config` is not involved; the extension has its own configuration:
+
+```ruby
+SolidusAdvancedPricing.configure do |config|
+  config.batch_row_limit = 500 # default
+
+  # Called once every row is written and before the transaction commits.
+  # Raise to abort the whole batch.
+  config.batch_guard = ->(batch) do
+    raise TooMuchMovement if batch.summary.fetch(:updated, 0) > 200
+  end
+end
+```
+
+A batch over `batch_row_limit` is refused with a `422` before any row is looked at — a
+synchronous request has to stay inside the web timeout, and anything larger belongs in a
+background job.
+
+`batch_guard` 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 where it can see the finished picture and still stop it.
+
+### Reading price types
+
+`GET /api/price_types` lists the types a price payload may reference — `id`, `code`,
+`name`, `position` and the type's default `role_id` — in `position` order. Retired
+(discarded) types are omitted, since they are no longer a valid choice; historical prices
+still report their own type's code through the prices endpoints. The endpoint is
+read-only and admin-authorized: creating a pricing dimension is an admin act, not an API
+one.
+
 ## Storefront: compare-at (strikethrough) pricing
 
 `Spree::Variant#price_of_type` and `#base_price` fetch a specific typed price

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

@@ -23,6 +23,7 @@ module SolidusAdvancedPricing
           optional: true
 
         base.validate :valid_to_after_valid_from
+        base.validate :price_type_is_immutable
 
         # 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) {
@@ -30,8 +31,23 @@ module SolidusAdvancedPricing
             .where(arel_table[:valid_to].eq(nil).or(arel_table[:valid_to].gt(time)))
         }
 
+        # Tests the *effective* role (price's own role_id, falling back to its
+        # type's) via COALESCE over a LEFT JOIN, not just the price's column —
+        # a price whose type carries a default role must be excluded from a
+        # guest's listing even though the price row itself has role_id: nil.
+        # left_joins(:price_type) does not apply PriceType's `kept` default
+        # scope (verified empirically), so a retired type's default role still
+        # applies to its historical prices.
         base.scope :visible_to_roles, ->(role_ids) {
-          where(role_id: [nil, *role_ids])
+          price_types_table = SolidusAdvancedPricing::PriceType.arel_table
+          effective_role_id = Arel::Nodes::NamedFunction.new(
+            "COALESCE", [arel_table[:role_id], price_types_table[:role_id]]
+          )
+
+          condition = effective_role_id.eq(nil)
+          condition = condition.or(effective_role_id.in(role_ids)) if role_ids.present?
+
+          left_joins(:price_type).where(condition)
         }
 
         base.scope :for_price_type, ->(price_type) {
@@ -41,8 +57,24 @@ module SolidusAdvancedPricing
         base.after_commit { SolidusAdvancedPricing::PriceTypeCache.clear }
       end
 
+      # nil on the price means "inherit from the type", not "public".
+      def effective_role_id
+        role_id || SolidusAdvancedPricing::PriceTypeCache.role_id_for(price_type_id)
+      end
+
       private
 
+      # The admin form has disabled this select on persisted records since 0.2.0;
+      # the API would otherwise be a way around that. Retyping an existing row
+      # reinterprets history rather than correcting it -- the fix for a
+      # mistyped price is to discard it and create the right one.
+      def price_type_is_immutable
+        return if new_record?
+        return unless price_type_id_changed?
+
+        errors.add(:price_type_id, :cannot_be_changed)
+      end
+
       def valid_to_after_valid_from
         return if valid_from.blank? || valid_to.blank?
         return if valid_to > valid_from

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

@@ -12,7 +12,9 @@ module SolidusAdvancedPricing
       private
 
       def prevent_destroying_referenced_role
-        return unless ::Spree::Price.with_discarded.exists?(role_id: id)
+        referenced = ::Spree::Price.with_discarded.exists?(role_id: id) ||
+          SolidusAdvancedPricing::PriceType.with_discarded.exists?(role_id: id)
+        return unless referenced
 
         errors.add(:base, :referenced_by_prices)
         throw :abort