Skip to content

armgit / spree

Public Imported from GitHub
0

Open Source Platform for DTC, B2B Commerce, Marketplaces & Omnichannel. REST APIs, TypeScript SDKs, and production-ready Next.js storefront. Self-host it. Own your data. No vendor lock-in. Zero platform fees.

Separate the store back office from future panels by grant audience (#14447)

Damian Legawiecd4a6cc3e7d23
diff --git a/docs/plans/6.0-admin-rbac.md b/docs/plans/6.0-admin-rbac.md
index a259cb2b3b..5926111855 100644
--- a/docs/plans/6.0-admin-rbac.md
+++ b/docs/plans/6.0-admin-rbac.md
@@ -508,23 +508,36 @@ all resolved 2026-08-07 and live in Key Decisions. Genuinely deferred:
plan to inherit:
- **Same machinery, separate pools.** Roles gain an *audience* (staff |
vendor). The operator defines vendor capability tiers in the same editor;
- vendors assign their people to those tiers but do not define roles
- (role names are globally unique — vendor-created roles would collide;
- per-vendor-owned pools are a later need, like per-store definitions).
- - **A vendor-grantable catalog subset.** Vendor roles draw only from
+ vendors assign their people to those tiers but do not define roles.
+ **Shipped 2026-08-16:** roles are store-owned (`spree_roles.store_id`,
+ required) and unique per `(store, name, audience)`, so each store defines
+ its own tiers and holds its own immutable `admin`. Per-*vendor*-owned
+ pools remain a later need — two vendors on one store still cannot each
+ define a "Packer", which is why the operator defines vendor tiers.
+ - **A per-audience catalog subset.** Vendor roles draw only from
vendor-safe resources (products, orders, fulfillments, stock, analytics —
- never `settings`, `staff`, `api_keys`); catalog resources carry the
- marker, the editor filters the grid by audience, and assignment /
- invitation guards pair audience with resource type.
+ never `settings`, `staff`, `api_keys`); the editor filters the grid by
+ audience, and assignment / invitation guards pair audience with resource
+ type. **Shipped 2026-08-16** as `register_resource(audiences: %i[vendor])`
+ — a list of the audiences *beyond staff* a resource opens up, rather than
+ a vendor-specific boolean, so a third panel adds a value instead of a
+ column (decisions.md 2026-08-16). `Spree.permissions.grantable_keys(audience)`
+ reads it; a non-staff role validates that it holds only granted keys.
- **The vendor boundary is tenancy, not new keys** (Axis A/B): vendor-panel
endpoints scope-fetch through `current_vendor` exactly as admin endpoints
scope through `current_store`. The store-admin half of that boundary is
- **already enforced** — `Spree::Ability#staff_roles` and
+ enforced in the ability — `Spree::Ability#staff_roles` and
`RoleGrantGuard#caller_roles` match on `resource_type: 'Spree::Store'`, not
`store_id` alone, so a vendor-resourced assignment (which binds to the
vendor's store) confers nothing in the store admin. Regression specs cover
- it, including an `admin`-named vendor role. The marketplace plan adds the
- vendor-side ability that reads those assignments.
+ it, including an `admin`-named vendor role. **`AdminAuthentication`'s
+ membership check was the hole in that story** — it matched `store_id`
+ alone, so a vendor-resourced holder authenticated into the admin API with
+ an empty ability and reached the scope-exempt endpoints; tightened
+ 2026-08-16 with a regression spec (marketplace plan Phase 0). The
+ marketplace plan adds the vendor-side ability, which `Spree::Ability` now
+ supports through a `resource:` option that also confines the `admin`
+ super-role to store resources.
Surface and enforcement ship with `6.0-multi-vendor-marketplace.md`, not
here. **Settled there 2026-08-15 (Decision 10):** vendor staff are
diff --git a/docs/plans/6.0-multi-vendor-marketplace.md b/docs/plans/6.0-multi-vendor-marketplace.md
index 1968992629..f24a7898de 100644
--- a/docs/plans/6.0-multi-vendor-marketplace.md
+++ b/docs/plans/6.0-multi-vendor-marketplace.md
@@ -604,7 +604,7 @@ This is **new OSS code**, not a rename of existing core — there is no in-place
- Migrate the legacy Stripe transfer ledger → `spree_vendor_transfers` (the per-order, on-fulfillment level) with `provider: 'stripe_connect'` and the Stripe transfer id in `reference`. The legacy module has no payout *records* (it delegated scheduling to Stripe), so there is nothing to backfill into `spree_vendor_payouts` — historical Stripe payouts can optionally be reconstructed from Stripe's API, or simply start fresh from the cutover.
The Enterprise module then becomes a thin layer on top of core's new models, deleting its splitting + commission + transfer decorators. The basic `Spree::PayoutProvider::StripeConnect` ships in the monorepo with the pulled-in Stripe gateway (2026-07-15 amendment); Enterprise extends it (clawbacks, netting, KYC ops, reconciliation) and keeps Shopify/WooCommerce.
2. **Build order** (each phase shippable):
- - **Phase 0 — admin-branch hardening (ships first, no Vendor model needed).** Tighten `AdminAuthentication#current_user_member_of_store?` to `resource_type: 'Spree::Store'` + regression spec; `spree_refresh_tokens.audience` written at mint and enforced on refresh (admin + store surfaces stamp their own); `Role#audience` + the vendor-grantable marker on `register_resource` (Decision 10 / RBAC plan).
+ - **Phase 0 — admin-branch hardening (ships first, no Vendor model needed). IMPLEMENTED 2026-08-16.** Tighten `AdminAuthentication#current_user_member_of_store?` to `resource_type: 'Spree::Store'` + regression spec; `spree_refresh_tokens.audience` written at mint and enforced on refresh (admin + store surfaces stamp their own); `Role#audience` + the audience marker on `register_resource` (Decision 10 / RBAC plan). **Shipped as:** `audience` on refresh tokens (nullable; `for_audience` scope narrowing every refresh **and** logout lookup on both surfaces — ending a session belongs to the surface that started it; legacy NULL-audience rows match no surface and are rejected on refresh, costing their holders one login) and on roles (`null: false`, backfilled `staff`, immutable after create, `Spree::Role::AUDIENCES` the vocabulary); the catalog takes `audiences:` naming the audiences **beyond staff** a resource opens up, with `grantable_keys(audience)` (unknown audience ⇒ empty, never raises) — a generalization of the originally-planned `vendor_grantable` boolean, so a third panel needs no schema change (decisions.md 2026-08-16); `orders`/`fulfillments`/`products`/`stock`/`dashboard` opened to `vendor`. **Roles became store-owned** (`spree_roles.store_id`, `null: false`, via `SingleStoreResource`): they were global reference data, so two stores could never each define a "Manager" and the marketplace would have inherited that. Names are unique per `(store, name, audience)` — `Spree::UniqueName`'s global uniqueness is deliberately not used on Role — so one store holds a staff "Manager" beside a vendor "Manager", and another store holds its own. `admin` is now one immutable role **per store** (`default_admin_role(store)`; `Seeds::Roles` moved after `Seeds::Stores`, since a role cannot exist before its store). The upgrade fans every existing role out per store and re-points assignments and invitations at the copy for the store they already named, so no grant changes hands. The audience bound is enforced **twice**: `Spree::Role` validates it on write, and `Spree::Ability` re-filters through `grantable_keys(role.audience)` at activation, since a catalog that changes after the role was saved would otherwise leave stale keys live. The staff surface is closed to foreign-audience roles at both ends — `Admin::RolesController#scope` lists only `Spree::Role.staff`, and `RoleGrantGuard` rejects assigning a non-staff role to store staff (invitations + admin_users). `Spree::Ability` takes `resource:` (defaults to the store) and reads `role_users` on it — the `admin` super-role and the implicit-admin fallback apply **only** on a store resource, and the staff baseline narrows `read Spree::Store` to the one store a non-store panel operates under. **The ability answers capability, never tenancy:** a vendor holding `write_orders` gets `can :manage, Spree::Order` on the model class exactly as an admin does; which records it may touch is `current_vendor` scope-fetching in the controller, so a vendor-branch controller that authorizes without scope-fetching reads store-wide.
- **Phase 1 — Vendor identity.** `Spree::Vendor` model (see Vendor identity & teams: lifecycle, branding, ToS acceptance, holiday mode), onboarding task registry + core tasks, vendor teams via `RoleUser`/`Invitation` (`resource: vendor`) + `UserRoles#vendors`, self-serve application endpoint, core `Spree::VendorMailer` lifecycle emails (see Vendor notifications), product ownership (`products.vendor_id` + approval preference), Admin API Marketplace/vendors endpoints + Store API vendor profiles, vendor CSV import/export on the `Spree::Import` pipeline. **The Vendor API branch anchor** (`Vendor::BaseController`/`ResourceController`, `vendor_api` audience, `Spree.vendor_authentication_strategies`, `/vendor/auth/*`, `/vendor/me`, `/vendor/profile`, onboarding, team, vendor-scope guard, `Spree::Ability` `resource:` option) + the seeded default vendor role. Products/orders/fulfillments on the vendor branch follow as each domain lands (products in Phase 1, orders/fulfillments/ledger reads in Phase 3). No splitting yet.
- **Phase 2 — Commission engine.** `CommissionRate` + `CommissionRule` + `CommissionLine`, resolution + calculation services (dimension-grouped matching, min/max clamps, `include_shipping`), commission-tax field, admin UI for rates. Compute-only (attach to single-vendor orders, no split).
- **Phase 3 — Order splitting + fund ledger.** `OrderGroup`, `Carts::SplitByVendor` inside `Carts::Complete`, per-vendor delivery selection at checkout, `PaymentSplit`, derived group status, reversals, the two-level `VendorTransfer` (on-fulfillment) + `VendorPayout` (scheduled sweep) + `PayoutProvider::System` + `vendor.balance(currency)`. **Gated on `6.0-cart-order-split.md` and `6.0-6.1-split-adjustments.md` landing first** — and cart-order-split is today a one-page stub: it must be expanded (checkout/delivery-selection/payment flow on Cart) before this phase's design can freeze. Flagging early: the 6.0 headline feature sits downstream of the two biggest unstarted refactors.
diff --git a/docs/plans/decisions.md b/docs/plans/decisions.md
index 81a2109930..22e17217ee 100644
--- a/docs/plans/decisions.md
+++ b/docs/plans/decisions.md
@@ -1,3 +1,39 @@
+## 2026-08-16: Grant audiences are a vocabulary, not a vendor flag
+
+Phase 0 of `6.0-multi-vendor-marketplace.md`. Damian's call, after
+re-examining the vendor principal question against a primary-source read of a
+leading open-source marketplace platform.
+
+**The principal decision stands, and the survey explains why it differs
+elsewhere.** The surveyed platform separates *credential* from *principal*: a
+standalone identity record holds the password, and it points at either an
+operator principal or a seller principal, with the token naming which one is
+acting. Spree has no such split — `Spree::AdminUser` **is** the credential
+(`has_secure_password`, lockout, password policy, reset tokens, SSO identity
+linking). Reproducing that shape means either a second copy of the whole auth
+stack or rebuilding the shipped one. So Decision 10 holds: one `AdminUser`,
+several hats, the surface distinguished by JWT audience. Worth noting the
+convergence — that platform's per-request seller header and its token-level
+actor tagging are the same two mechanisms Decision 10 specifies.
+
+**Where the boolean was wrong.** The first cut marked catalog resources with
+`vendor_grantable: true`. But `Role#audience` is already a *string* vocabulary
+(`staff` | `vendor`), and the B2B plan anticipates company roles as a separate
+future system — so the catalog would have needed a second boolean the moment a
+third panel appeared, then a third. The catalog now carries `audiences:` — the
+audiences *beyond staff* a resource opens up, staff being the implicit
+baseline every resource grants — and `grantable_keys(audience)` replaces the
+vendor-specific reader. An unregistered audience returns an empty set rather
+than raising, so a panel that does not exist yet reads as granting nothing.
+The vocabulary itself stays a constant on `Spree::Role` rather than a
+registry: a third audience is a one-line change, and nothing has asked to
+register one from outside.
+
+**Audience is immutable once a role exists**, since flipping it would
+re-point every existing assignment at the other panel, and a non-staff role
+may only hold keys its audience is granted — so `settings`/`staff`/`api_keys`
+cannot reach a seller even through a hand-written seed.
+
## 2026-08-15: Country-derived store defaults are born from the merchant's answer, not seeded and rewritten
Amends the 2026-08-13 first-run setup entry. Damian's call, after
diff --git a/packages/dashboard/e2e/global-setup.ts b/packages/dashboard/e2e/global-setup.ts
index f10fe34403..715e6c798b 100644
--- a/packages/dashboard/e2e/global-setup.ts
+++ b/packages/dashboard/e2e/global-setup.ts
@@ -51,7 +51,7 @@ const BOOTSTRAP_RUBY = [
's = Spree::Store.default',
'admin = Spree.admin_user_class.first || Spree.admin_user_class.create!(email: "[email protected]", password: "spree123", password_confirmation: "spree123")',
'admin.update!(password: "spree123", password_confirmation: "spree123")',
- 's.add_user(admin, Spree::Role.default_admin_role) unless s.role_users.exists?(user: admin)',
+ 's.add_user(admin, Spree::Role.default_admin_role(s)) unless s.role_users.exists?(user: admin)',
// Idempotent fixtures for promotion rule/action editor specs. Customer
// groups have no admin UI yet, so this is the only path to seed one.
// Looked up by permalink, not name: category names are not unique, so a name
diff --git a/spree/api/app/controllers/concerns/spree/api/v3/admin/role_grant_guard.rb b/spree/api/app/controllers/concerns/spree/api/v3/admin/role_grant_guard.rb
index 2f6c5dfe38..09ec1ba78e 100644
--- a/spree/api/app/controllers/concerns/spree/api/v3/admin/role_grant_guard.rb
+++ b/spree/api/app/controllers/concerns/spree/api/v3/admin/role_grant_guard.rb
@@ -31,7 +31,7 @@ module Spree
# past a caller without role-management authority.
return true if require_role_management && reject_without_role_management!
- roles = Spree::Role.where(id: role_ids.map(&:to_s)).to_a
+ roles = current_store.roles.where(id: role_ids.map(&:to_s)).to_a
return false if roles.empty?
return true if reject_admin_role_grant!(roles)
@@ -76,7 +76,7 @@ module Spree
end
def reject_admin_role_grant!(roles)
- return false unless roles.any? { |role| role.name == Spree::Role::ADMIN_ROLE }
+ return false unless roles.any?(&:admin?)
return false if caller_holds_admin_role?
deny_role_grant!('You cannot grant the admin role.')
@@ -107,12 +107,10 @@ module Spree
end
end
- # The caller's store-admin roles, fetched once per request. Matched
- # on the store AND a store resource, mirroring
- # `Spree::Ability#staff_roles`: an assignment scoped to another
- # resource (a marketplace vendor) binds to that resource's store but
- # confers no store-admin authority, so it must not widen what the
- # caller may grant.
+ # The caller's roles on this store, fetched once per request,
+ # mirroring `Spree::Ability#staff_roles`: a role owned by another
+ # resource (a marketplace vendor) confers no store-admin authority
+ # and must not widen what the caller may grant.
#
# @return [Array<Spree::Role>]
def caller_roles
@@ -120,10 +118,8 @@ module Spree
user = try_spree_current_user
@caller_roles =
- if user.respond_to?(:role_users)
- user.role_users.
- where(store: current_store, resource_type: Spree::Store.to_s).
- includes(:role).map(&:role)
+ if user.respond_to?(:spree_roles)
+ user.spree_roles.for_resource(current_store).to_a
else
[]
end
@@ -132,7 +128,7 @@ module Spree
def caller_holds_admin_role?
return current_api_key.has_scope?('write_all') if scope_limited_principal?
- caller_roles.any? { |role| role.name == Spree::Role::ADMIN_ROLE } ||
+ caller_roles.any?(&:admin?) ||
try_spree_current_user.try(:spree_admin?, current_store)
end
diff --git a/spree/api/app/controllers/concerns/spree/api/v3/admin_authentication.rb b/spree/api/app/controllers/concerns/spree/api/v3/admin_authentication.rb
index 85399d5f27..23c3fbbf82 100644
--- a/spree/api/app/controllers/concerns/spree/api/v3/admin_authentication.rb
+++ b/spree/api/app/controllers/concerns/spree/api/v3/admin_authentication.rb
@@ -61,10 +61,14 @@ module Spree
false
end
+ # Membership is holding a role the store itself owns, mirroring
+ # Spree::Ability#staff_roles. A role belonging to another resource — a
+ # marketplace vendor, say — is that panel's business and never admits
+ # its holder here.
def current_user_member_of_store?
- return false unless current_user.respond_to?(:role_users)
+ return false unless current_user.respond_to?(:spree_roles)
- current_user.role_users.exists?(store: current_store)
+ current_user.spree_roles.for_resource(current_store).exists?
end
def set_no_store_cache
diff --git a/spree/api/app/controllers/spree/api/v3/admin/admin_users_controller.rb b/spree/api/app/controllers/spree/api/v3/admin/admin_users_controller.rb
index 92f680b18c..3d29cb9142 100644
--- a/spree/api/app/controllers/spree/api/v3/admin/admin_users_controller.rb
+++ b/spree/api/app/controllers/spree/api/v3/admin/admin_users_controller.rb
@@ -24,7 +24,7 @@ module Spree
# the account globally. The user keeps access to any other stores.
def destroy
authorize!(:destroy, @resource)
- @resource.role_users.where(resource: current_store).destroy_all
+ @resource.role_users.where(role: current_store.roles).destroy_all
head :no_content
end
@@ -62,7 +62,7 @@ module Spree
end
def collection_includes
- [{ role_users: :role, avatar_attachment: :blob }, :stores]
+ [{ spree_roles: :resource, avatar_attachment: :blob }]
end
# Restrict to users with a role assignment on the current store.
@@ -71,10 +71,7 @@ module Spree
# host-app-defined and may contain `json` columns, which Postgres
# cannot compare for equality.
def scope
- staff_ids = model_class.
- joins(:role_users).
- where(Spree::RoleUser.table_name => { resource: current_store }).
- select(:id)
+ staff_ids = model_class.joins(:spree_roles).merge(current_store.roles).select(:id)
model_class.
where(id: staff_ids).
@@ -95,17 +92,15 @@ module Spree
# Reconcile the user's roles on this store to match `desired_role_ids`.
# Adds missing assignments and removes extras — no-op for unchanged.
def apply_role_ids(desired_role_ids)
- current = @resource.role_users.where(resource: current_store).pluck(:role_id).map(&:to_s)
+ store_roles = current_store.roles
+ current = @resource.role_users.where(role: store_roles).pluck(:role_id).map(&:to_s)
target = desired_role_ids.map(&:to_s)
- (target - current).each do |role_id|
- role = Spree::Role.find_by(id: role_id)
- @resource.role_users.find_or_create_by!(role: role, resource: current_store) if role
+ store_roles.where(id: target - current).each do |role|
+ @resource.role_users.find_or_create_by!(role: role)
end
- (current - target).each do |role_id|
- @resource.role_users.where(role_id: role_id, resource: current_store).destroy_all
- end
+ @resource.role_users.where(role: store_roles.where(id: current - target)).destroy_all
end
end
end
diff --git a/spree/api/app/controllers/spree/api/v3/admin/auth_controller.rb b/spree/api/app/controllers/spree/api/v3/admin/auth_controller.rb
index d70757801e..725bf01020 100644
--- a/spree/api/app/controllers/spree/api/v3/admin/auth_controller.rb
+++ b/spree/api/app/controllers/spree/api/v3/admin/auth_controller.rb
@@ -36,7 +36,7 @@ module Spree
if result.success?
user = result.value
- refresh_token = Spree::RefreshToken.create_for(user, request_env: request_env_for_token)
+ refresh_token = Spree::RefreshToken.create_for(user, audience: JWT_AUDIENCE_ADMIN, request_env: request_env_for_token)
set_refresh_cookie(refresh_token)
render json: auth_response(user)
else
@@ -87,7 +87,9 @@ module Spree
return redirect_to_dashboard(error: callback_error_code(strategy))
end
- set_refresh_cookie(Spree::RefreshToken.create_for(result.value, request_env: request_env_for_token))
+ set_refresh_cookie(
+ Spree::RefreshToken.create_for(result.value, audience: JWT_AUDIENCE_ADMIN, request_env: request_env_for_token)
+ )
redirect_to_dashboard
end
@@ -103,7 +105,9 @@ module Spree
)
end
- refresh_token = Spree::RefreshToken.active.find_by(token: refresh_token_value)
+ # Narrowed by audience: a token minted on another surface must not
+ # be exchangeable for an admin access token here.
+ refresh_token = Spree::RefreshToken.active.for_audience(JWT_AUDIENCE_ADMIN).find_by(token: refresh_token_value)
if refresh_token.nil?
clear_refresh_cookie
@@ -124,7 +128,11 @@ module Spree
# POST /api/v3/admin/auth/logout
def logout
refresh_token_value = refresh_token_from_cookie
- Spree::RefreshToken.active.find_by(token: refresh_token_value)&.destroy if refresh_token_value.present?
+ if refresh_token_value.present?
+ # No `active` scope — revoking an already-expired token should
+ # still delete the row rather than leave it for the sweeper.
+ Spree::RefreshToken.for_audience(JWT_AUDIENCE_ADMIN).find_by(token: refresh_token_value)&.destroy
+ end
clear_refresh_cookie
head :no_content
diff --git a/spree/api/app/controllers/spree/api/v3/admin/invitation_acceptances_controller.rb b/spree/api/app/controllers/spree/api/v3/admin/invitation_acceptances_controller.rb
index af9f8dc98d..4e984e2885 100644
--- a/spree/api/app/controllers/spree/api/v3/admin/invitation_acceptances_controller.rb
+++ b/spree/api/app/controllers/spree/api/v3/admin/invitation_acceptances_controller.rb
@@ -34,7 +34,7 @@ module Spree
@invitation.invitee = user
@invitation.accept!
- refresh_token = Spree::RefreshToken.create_for(user, request_env: request_env_for_token)
+ refresh_token = Spree::RefreshToken.create_for(user, audience: JWT_AUDIENCE_ADMIN, request_env: request_env_for_token)
set_refresh_cookie(refresh_token)
render json: auth_response(user)
rescue ActiveRecord::RecordInvalid => e
diff --git a/spree/api/app/controllers/spree/api/v3/admin/password_resets_controller.rb b/spree/api/app/controllers/spree/api/v3/admin/password_resets_controller.rb
index 5c1ba8da98..336bcedfda 100644
--- a/spree/api/app/controllers/spree/api/v3/admin/password_resets_controller.rb
+++ b/spree/api/app/controllers/spree/api/v3/admin/password_resets_controller.rb
@@ -60,7 +60,7 @@ module Spree
# password. Revoke first, then mint the fresh token for this
# browser (the auto-sign-in below).
Spree::RefreshToken.revoke_all_for(user)
- refresh_token = Spree::RefreshToken.create_for(user, request_env: request_env_for_token)
+ refresh_token = Spree::RefreshToken.create_for(user, audience: JWT_AUDIENCE_ADMIN, request_env: request_env_for_token)
set_refresh_cookie(refresh_token)
render json: auth_response(user)
diff --git a/spree/api/app/controllers/spree/api/v3/admin/roles_controller.rb b/spree/api/app/controllers/spree/api/v3/admin/roles_controller.rb
index 0a93241a5a..d9addc7103 100644
--- a/spree/api/app/controllers/spree/api/v3/admin/roles_controller.rb
+++ b/spree/api/app/controllers/spree/api/v3/admin/roles_controller.rb
@@ -3,10 +3,11 @@ module Spree
module V3
module Admin
# Staff roles and their catalog permissions (docs/plans/6.0-admin-rbac.md).
- # Roles are global, not per-store — the controller ignores
- # `current_store` for that reason; assignments (RoleUser) are the
- # store-scoped half. Protection of the admin role and host-locked rows
- # lives on the model (`mutable` guards, `can_be_deleted?`).
+ # A role belongs to what it governs, so this surface reads and writes
+ # the current store's own roles; one owned by another resource — a
+ # marketplace vendor's — belongs to that panel. Protection of the admin
+ # role and host-locked rows lives on the model (`mutable` guards,
+ # `can_be_deleted?`).
class RolesController < ResourceController
include Spree::Api::V3::Admin::RoleGrantGuard
@@ -38,14 +39,24 @@ module Spree
Spree.api.admin_role_serializer
end
+ # The store's own roles. A role belonging to another resource — a
+ # marketplace vendor's — is managed from that panel and never appears
+ # in the staff role picker.
def scope
- Spree::Role.accessible_by(current_ability, :show)
+ current_store.roles.accessible_by(current_ability, :show)
end
def collection_includes
[:role_users]
end
+ # Roles created here belong to the store being administered. The base
+ # builder stamps `store`, which a role does not have — its owner is
+ # polymorphic — so it would leave the resource unset.
+ def build_resource
+ current_store.roles.build(permitted_params)
+ end
+
def permitted_params
params.permit(:name, :description, permissions: [])
end
diff --git a/spree/api/app/controllers/spree/api/v3/admin/setup_controller.rb b/spree/api/app/controllers/spree/api/v3/admin/setup_controller.rb
index 0765a7321f..90bbf512c2 100644
--- a/spree/api/app/controllers/spree/api/v3/admin/setup_controller.rb
+++ b/spree/api/app/controllers/spree/api/v3/admin/setup_controller.rb
@@ -63,7 +63,7 @@ module Spree
adopt_default_store(user, store)
end
- refresh_token = Spree::RefreshToken.create_for(user, request_env: request_env_for_token)
+ refresh_token = Spree::RefreshToken.create_for(user, audience: JWT_AUDIENCE_ADMIN, request_env: request_env_for_token)
set_refresh_cookie(refresh_token)
render json: auth_response(user)
rescue ActiveRecord::RecordInvalid => e
diff --git a/spree/api/app/controllers/spree/api/v3/store/auth_controller.rb b/spree/api/app/controllers/spree/api/v3/store/auth_controller.rb
index 4ff81c0452..ef08531c33 100644
--- a/spree/api/app/controllers/spree/api/v3/store/auth_controller.rb
+++ b/spree/api/app/controllers/spree/api/v3/store/auth_controller.rb
@@ -52,7 +52,7 @@ module Spree
)
end
- refresh_token = Spree::RefreshToken.active.find_by(token: refresh_token_value)
+ refresh_token = Spree::RefreshToken.active.for_audience(JWT_AUDIENCE_STORE).find_by(token: refresh_token_value)
if refresh_token.nil?
return render_error(
@@ -76,11 +76,14 @@ module Spree
# Accepts: { "refresh_token": "rt_xxx" }
# Revokes the submitted refresh token. The token itself is the
# credential — no access JWT is required, so clients with an expired
- # access token can still log out.
+ # access token can still log out. Narrowed to this surface's own
+ # tokens: ending a session belongs to the surface that started it.
def logout
refresh_token_value = params[:refresh_token]
- Spree::RefreshToken.find_by(token: refresh_token_value)&.destroy if refresh_token_value.present?
+ if refresh_token_value.present?
+ Spree::RefreshToken.for_audience(JWT_AUDIENCE_STORE).find_by(token: refresh_token_value)&.destroy
+ end
head :no_content
end
@@ -101,7 +104,7 @@ module Spree
private
def auth_response(user)
- refresh_token = Spree::RefreshToken.create_for(user, request_env: request_env_for_token)
+ refresh_token = Spree::RefreshToken.create_for(user, audience: JWT_AUDIENCE_STORE, request_env: request_env_for_token)
{
token: generate_jwt(user),
diff --git a/spree/api/app/controllers/spree/api/v3/store/customer/password_resets_controller.rb b/spree/api/app/controllers/spree/api/v3/store/customer/password_resets_controller.rb
index 9630f5893c..5c1f0dd3f6 100644
--- a/spree/api/app/controllers/spree/api/v3/store/customer/password_resets_controller.rb
+++ b/spree/api/app/controllers/spree/api/v3/store/customer/password_resets_controller.rb
@@ -59,7 +59,11 @@ module Spree
# Kill every existing session before minting the new one —
# a stolen refresh token must not survive a password reset.
Spree::RefreshToken.revoke_all_for(user)
- refresh_token = Spree::RefreshToken.create_for(user, request_env: { ip_address: request.remote_ip, user_agent: request.user_agent&.truncate(255) })
+ refresh_token = Spree::RefreshToken.create_for(
+ user,
+ audience: JWT_AUDIENCE_STORE,
+ request_env: { ip_address: request.remote_ip, user_agent: request.user_agent&.truncate(255) }
+ )
user.publish_event('customer.password_reset')
render json: {
diff --git a/spree/api/app/controllers/spree/api/v3/store/customers_controller.rb b/spree/api/app/controllers/spree/api/v3/store/customers_controller.rb
index 50b39d7d2d..bbefc13ff6 100644
--- a/spree/api/app/controllers/spree/api/v3/store/customers_controller.rb
+++ b/spree/api/app/controllers/spree/api/v3/store/customers_controller.rb
@@ -22,7 +22,7 @@ module Spree
if result.success?
user = result.value
- refresh_token = Spree::RefreshToken.create_for(user, request_env: {
+ refresh_token = Spree::RefreshToken.create_for(user, audience: JWT_AUDIENCE_STORE, request_env: {
ip_address: request.remote_ip,
user_agent: request.user_agent&.truncate(255)
})
diff --git a/spree/api/app/serializers/spree/api/v3/admin/admin_user_serializer.rb b/spree/api/app/serializers/spree/api/v3/admin/admin_user_serializer.rb
index 9bdb7e31ee..24b7690b65 100644
--- a/spree/api/app/serializers/spree/api/v3/admin/admin_user_serializer.rb
+++ b/spree/api/app/serializers/spree/api/v3/admin/admin_user_serializer.rb
@@ -25,21 +25,24 @@ module Spree
# the user might have on other stores. Block receives `params`
# only when Alba passes it through the `serializer_params` hash —
# we fall back to `Spree::Current.store` if not.
+ # Filtered in Ruby rather than with `for_resource`, so the staff
+ # index's preloaded roles are used instead of a query per user.
attribute :roles do |user, params|
store = params&.dig(:store) || Spree::Current.store
- scope = user.role_users
- scope = scope.where(resource: store) if store
- scope.includes(:role).map { |ru| { id: ru.role.prefixed_id, name: ru.role.name } }
+ roles = user.spree_roles.to_a
+ roles = roles.select { |role| role.resource == store } if store
+ roles.map { |role| { id: role.prefixed_id, name: role.name } }
end
- # Every store this user holds a role on (via `Spree::RoleUser`) —
- # unlike `roles`, deliberately NOT scoped to the current store, so
- # the dashboard store switcher can offer all accessible stores.
- # Dedupe/sort happen in Ruby (not `.distinct.order`) so the staff
- # index's `collection_includes` preload is used instead of firing
- # an extra query per user.
+ # Every store this user holds a role on — unlike `roles`,
+ # deliberately NOT scoped to the current store, so the dashboard
+ # store switcher can offer all accessible stores. Read off the same
+ # preloaded roles, and deduped/sorted in Ruby, so the staff index
+ # spends no extra query per user.
attribute :stores do |user|
- user.stores.uniq.sort_by(&:name).map do |store|
+ stores = user.spree_roles.filter_map { |role| role.resource if role.resource.is_a?(Spree::Store) }
+
+ stores.uniq.sort_by(&:name).map do |store|
{ id: store.prefixed_id, name: store.name, code: store.code }
end
end
diff --git a/spree/api/app/serializers/spree/api/v3/admin/role_serializer.rb b/spree/api/app/serializers/spree/api/v3/admin/role_serializer.rb
index cbb6688b5a..38dff7069b 100644
--- a/spree/api/app/serializers/spree/api/v3/admin/role_serializer.rb
+++ b/spree/api/app/serializers/spree/api/v3/admin/role_serializer.rb
@@ -2,10 +2,11 @@ module Spree
module Api
module V3
module Admin
- # Admin API serializer for {Spree::Role}. Roles are global; permissions
- # are flat catalog keys (see the `/admin/permissions` discovery
- # endpoint). `mutable: false` marks the protected admin role and
- # host-locked rows — the dashboard renders those read-only.
+ # Admin API serializer for {Spree::Role}. A role belongs to the store
+ # it governs; permissions are flat catalog keys (see the
+ # `/admin/permissions` discovery endpoint). `mutable: false` marks the
+ # protected admin role and host-locked rows — the dashboard renders
+ # those read-only.
class RoleSerializer < V3::BaseSerializer
typelize name: :string, description: 'string | null', mutable: :boolean,
users_count: :number
@@ -19,9 +20,10 @@ module Spree
attribute(:mutable, &:mutable?)
- # Staff assignments on the serialized store.
+ # Staff assignments. The role belongs to one store already, so every
+ # assignment it has is on that store.
attribute :users_count do |role|
- role.role_users.count { |role_user| role_user.store_id == params[:store]&.id }
+ role.role_users.size
end
end
end
diff --git a/spree/api/lib/spree/api/testing_support/v3/base.rb b/spree/api/lib/spree/api/testing_support/v3/base.rb
index 4bb4781ed6..3462cdcd20 100644
--- a/spree/api/lib/spree/api/testing_support/v3/base.rb
+++ b/spree/api/lib/spree/api/testing_support/v3/base.rb
@@ -89,7 +89,8 @@ shared_context 'API v3 Admin with custom permissions' do
include_context 'API v3 Admin'
let(:custom_permissions) { [] }
- let(:custom_role) { create(:role, name: 'limited', permissions: custom_permissions) }
+ # A role belongs to what it governs, so it must be the store under test.
+ let(:custom_role) { create(:role, name: 'limited', permissions: custom_permissions, resource: store) }
let(:custom_admin) { create(:admin_user, :without_admin_role) }
let(:headers) do
{ 'Authorization' => "Bearer #{Spree::Api::V3::TestingSupport.generate_jwt(custom_admin, audience: Spree::Api::V3::JwtAuthentication::JWT_AUDIENCE_ADMIN)}" }
diff --git a/spree/api/spec/controllers/concerns/spree/api/v3/admin/store_context_spec.rb b/spree/api/spec/controllers/concerns/spree/api/v3/admin/store_context_spec.rb
index c48d9dae85..0760f8965f 100644
--- a/spree/api/spec/controllers/concerns/spree/api/v3/admin/store_context_spec.rb
+++ b/spree/api/spec/controllers/concerns/spree/api/v3/admin/store_context_spec.rb
@@ -23,7 +23,7 @@ RSpec.describe Spree::Api::V3::Admin::TaxCategoriesController, type: :controller
context 'with X-Spree-Store-Id naming a store the admin has a role on' do
before do
- create(:role_user, user: admin_user, role: Spree::Role.default_admin_role, resource: other_store)
+ create(:role_user, user: admin_user, role: Spree::Role.default_admin_role(other_store))
request.headers['X-Spree-Store-Id'] = other_store.prefixed_id
end
diff --git a/spree/api/spec/controllers/spree/api/v3/admin/admin_users_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/admin/admin_users_controller_spec.rb
index 8760a488e9..394c6712ee 100644
--- a/spree/api/spec/controllers/spree/api/v3/admin/admin_users_controller_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/admin/admin_users_controller_spec.rb
@@ -11,7 +11,7 @@ RSpec.describe Spree::Api::V3::Admin::AdminUsersController, type: :controller do
# `scope` resolves them) but without the admin role.
let!(:target) do
create(:admin_user, :without_admin_role).tap do |u|
- u.role_users.create!(role: staff_role, resource: store)
+ create(:role_user, user: u, role: staff_role)
end
end
@@ -35,14 +35,14 @@ RSpec.describe Spree::Api::V3::Admin::AdminUsersController, type: :controller do
patch :update, params: { id: target.prefixed_id, role_ids: [other_role.prefixed_id] }, as: :json
expect(response).to have_http_status(:ok)
- expect(target.role_users.where(resource: store, role: other_role)).to exist
+ expect(target.role_users.where(role: other_role)).to exist
end
end
context 'authenticated as a staff JWT without staff permissions' do
let(:orders_role) { create(:role, name: 'orders_only', permissions: %w[write_orders]) }
let(:staff_admin) do
- create(:admin_user, :without_admin_role).tap { |u| u.role_users.create!(role: orders_role, resource: store) }
+ create(:admin_user, :without_admin_role).tap { |u| create(:role_user, user: u, role: orders_role) }
end
let(:headers) do
api_key_headers.merge('Authorization' => "Bearer #{Spree::Api::V3::TestingSupport.generate_jwt(staff_admin, audience: Spree::Api::V3::JwtAuthentication::JWT_AUDIENCE_ADMIN)}")
@@ -60,7 +60,7 @@ RSpec.describe Spree::Api::V3::Admin::AdminUsersController, type: :controller do
it 'cannot assign any role' do
expect {
patch :update, params: { id: target.prefixed_id, role_ids: [staff_role.prefixed_id] }, as: :json
- }.not_to change { target.role_users.where(resource: store).count }
+ }.not_to change { target.role_users.where(role: store.roles).count }
expect(response).to have_http_status(:not_found)
end
@@ -70,7 +70,7 @@ RSpec.describe Spree::Api::V3::Admin::AdminUsersController, type: :controller do
it 'cannot mutate roles with unresolved role ids' do
expect {
patch :update, params: { id: target.prefixed_id, role_ids: ['role_nonexistent'] }, as: :json
- }.not_to change { target.role_users.where(resource: store).count }
+ }.not_to change { target.role_users.where(role: store.roles).count }
expect(response).to have_http_status(:not_found)
end
@@ -79,7 +79,7 @@ RSpec.describe Spree::Api::V3::Admin::AdminUsersController, type: :controller do
context 'authenticated as a staff JWT holding write_staff' do
let(:manager_role) { create(:role, name: 'team_manager', permissions: %w[write_staff]) }
let(:staff_admin) do
- create(:admin_user, :without_admin_role).tap { |u| u.role_users.create!(role: manager_role, resource: store) }
+ create(:admin_user, :without_admin_role).tap { |u| create(:role_user, user: u, role: manager_role) }
end
let(:headers) do
api_key_headers.merge('Authorization' => "Bearer #{Spree::Api::V3::TestingSupport.generate_jwt(staff_admin, audience: Spree::Api::V3::JwtAuthentication::JWT_AUDIENCE_ADMIN)}")
@@ -89,7 +89,7 @@ RSpec.describe Spree::Api::V3::Admin::AdminUsersController, type: :controller do
patch :update, params: { id: target.prefixed_id, role_ids: [staff_role.prefixed_id] }, as: :json
expect(response).to have_http_status(:ok)
- expect(target.role_users.where(resource: store, role: staff_role)).to exist
+ expect(target.role_users.where(role: staff_role)).to exist
end
it 'forbids promoting an account to admin' do
@@ -105,7 +105,7 @@ RSpec.describe Spree::Api::V3::Admin::AdminUsersController, type: :controller do
patch :update, params: { id: target.prefixed_id, role_ids: [owner_role.prefixed_id] }, as: :json
expect(response).to have_http_status(:forbidden)
- expect(target.role_users.where(resource: store, role: owner_role)).not_to exist
+ expect(target.role_users.where(role: owner_role)).not_to exist
end
end
diff --git a/spree/api/spec/controllers/spree/api/v3/admin/auth_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/admin/auth_controller_spec.rb
index 6229d7742c..7d1e72c4a7 100644
--- a/spree/api/spec/controllers/spree/api/v3/admin/auth_controller_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/admin/auth_controller_spec.rb
@@ -208,7 +208,7 @@ RSpec.describe Spree::Api::V3::Admin::AuthController, type: :controller do
end
describe 'POST #refresh' do
- let(:refresh_token) { create(:refresh_token, user: admin_user, ip_address: '127.0.0.1', user_agent: 'test') }
+ let(:refresh_token) { create(:refresh_token, :for_admin, user: admin_user, ip_address: '127.0.0.1', user_agent: 'test') }
context 'with a valid refresh cookie' do
before do
@@ -261,10 +261,28 @@ RSpec.describe Spree::Api::V3::Admin::AuthController, type: :controller do
expect(set_cookie_for('spree_admin_refresh_token')).to include('=;')
end
end
+
+ # A token is redeemable only on the surface that minted it — otherwise one
+ # surface's refresh token buys another surface's access token.
+ context 'with a refresh token minted for another audience' do
+ let(:foreign_token) do
+ create(:refresh_token, user: admin_user, audience: 'store_api', ip_address: '127.0.0.1', user_agent: 'test')
+ end
+
+ it 'returns 401 invalid_refresh_token and leaves the row intact' do
+ request.cookie_jar.signed[refresh_cookie_name] = foreign_token.token
+
+ post :refresh
+
+ expect(response).to have_http_status(:unauthorized)
+ expect(json_response['error']['code']).to eq('invalid_refresh_token')
+ expect(foreign_token.reload).to be_present
+ end
+ end
end
describe 'POST #logout' do
- let(:refresh_token) { create(:refresh_token, user: admin_user, ip_address: '127.0.0.1', user_agent: 'test') }
+ let(:refresh_token) { create(:refresh_token, :for_admin, user: admin_user, ip_address: '127.0.0.1', user_agent: 'test') }
context 'with a valid refresh cookie' do
before do
@@ -289,6 +307,21 @@ RSpec.describe Spree::Api::V3::Admin::AuthController, type: :controller do
expect(response).to have_http_status(:no_content)
end
end
+
+ context 'with a refresh token minted for another audience' do
+ let(:foreign_token) do
+ create(:refresh_token, user: admin_user, audience: 'store_api', ip_address: '127.0.0.1', user_agent: 'test')
+ end
+
+ it 'leaves the other surface session alone' do
+ request.cookie_jar.signed[refresh_cookie_name] = foreign_token.token
+
+ post :logout
+
+ expect(response).to have_http_status(:no_content)
+ expect(foreign_token.reload).to be_present
+ end
+ end
end
describe 'response headers' do
diff --git a/spree/api/spec/controllers/spree/api/v3/admin/base_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/admin/base_controller_spec.rb
index 3878e86d96..812c3c9782 100644
--- a/spree/api/spec/controllers/spree/api/v3/admin/base_controller_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/admin/base_controller_spec.rb
@@ -179,7 +179,7 @@ RSpec.describe Spree::Api::V3::Admin::BaseController, type: :controller do
let(:other_store) { create(:store) }
let(:foreign_admin) do
create(:admin_user, :without_admin_role).tap do |u|
- u.role_users.create!(role: Spree::Role.default_admin_role, resource: other_store, store: other_store)
+ create(:role_user, user: u, role: Spree::Role.default_admin_role(other_store))
end
end
let(:foreign_admin_jwt) do
@@ -197,6 +197,39 @@ RSpec.describe Spree::Api::V3::Admin::BaseController, type: :controller do
expect(response).to have_http_status(:forbidden)
end
end
+
+ # A role held on a non-store resource binds to that resource's store, so
+ # matching membership on store_id alone would admit its holder here. The
+ # stand-in resource plays the part of a marketplace vendor until the Vendor
+ # model lands.
+ context 'with an admin JWT whose only role is on a non-store resource of this store' do
+ let(:panel) { create(:customer_group, store: store) }
+ let(:panel_admin) do
+ create(:admin_user, :without_admin_role).tap do |u|
+ create(:role_user, user: u, role: create(:role, name: 'panel_orders', resource: panel))
+ end
+ end
+ let(:panel_admin_jwt) do
+ Spree::Api::V3::TestingSupport.generate_jwt(
+ panel_admin,
+ audience: Spree::Api::V3::JwtAuthentication::JWT_AUDIENCE_ADMIN
+ )
+ end
+
+ before { request.headers['Authorization'] = "Bearer #{panel_admin_jwt}" }
+
+ # The panel belongs to this store, so the role is on the store's own turf
+ # — otherwise the check below would pass for the wrong reason.
+ it 'holds the role on a resource of this store' do
+ expect(panel_admin.spree_roles.first.resource.store).to eq(store)
+ end
+
+ it 'returns 403 forbidden' do
+ get :index
+
+ expect(response).to have_http_status(:forbidden)
+ end
+ end
end
describe 'authentication priority (secret key vs JWT)' do
diff --git a/spree/api/spec/controllers/spree/api/v3/admin/invitations_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/admin/invitations_controller_spec.rb
index 7d22061b4f..0f28814d2c 100644
--- a/spree/api/spec/controllers/spree/api/v3/admin/invitations_controller_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/admin/invitations_controller_spec.rb
@@ -30,7 +30,7 @@ RSpec.describe Spree::Api::V3::Admin::InvitationsController, type: :controller d
context 'authenticated as a non-admin staff JWT' do
let(:inviter_role) { create(:role, name: 'team_manager', permissions: %w[write_staff]) }
let(:staff_admin) do
- create(:admin_user, :without_admin_role).tap { |u| u.role_users.create!(role: inviter_role, resource: store) }
+ create(:admin_user, :without_admin_role).tap { |u| create(:role_user, user: u, role: inviter_role) }
end
let(:headers) do
api_key_headers.merge('Authorization' => "Bearer #{Spree::Api::V3::TestingSupport.generate_jwt(staff_admin, audience: Spree::Api::V3::JwtAuthentication::JWT_AUDIENCE_ADMIN)}")
@@ -75,6 +75,19 @@ RSpec.describe Spree::Api::V3::Admin::InvitationsController, type: :controller d
expect(response).to have_http_status(:created)
expect(Spree::Invitation.last.role).to eq(admin_role)
end
+
+ # A role names what it governs, so one owned elsewhere cannot be granted
+ # on this store — the invitation is rejected as invalid rather than
+ # unauthorized, since it is not a privilege question but a nonsensical one.
+ it 'refuses inviting store staff into a role owned by another resource' do
+ vendor_role = create(:role, name: 'vendor_manager', resource: create(:customer_group))
+
+ expect {
+ post :create, params: { email: '[email protected]', role_id: vendor_role.prefixed_id }, as: :json
+ }.not_to change(Spree::Invitation, :count)
+
+ expect(response).to have_http_status(:unprocessable_content)
+ end
end
end
end
diff --git a/spree/api/spec/controllers/spree/api/v3/admin/me_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/admin/me_controller_spec.rb
index 69bccda580..572ea9584b 100644
--- a/spree/api/spec/controllers/spree/api/v3/admin/me_controller_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/admin/me_controller_spec.rb
@@ -74,7 +74,7 @@ RSpec.describe Spree::Api::V3::Admin::MeController, type: :controller do
context 'as a staffer with a limited role' do
let(:staffer) do
create(:admin_user, :without_admin_role).tap do |user|
- user.role_users.create!(role: create(:role, name: 'viewer', permissions: %w[write_orders]), resource: store)
+ create(:role_user, user: user, role: create(:role, name: 'viewer', permissions: %w[write_orders], resource: store))
end
end
let(:headers) do
@@ -91,8 +91,8 @@ RSpec.describe Spree::Api::V3::Admin::MeController, type: :controller do
let(:store_b) { create(:store) }
let(:staffer) do
create(:admin_user, :without_admin_role).tap do |user|
- user.role_users.create!(role: create(:role, name: 'a_orders', permissions: %w[write_orders]), resource: store)
- user.role_users.create!(role: create(:role, name: 'b_products', permissions: %w[read_products]), resource: store_b)
+ create(:role_user, user: user, role: create(:role, name: 'a_orders', permissions: %w[write_orders], resource: store))
+ create(:role_user, user: user, role: create(:role, name: 'b_products', permissions: %w[read_products], resource: store_b))
end
end
let(:headers) do
diff --git a/spree/api/spec/controllers/spree/api/v3/admin/password_resets_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/admin/password_resets_controller_spec.rb
index 28cf25aaab..a04fee8850 100644
--- a/spree/api/spec/controllers/spree/api/v3/admin/password_resets_controller_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/admin/password_resets_controller_spec.rb
@@ -57,7 +57,9 @@ RSpec.describe Spree::Api::V3::Admin::PasswordResetsController, type: :controlle
end
it 'revokes every pre-existing session, keeping only the fresh one' do
- stolen_token = Spree::RefreshToken.create_for(admin_user, request_env: {})
+ stolen_token = Spree::RefreshToken.create_for(
+ admin_user, audience: Spree::Api::V3::JwtAuthentication::JWT_AUDIENCE_ADMIN, request_env: {}
+ )
token = admin_user.generate_token_for(:password_reset)
patch :update, params: { id: token, password: 'new-secret-123', password_confirmation: 'new-secret-123' }
@@ -67,6 +69,17 @@ RSpec.describe Spree::Api::V3::Admin::PasswordResetsController, type: :controlle
expect(Spree::RefreshToken.where(user: admin_user).count).to eq(1)
end
+ # The auto-sign-in is worthless if the token it mints cannot be redeemed —
+ # the refresh endpoint only accepts its own audience.
+ it 'mints the fresh session for the admin surface' do
+ token = admin_user.generate_token_for(:password_reset)
+
+ patch :update, params: { id: token, password: 'new-secret-123', password_confirmation: 'new-secret-123' }
+
+ expect(response).to have_http_status(:ok)
+ expect(Spree::RefreshToken.where(user: admin_user).last.audience).to eq('admin_api')
+ end
+
it 'rejects an invalid token' do
patch :update, params: { id: 'bogus', password: 'new-secret-123', password_confirmation: 'new-secret-123' }
diff --git a/spree/api/spec/controllers/spree/api/v3/admin/permissions_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/admin/permissions_controller_spec.rb
index db5f8556b2..dc63dd3bf5 100644
--- a/spree/api/spec/controllers/spree/api/v3/admin/permissions_controller_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/admin/permissions_controller_spec.rb
@@ -33,7 +33,7 @@ RSpec.describe Spree::Api::V3::Admin::PermissionsController, type: :controller d
context 'with a limited staff JWT' do
let(:staffer) do
create(:admin_user, :without_admin_role).tap do |user|
- user.role_users.create!(role: create(:role, name: 'viewer', permissions: %w[read_orders]), resource: store)
+ create(:role_user, user: user, role: create(:role, name: 'viewer', permissions: %w[read_orders], resource: store))
end
end
let(:headers) do
diff --git a/spree/api/spec/controllers/spree/api/v3/admin/roles_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/admin/roles_controller_spec.rb
index 82df4995e1..a2b68a6614 100644
--- a/spree/api/spec/controllers/spree/api/v3/admin/roles_controller_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/admin/roles_controller_spec.rb
@@ -25,6 +25,17 @@ RSpec.describe Spree::Api::V3::Admin::RolesController, type: :controller do
expect(support['users_count']).to eq(0)
end
+ # The staff Roles page feeds the staff role picker, so a role owned by
+ # another resource would be assignable to store staff.
+ it 'omits roles owned by another resource' do
+ create(:role, name: 'vendor_manager', resource: create(:customer_group))
+
+ get :index, as: :json
+
+ names = json_response['data'].map { |r| r['name'] }
+ expect(names).not_to include('vendor_manager')
+ end
+
it 'reports the admin role as immutable with the full catalog' do
get :index, as: :json
@@ -53,10 +64,8 @@ RSpec.describe Spree::Api::V3::Admin::RolesController, type: :controller do
context 'as a staffer with limited permissions' do
let(:staffer) do
create(:admin_user, :without_admin_role).tap do |user|
- user.role_users.create!(
- role: create(:role, name: 'team_manager', permissions: %w[write_staff read_orders]),
- resource: store
- )
+ create(:role_user, user: user,
+ role: create(:role, name: 'team_manager', permissions: %w[write_staff read_orders]))
end
end
let(:headers) do
@@ -77,29 +86,30 @@ RSpec.describe Spree::Api::V3::Admin::RolesController, type: :controller do
expect(Spree::Role.find_by(name: 'sneaky')).to be_nil
end
- # Authority scoped to a non-store resource (a marketplace vendor) binds
- # to that resource's store but confers nothing in the store admin, so it
- # must not widen what the caller may grant.
+ # A role owned by another resource (a marketplace vendor) confers nothing
+ # in the store admin, so it must not widen what the caller may grant.
it 'ignores keys the caller holds only on a non-store resource' do
- staffer.role_users.create!(
- role: create(:role, name: 'vendor_catalog', permissions: %w[write_products]),
- resource: Spree::DummyModel.create!(name: 'Vendor A')
+ Spree.permissions.register_resource(
+ :products, group: :catalog, audiences: %i[dummy_model], subjects: -> { [Spree::Product] }
)
+ create(:role_user, user: staffer,
+ role: create(:role, name: 'vendor_catalog', permissions: %w[write_products],
+ resource: Spree::DummyModel.create!(name: 'Vendor A')))
post :create, params: { name: 'sneaky', permissions: %w[write_products] }, as: :json
expect(response).to have_http_status(:forbidden)
expect(Spree::Role.find_by(name: 'sneaky')).to be_nil
+ ensure
+ Spree.permissions.reset!
end
# Privileges held on OTHER stores don't count: the caller's grant is
# their roles on the store the request runs against.
it 'ignores keys the caller holds only on a different store' do
store_b = create(:store)
- staffer.role_users.create!(
- role: create(:role, name: 'b_products', permissions: %w[write_products]),
- resource: store_b
- )
+ create(:role_user, user: staffer,
+ role: create(:role, name: 'b_products', permissions: %w[write_products], resource: store_b))
post :create, params: { name: 'sneaky', permissions: %w[write_products] }, as: :json
@@ -169,7 +179,7 @@ RSpec.describe Spree::Api::V3::Admin::RolesController, type: :controller do
it 'refuses to delete a role still assigned to staff' do
role = create(:role, name: 'in_use')
- create(:admin_user, :without_admin_role).role_users.create!(role: role, resource: store)
+ create(:role_user, user: create(:admin_user, :without_admin_role), role: role)
delete :destroy, params: { id: role.prefixed_id }, as: :json
diff --git a/spree/api/spec/controllers/spree/api/v3/admin/setup_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/admin/setup_controller_spec.rb
index 7153659d64..660541dadc 100644
--- a/spree/api/spec/controllers/spree/api/v3/admin/setup_controller_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/admin/setup_controller_spec.rb
@@ -103,7 +103,7 @@ RSpec.describe Spree::Api::V3::Admin::SetupController, type: :controller do
expect(json_response['user']['email']).to eq('[email protected]')
user = Spree.admin_user_class.find_by(email: '[email protected]')
- expect(user.role_users.exists?(store: @default_store)).to be(true)
+ expect(user.spree_roles.for_resource(@default_store).exists?).to be(true)
expect(@default_store.reload.name).to eq('My New Store')
expect(@default_store.setup_token).to be_nil
expect(response.cookies['spree_admin_refresh_token']).to be_present
diff --git a/spree/api/spec/controllers/spree/api/v3/admin/store_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/admin/store_controller_spec.rb
index 55f11c5db5..fd449f6709 100644
--- a/spree/api/spec/controllers/spree/api/v3/admin/store_controller_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/admin/store_controller_spec.rb
@@ -25,10 +25,8 @@ RSpec.describe Spree::Api::V3::Admin::StoreController, type: :controller do
context 'as a staffer without any settings permission' do
let(:staffer) do
create(:admin_user, :without_admin_role).tap do |user|
- user.role_users.create!(
- role: create(:role, name: 'orders_only', permissions: %w[write_orders]),
- resource: store
- )
+ create(:role_user, user: user,
+ role: create(:role, name: 'orders_only', permissions: %w[write_orders]))
end
end
let(:headers) do
diff --git a/spree/api/spec/controllers/spree/api/v3/admin/translations_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/admin/translations_controller_spec.rb
index a064dc9eaa..592d28d80c 100644
--- a/spree/api/spec/controllers/spree/api/v3/admin/translations_controller_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/admin/translations_controller_spec.rb
@@ -46,7 +46,7 @@ RSpec.describe Spree::Api::V3::Admin::TranslationsController, type: :controller
context 'as a staffer holding read_products' do
let(:staffer) do
create(:admin_user, :without_admin_role).tap do |user|
- user.role_users.create!(role: create(:role, name: 'catalog_viewer', permissions: %w[read_products]), resource: store)
+ create(:role_user, user: user, role: create(:role, name: 'catalog_viewer', permissions: %w[read_products], resource: store))
end
end
let(:headers) do
@@ -63,7 +63,7 @@ RSpec.describe Spree::Api::V3::Admin::TranslationsController, type: :controller
context 'as a staffer without a products permission' do
let(:staffer) do
create(:admin_user, :without_admin_role).tap do |user|
- user.role_users.create!(role: create(:role, name: 'orders_only', permissions: %w[read_orders]), resource: store)
+ create(:role_user, user: user, role: create(:role, name: 'orders_only', permissions: %w[read_orders], resource: store))
end
end
let(:headers) do
diff --git a/spree/api/spec/controllers/spree/api/v3/scoped_authorization_spec.rb b/spree/api/spec/controllers/spree/api/v3/scoped_authorization_spec.rb
index 19a0743769..4c8431ee58 100644
--- a/spree/api/spec/controllers/spree/api/v3/scoped_authorization_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/scoped_authorization_spec.rb
@@ -107,7 +107,7 @@ RSpec.describe Spree::Api::V3::Admin::OrdersController, type: :controller do
context 'as a staffer whose roles grant the required key' do
let(:staffer) do
create(:admin_user, :without_admin_role).tap do |user|
- user.role_users.create!(role: create(:role, name: 'viewer', permissions: %w[read_orders]), resource: store)
+ create(:role_user, user: user, role: create(:role, name: 'viewer', permissions: %w[read_orders], resource: store))
end
end
let(:jwt_token) { Spree::Api::V3::TestingSupport.generate_jwt(staffer, audience: Spree::Api::V3::JwtAuthentication::JWT_AUDIENCE_ADMIN) }
@@ -121,7 +121,7 @@ RSpec.describe Spree::Api::V3::Admin::OrdersController, type: :controller do
context 'as a staffer whose roles lack the required key' do
let(:staffer) do
create(:admin_user, :without_admin_role).tap do |user|
- user.role_users.create!(role: create(:role, name: 'other', permissions: %w[read_customers]), resource: store)
+ create(:role_user, user: user, role: create(:role, name: 'other', permissions: %w[read_customers], resource: store))
end
end
let(:jwt_token) { Spree::Api::V3::TestingSupport.generate_jwt(staffer, audience: Spree::Api::V3::JwtAuthentication::JWT_AUDIENCE_ADMIN) }
diff --git a/spree/api/spec/controllers/spree/api/v3/store/auth_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/store/auth_controller_spec.rb
index 967afba131..ca4e8f0732 100644
--- a/spree/api/spec/controllers/spree/api/v3/store/auth_controller_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/store/auth_controller_spec.rb
@@ -255,6 +255,17 @@ RSpec.describe Spree::Api::V3::Store::AuthController, type: :controller do
expect(response).to have_http_status(:no_content)
end
+ it 'leaves a token minted for another surface alone' do
+ admin_token = create(:refresh_token, :for_admin)
+
+ expect {
+ post :logout, params: { refresh_token: admin_token.token }
+ }.not_to change(Spree::RefreshToken, :count)
+
+ expect(response).to have_http_status(:no_content)
+ expect(admin_token.reload).to be_present
+ end
+
it 'succeeds without refresh token param' do
post :logout
diff --git a/spree/api/spec/controllers/spree/api/v3/store/customer/password_resets_controller_spec.rb b/spree/api/spec/controllers/spree/api/v3/store/customer/password_resets_controller_spec.rb
index 03ad762804..242d23f21e 100644
--- a/spree/api/spec/controllers/spree/api/v3/store/customer/password_resets_controller_spec.rb
+++ b/spree/api/spec/controllers/spree/api/v3/store/customer/password_resets_controller_spec.rb
@@ -111,8 +111,21 @@ RSpec.describe Spree::Api::V3::Store::Customer::PasswordResetsController, type:
expect(json_response['user']['email']).to eq(user.email)
end
+ it 'mints the fresh session for the store surface' do
+ patch :update, params: {
+ id: reset_token,
+ password: 'newsecurepassword',
+ password_confirmation: 'newsecurepassword'
+ }
+
+ expect(response).to have_http_status(:ok)
+ expect(Spree::RefreshToken.where(user: user).last.audience).to eq('store_api')
+ end
+
it 'revokes every pre-existing session, keeping only the fresh one' do
- stolen_token = Spree::RefreshToken.create_for(user, request_env: {})
+ stolen_token = Spree::RefreshToken.create_for(
+ user, audience: Spree::Api::V3::JwtAuthentication::JWT_AUDIENCE_STORE, request_env: {}
+ )
patch :update, params: {
id: reset_token,
diff --git a/spree/api/spec/integration/spree/api/v3/admin/admin_users_spec.rb b/spree/api/spec/integration/spree/api/v3/admin/admin_users_spec.rb
index 9b10ff165b..24c89bcff7 100644
--- a/spree/api/spec/integration/spree/api/v3/admin/admin_users_spec.rb
+++ b/spree/api/spec/integration/spree/api/v3/admin/admin_users_spec.rb
@@ -14,7 +14,7 @@ RSpec.describe 'Admin Staff API', type: :request, swagger_doc: 'api-reference/ad
# and pin the role assignment to `store` so the staff list returns it.
let!(:staff_member) do
user = admin_user
- user.role_users.find_or_create_by!(role: admin_role, resource: store)
+ user.role_users.find_or_create_by!(role: admin_role)
user
end
@@ -123,7 +123,7 @@ RSpec.describe 'Admin Staff API', type: :request, swagger_doc: 'api-reference/ad
run_test! do |response|
# Account still exists; only the per-store RoleUser is gone.
expect(Spree.admin_user_class.exists?(staff_member.id)).to be true
- expect(staff_member.role_users.where(resource: store).exists?).to be false
+ expect(staff_member.role_users.where(role: store.roles).exists?).to be false
end
end
end
diff --git a/spree/api/spec/integration/spree/api/v3/admin/auth_spec.rb b/spree/api/spec/integration/spree/api/v3/admin/auth_spec.rb
index bc9b6ec483..8f77ec65f4 100644
--- a/spree/api/spec/integration/spree/api/v3/admin/auth_spec.rb
+++ b/spree/api/spec/integration/spree/api/v3/admin/auth_spec.rb
@@ -112,7 +112,7 @@ RSpec.describe 'Admin Authentication API', type: :request, swagger_doc: 'api-ref
response '200', 'refresh successful' do
let(:'x-spree-api-key') { secret_api_key.plaintext_token }
- let(:refresh_token_record) { create(:refresh_token, user: existing_admin) }
+ let(:refresh_token_record) { create(:refresh_token, :for_admin, user: existing_admin) }
# rswag drives requests through Rack::Test, whose cookie jar can't sign cookies the
# way Rails does. Stub the cookie reader on the controller concern so the integration
diff --git a/spree/api/spec/serializers/spree/api/v3/admin/admin_user_serializer_spec.rb b/spree/api/spec/serializers/spree/api/v3/admin/admin_user_serializer_spec.rb
index b20799ba2b..fad1bd1ab1 100644
--- a/spree/api/spec/serializers/spree/api/v3/admin/admin_user_serializer_spec.rb
+++ b/spree/api/spec/serializers/spree/api/v3/admin/admin_user_serializer_spec.rb
@@ -11,7 +11,7 @@ RSpec.describe Spree::Api::V3::Admin::AdminUserSerializer do
describe 'stores' do
it 'lists every store the user holds a role on, not just the current one' do
other_store = create(:store)
- create(:role_user, user: admin_user, role: Spree::Role.default_admin_role, resource: other_store, store: other_store)
+ create(:role_user, user: admin_user, role: Spree::Role.default_admin_role(other_store))
expect(subject['stores']).to contain_exactly(
{ id: store.prefixed_id, name: store.name, code: store.code },
@@ -20,7 +20,7 @@ RSpec.describe Spree::Api::V3::Admin::AdminUserSerializer do
end
it 'does not duplicate a store the user holds multiple roles on' do
- create(:role_user, user: admin_user, role: create(:role), resource: store, store: store)
+ create(:role_user, user: admin_user, role: create(:role))
expect(subject['stores'].map { |s| s[:id] }).to eq([store.prefixed_id])
end
diff --git a/spree/core/app/models/concerns/spree/user_management.rb b/spree/core/app/models/concerns/spree/user_management.rb
index 4c4c191555..253d250d66 100644
--- a/spree/core/app/models/concerns/spree/user_management.rb
+++ b/spree/core/app/models/concerns/spree/user_management.rb
@@ -1,9 +1,13 @@
module Spree
+ # Included into whatever a role can govern — a Store today, a marketplace
+ # vendor later. Assignments hang off the resource's own roles, so a user is
+ # "in" a resource exactly when they hold one of its roles.
module UserManagement
extend ActiveSupport::Concern
included do
- has_many :role_users, class_name: 'Spree::RoleUser', as: :resource, dependent: :destroy
+ has_many :roles, class_name: 'Spree::Role', as: :resource, dependent: :destroy
+ has_many :role_users, through: :roles, source: :role_users
has_many :users, through: :role_users, source: :user, source_type: Spree.admin_user_class.to_s
has_many :invitations, class_name: 'Spree::Invitation', as: :resource, dependent: :destroy
end
@@ -11,23 +15,31 @@ module Spree
# Adds a user to the resource with the default user role
# If no role is provided, the default user role will be used
# If a role is provided, it will be used instead of the default user role
+ #
+ # The role must be one this resource owns: a role names what it governs, so
+ # granting another's here would add the user somewhere else entirely.
+ #
# @param user [Spree.admin_user_class] The user to add to the resource
# @param role [Spree::Role] The role to add the user to
+ # @raise [ArgumentError] if the role belongs to another resource
+ # @return [Spree::RoleUser]
def add_user(user, role = nil)
- role = role || default_user_role
- role_users.find_or_create_by!(user: user, role: role)
+ role ||= default_user_role
+ raise ArgumentError, "#{role.name} does not belong to this #{self.class.name}" unless role.resource == self
+
+ role.role_users.find_or_create_by!(user: user)
end
# Revokes a user's access to the resource
# @param user [Spree.admin_user_class] The user to remove from the resource
# @return [void]
def remove_user(user)
- role_users.where(user: user).destroy_all
+ Spree::RoleUser.where(user: user, role: roles).destroy_all
end
# this can be overridden in the base model to use a different user role, eg. 'vendor'
def default_user_role
- Spree::Role.default_admin_role
+ Spree::Role.default_admin_role(self)
end
end
end
diff --git a/spree/core/app/models/concerns/spree/user_roles.rb b/spree/core/app/models/concerns/spree/user_roles.rb
index 9d60cd8dc4..3ab4c3640a 100644
--- a/spree/core/app/models/concerns/spree/user_roles.rb
+++ b/spree/core/app/models/concerns/spree/user_roles.rb
@@ -5,7 +5,7 @@ module Spree
included do
has_many :role_users, class_name: 'Spree::RoleUser', foreign_key: :user_id, as: :user, dependent: :destroy_async # async as we need to check if the user has admin role before destroying
has_many :spree_roles, through: :role_users, class_name: 'Spree::Role', source: :role
- has_many :stores, through: :role_users, source: :resource, source_type: 'Spree::Store'
+ has_many :stores, through: :spree_roles, source: :resource, source_type: 'Spree::Store'
has_many :invitations, class_name: 'Spree::Invitation', as: :invitee, dependent: :destroy
has_many :sent_invitations, class_name: 'Spree::Invitation', as: :inviter, dependent: :destroy
@@ -18,10 +18,10 @@ module Spree
# @return [Spree::RoleUser] The role user created
def add_role(role_name, resource = nil)
resource ||= Spree::Store.current
- role = Spree::Role.find_by(name: role_name)
+ role = Spree::Role.find_by(name: role_name, resource: resource)
return if role.nil?
- role_users.find_or_create_by!(role: role, resource: resource)
+ role_users.find_or_create_by!(role: role)
end
# Removes a role from a resource
@@ -30,10 +30,10 @@ module Spree
# @param resource [Spree::Base] The resource to remove the role from
def remove_role(role_name, resource = nil)
resource ||= Spree::Store.current
- role = Spree::Role.find_by(name: role_name)
+ role = Spree::Role.find_by(name: role_name, resource: resource)
return if role.nil?
- role_users.where(role: role, resource: resource).destroy_all
+ role_users.where(role: role).destroy_all
end
# has_spree_role? simply needs to return true or false whether a user has a role or not.
@@ -44,7 +44,7 @@ module Spree
def has_spree_role?(role_name, resource = nil)
resource ||= Spree::Store.current
- role_users.where(resource: resource).joins(:role).where(Spree::Role.table_name => { name: role_name }).exists?
+ spree_roles.for_resource(resource).exists?(name: role_name)
end
# Returns true if the user has the admin role for a given resource
@@ -61,6 +61,7 @@ module Spree
def invited_by
invitations.first&.inviter
end
+
end
end
end
diff --git a/spree/core/app/models/spree/ability.rb b/spree/core/app/models/spree/ability.rb
index dcd5453100..73f5b7a7b1 100644
--- a/spree/core/app/models/spree/ability.rb
+++ b/spree/core/app/models/spree/ability.rb
@@ -24,15 +24,34 @@ module Spree
# @return [Spree::Store, nil] the current store
attr_reader :store
+ # @return [Object] the resource whose role assignments this ability reads —
+ # the store for the admin panel, a Spree::Vendor for a vendor panel
+ attr_reader :resource
+
# @return [Array<String>] the expanded catalog keys this ability activated
# (empty for non-staff principals). Feeds `/me` and the admin key gate.
attr_reader :permission_keys
+ # @param user [Object] the principal
+ # @param options [Hash]
+ # @option options [Spree::Store] :store the current store
+ # @option options [Object] :resource the resource whose assignments grant
+ # capability — defaults to the store. Pass a Spree::Vendor to build the
+ # ability of a vendor panel from that vendor's own role assignments.
+ #
+ # **The ability answers capability, never tenancy.** A vendor holding
+ # `write_orders` gets `can :manage, Spree::Order` — the model class, not
+ # that vendor's subset — exactly as a store admin does. Which records a
+ # panel may touch is decided by scope-fetching in the controller
+ # (`current_vendor.orders`), the same way store isolation works on the
+ # admin branch. A panel controller that authorizes with `accessible_by`
+ # or `authorize!` and does NOT scope-fetch is reading store-wide.
def initialize(user, options = {})
alias_cancan_delete_action
@user = user || Spree.customer_class.new
@store = options[:store] || Spree::Current.store
+ @resource = options[:resource] || @store
@permission_keys = []
apply_staff_permissions if staff_principal?
@@ -70,31 +89,62 @@ module Spree
def apply_staff_permissions
roles = staff_roles
- if roles.any? { |role| role.name == Spree::Role::ADMIN_ROLE } || implicit_admin?(roles)
+ if full_access?(roles)
activate_full_access
else
apply_staff_baseline
- Spree.permissions.expand_keys(roles.flat_map(&:permissions)).each do |key|
- activate_permission(key)
- end
+ grantable_keys_for(roles).each { |key| activate_permission(key) }
end
end
- # The user's store-admin roles on the current store.
+ # Every key the roles ask for, bounded at activation by what each role's
+ # audience may hold. `Spree::Role` validates the same bound on write, but a
+ # catalog that changes after the role was saved would leave stale keys
+ # behind — the write-time check is a UX affordance, this is the boundary.
+ #
+ # @param roles [Array<Spree::Role>]
+ # @return [Array<String>]
+ def grantable_keys_for(roles)
+ roles.flat_map do |role|
+ keys = Spree.permissions.expand_keys(role.permissions)
+ next keys if role.staff?
+
+ keys & Spree.permissions.grantable_keys(role.audience)
+ end.uniq
+ end
+
+ # The super-role and the implicit-admin fallback are store-panel concepts:
+ # `admin` means "everything in this store", which is not a grant another
+ # panel's roles can carry. Outside the store panel, capability only ever
+ # comes from catalog keys.
+ def full_access?(roles)
+ return false unless store_resource?
+
+ roles.any?(&:admin?) || implicit_admin?(roles)
+ end
+
+ # @return [Boolean] whether this ability is being built for the store's own
+ # back office, as opposed to another panel (a marketplace vendor's)
+ def store_resource?
+ @resource.is_a?(Spree::Store)
+ end
+
+ # The user's roles on the ability's resource.
#
- # Assignments are matched on the store AND on a store resource: a
- # `RoleUser` scoped to a non-store resource (a marketplace vendor, say)
- # binds to that resource's store, so matching on `store_id` alone would
- # let a vendor's own staff role grant store-wide admin capability. Those
- # assignments belong to their own panel's ability, not this one.
+ # A role names what it governs, so matching on it answers both questions at
+ # once: which panel these grants belong to, and which tenant. A role owned
+ # by a marketplace vendor cannot be picked up here however it was assigned.
#
# @return [Array<Spree::Role>]
def staff_roles
- return [] unless @user.respond_to?(:role_users)
+ return @staff_roles if defined?(@staff_roles)
- @staff_roles ||= @user.role_users.
- where(store: @store, resource_type: Spree::Store.to_s).
- includes(:role).map(&:role)
+ @staff_roles =
+ if @user.respond_to?(:spree_roles) && @resource.present?
+ @user.spree_roles.for_resource(@resource).to_a
+ else
+ []
+ end
end
# Backward-compatible fallback for principals with no role rows whose
@@ -113,10 +163,19 @@ module Spree
# Reference data every staff member can read regardless of keys — address
# forms need countries/states, and the dashboard shell reads the store.
+ #
+ # The store grant is unrestricted only for the store's own back office.
+ # Another panel reads the one store it operates under and no other, so a
+ # marketplace's vendors cannot enumerate its sibling stores.
def apply_staff_baseline
can :read, Spree::Country
can :read, Spree::State
- can :read, Spree::Store
+
+ if store_resource? || @store.nil?
+ can :read, Spree::Store
+ else
+ can :read, Spree::Store, id: @store.id
+ end
end
end
diff --git a/spree/core/app/models/spree/invitation.rb b/spree/core/app/models/spree/invitation.rb
index 9377111895..818140f290 100644
--- a/spree/core/app/models/spree/invitation.rb
+++ b/spree/core/app/models/spree/invitation.rb
@@ -27,6 +27,7 @@ module Spree
validates :inviter, :resource, :role, presence: true
validate :invitee_is_not_inviter, on: :create
validate :invitee_already_exists, on: :create
+ validate :role_belongs_to_resource
#
# Scopes
@@ -55,6 +56,7 @@ module Spree
# Callbacks
#
after_initialize :set_defaults, if: :new_record?
+ before_validation :set_role_and_resource, if: :new_record?
before_validation :set_invitee_from_email, on: :create
after_commit :publish_invitation_created_event, on: :create, unless: :skip_email
@@ -110,8 +112,15 @@ module Spree
def set_defaults
self.expires_at ||= 2.weeks.from_now
- self.resource ||= Spree::Store.current
- self.role ||= Spree::Role.default_admin_role
+ end
+
+ # A role names what it governs, so the invitation follows it — one carrying
+ # another resource's role would grant access somewhere the inviter never
+ # named. Resolved at validation rather than on initialize, since a caller's
+ # own `resource` is not assigned yet when the record is instantiated.
+ def set_role_and_resource
+ self.resource ||= role&.resource || Spree::Store.current
+ self.role ||= Spree::Role.default_admin_role(resource)
end
def invitee_is_not_inviter
@@ -120,6 +129,15 @@ module Spree
end
end
+ # Accepting the invitation grants the role, which carries its own resource
+ # — so a mismatch would hand out access to somewhere else entirely.
+ def role_belongs_to_resource
+ return if role.blank? || resource.blank?
+ return if role.resource == resource
+
+ errors.add(:role, Spree.t(:invitation_role_resource_mismatch))
+ end
+
def invitee_already_exists
return if resource.blank?
diff --git a/spree/core/app/models/spree/refresh_token.rb b/spree/core/app/models/spree/refresh_token.rb
index a55ec9e99b..a5d8f68511 100644
--- a/spree/core/app/models/spree/refresh_token.rb
+++ b/spree/core/app/models/spree/refresh_token.rb
@@ -7,10 +7,18 @@ module Spree
has_secure_token :token
validates :user, :expires_at, presence: true
+ # On create only: rows minted before the column exists keep their NULL and
+ # stay loadable (they are simply unredeemable), while nothing new is born
+ # without the surface it belongs to.
+ validates :audience, presence: true, on: :create
scope :active, -> { where('expires_at > ?', Time.current) }
scope :expired, -> { where('expires_at <= ?', Time.current) }
+ # Tokens minted for one API surface. Always narrow a refresh lookup with
+ # this — a token is only redeemable on the surface that issued it.
+ scope :for_audience, ->(audience) { where(audience: audience) }
+
def expired?
expires_at <= Time.current
end
@@ -22,6 +30,7 @@ module Spree
transaction do
new_token = self.class.create!(
user: user,
+ audience: audience,
expires_at: self.class.default_expiry.from_now,
ip_address: request_env[:ip_address] || ip_address,
user_agent: request_env[:user_agent] || user_agent
@@ -31,10 +40,19 @@ module Spree
new_token
end
- # Create a refresh token for a user
- def self.create_for(user, request_env: {})
+ # Create a refresh token for a user.
+ #
+ # @param user [Object] the principal the token authenticates
+ # @param audience [String] the API surface the token may be redeemed on
+ # (`Spree::Api::V3::JwtAuthentication::JWT_AUDIENCE_ADMIN` and friends).
+ # Required: every redemption path narrows by audience, so an unstamped
+ # token authenticates a login and then fails its first refresh.
+ # @param request_env [Hash]
+ # @return [Spree::RefreshToken]
+ def self.create_for(user, audience:, request_env: {})
create!(
user: user,
+ audience: audience,
expires_at: default_expiry.from_now,
ip_address: request_env[:ip_address],
user_agent: request_env[:user_agent]
diff --git a/spree/core/app/models/spree/role.rb b/spree/core/app/models/spree/role.rb
index 83ff487aa4..6992d0efb8 100644
--- a/spree/core/app/models/spree/role.rb
+++ b/spree/core/app/models/spree/role.rb
@@ -2,7 +2,10 @@ module Spree
class Role < Spree.base_class
has_prefix_id :role
- include Spree::UniqueName
+ # Deliberately NOT Spree::UniqueName: its uniqueness is global, while a
+ # role is unique within the resource that owns it (see the name validation
+ # below). The normalization it applies is kept verbatim.
+ normalizes :name, with: ->(value) { value&.to_s&.squish&.presence }
ADMIN_ROLE = 'admin'
@@ -25,6 +28,12 @@ module Spree
#
# Associations
#
+ # What this role governs: a Spree::Store for back-office staff, a
+ # marketplace vendor for a seller's own team. The resource is the role's
+ # owner and its audience at once — a role on a Store is a staff role by
+ # construction, so there is no parallel column to keep in step.
+ belongs_to :resource, polymorphic: true
+
has_many :role_users, class_name: 'Spree::RoleUser', dependent: :destroy
has_many :users, through: :role_users, source: :user, source_type: Spree.customer_class.to_s
has_many :admin_users, through: :role_users, source: :user, source_type: Spree.admin_user_class.to_s
@@ -33,7 +42,15 @@ module Spree
#
# Validations
#
+ validates :resource, presence: true
+ # Unique within the owning resource rather than globally: two stores may
+ # each define a "Manager", and a store may hold one beside a vendor's.
+ validates :name, presence: true,
+ uniqueness: { case_sensitive: false, allow_blank: true,
+ scope: [*spree_base_uniqueness_scope, :resource_id, :resource_type] }
validate :permissions_must_be_known, if: :permissions_changed?
+ validate :permissions_must_be_grantable_for_resource, if: -> { permissions_changed? || resource_type_changed? }
+ validate :resource_immutable, on: :update, if: -> { resource_id_changed? || resource_type_changed? }
validate :name_immutable, on: :update, if: :name_changed?
validate :permissions_immutable, on: :update, if: :permissions_changed?
validate :description_immutable, on: :update, if: :description_changed?
@@ -49,22 +66,51 @@ module Spree
# Scopes
#
scope :admin, -> { where(name: ADMIN_ROLE) }
+ scope :for_resource, ->(resource) { where(resource: resource) }
#
# Class Methods
#
- def self.default_admin_role
- find_or_create_by(name: ADMIN_ROLE) do |role|
+ # The resource's own super-role, created on first ask. Each owns one:
+ # "admin" means everything in *this* store, so it cannot be shared.
+ #
+ # @param resource [Spree::Store, Object] defaults to the current store
+ # @return [Spree::Role]
+ def self.default_admin_role(resource = nil)
+ resource ||= Spree::Current.store || Spree::Store.current
+
+ for_resource(resource).find_or_create_by(name: ADMIN_ROLE) do |role|
role.mutable = false
end
end
- # The protected super-role. Guarded by name as well as the `mutable` flag
- # so a stale flag (e.g. a row predating the column) can never expose it.
+ # The protected super-role: everything in this store. Guarded by the owning
+ # resource as well as the name — names are unique per resource, so a vendor
+ # may legitimately call a role "admin" and it must never be mistaken for
+ # this one — and by the `mutable` flag, so a stale flag cannot expose it.
#
# @return [Boolean]
def admin?
- name == ADMIN_ROLE || name_was == ADMIN_ROLE
+ staff? && (name == ADMIN_ROLE || name_was == ADMIN_ROLE)
+ end
+
+ # Whether this role governs a store's own back office, as opposed to
+ # another panel's.
+ #
+ # @return [Boolean]
+ def staff?
+ resource_type == Spree::Store.to_s
+ end
+
+ # The permission catalog's name for the panel this role belongs to —
+ # derived from the owning resource, never stored, so the two cannot drift.
+ # `Spree::Vendor` reads as `:vendor`.
+ #
+ # @return [Symbol, nil]
+ def audience
+ return if resource_type.blank?
+
+ resource_type.demodulize.underscore.to_sym
end
# Whether the dashboard may edit or delete this role. False for the admin
@@ -91,6 +137,27 @@ module Spree
errors.add(:permissions, Spree.t(:role_permissions_unknown, keys: unknown.join(', '))) if unknown.any?
end
+ # A role outside the store's back office is bounded by the catalog: only
+ # resources registered as grantable to its kind may appear on it, so
+ # settings/staff/api_keys can never reach a seller, even from a seed.
+ def permissions_must_be_grantable_for_resource
+ return if staff? || resource_type.blank?
+
+ ungrantable = permissions - Spree.permissions.grantable_keys(audience)
+ return if ungrantable.none?
+
+ errors.add(
+ :permissions,
+ Spree.t(:role_permissions_not_grantable_for_audience, audience: audience, keys: ungrantable.join(', '))
+ )
+ end
+
+ # Re-pointing the resource would move every existing assignment to another
+ # panel — and, for a store, to another tenant.
+ def resource_immutable
+ errors.add(:resource, Spree.t(:role_resource_immutable))
+ end
+
def name_immutable
errors.add(:name, Spree.t(:role_immutable)) unless mutable_was_and_not_admin?
end
@@ -103,10 +170,12 @@ module Spree
errors.add(:description, Spree.t(:role_immutable)) unless mutable_was_and_not_admin?
end
- # Guards compare against the persisted state so flipping `mutable` in the
- # same save cannot smuggle a change past them.
+ # Guards compare against the persisted `mutable` so flipping it in the same
+ # save cannot smuggle a change past them. `admin?` reads the persisted name
+ # too, and is resource-aware — another resource may call a role "admin"
+ # without inheriting the store super-role's protection.
def mutable_was_and_not_admin?
- mutable_was && name_was != ADMIN_ROLE
+ mutable_was && !admin?
end
def ensure_can_be_deleted
diff --git a/spree/core/app/models/spree/role_user.rb b/spree/core/app/models/spree/role_user.rb
index 337a75ccdc..0e640a1442 100644
--- a/spree/core/app/models/spree/role_user.rb
+++ b/spree/core/app/models/spree/role_user.rb
@@ -1,13 +1,13 @@
module Spree
+ # A user holding a role. Where the grant applies is the role's business —
+ # `role.resource` names the store or vendor it governs — so an assignment
+ # carries nothing but the pairing.
class RoleUser < Spree.base_class
- include Spree::SingleStoreResource
-
#
# Associations
#
belongs_to :role, class_name: 'Spree::Role', foreign_key: :role_id
belongs_to :user, polymorphic: true
- belongs_to :resource, polymorphic: true
belongs_to :invitation, class_name: 'Spree::Invitation', optional: true, inverse_of: :role_user
#
@@ -15,40 +15,12 @@ module Spree
#
validates :role, presence: true
validates :user, presence: true
- validates :resource, presence: true
- validates :role_id, uniqueness: { scope: [:user_id, :resource_id, :user_type, :resource_type] }
+ validates :role_id, uniqueness: { scope: [:user_id, :user_type] }
#
# Delegations
#
delegate :name, to: :user
-
- #
- # Callbacks
- #
- before_validation :set_default_resource
-
- private
-
- # Set the default resource to the assignment's store (falling back to the
- # default store) if the resource is not set — this allows a graceful
- # migration from the old roles system to the new one.
- def set_default_resource
- self.resource ||= store || Spree::Store.current
- end
-
- # Overrides the SingleStoreResource fallback: the store binding follows
- # the resource — a store-resourced assignment applies on that store, a
- # vendor-resourced one on the vendor's store. Without this, a console or
- # seed assignment for another store would silently bind to
- # Spree::Current.store. An explicitly assigned store still wins, and
- # resources without a store keep the Current.store fallback.
- def ensure_store
- self.store ||= resource_bound_store || Spree::Current.store
- end
-
- def resource_bound_store
- resource.is_a?(Spree::Store) ? resource : resource.try(:store)
- end
+ delegate :resource, to: :role
end
end
diff --git a/spree/core/app/services/spree/seeds/all.rb b/spree/core/app/services/spree/seeds/all.rb
index dfc9e1aa09..675197d016 100644
--- a/spree/core/app/services/spree/seeds/all.rb
+++ b/spree/core/app/services/spree/seeds/all.rb
@@ -10,9 +10,6 @@ module Spree
# countries gem, and zones are migration-only, so none of them
# are seeded.
- # user roles
- Roles.call
-
# additional data
StoreCreditCategories.call
TaxCategories.call
@@ -20,6 +17,9 @@ module Spree
# store & channels
Stores.call
Channels.call
+ # Roles are store-owned, so they can only be seeded once a store
+ # exists — every store gets its own immutable admin role.
+ Roles.call
# Store-scoped, so it can only run once a store exists.
DigitalDelivery.call
# The warehouse, delivery zones and pickup are not seeded: their
diff --git a/spree/core/app/services/spree/seeds/roles.rb b/spree/core/app/services/spree/seeds/roles.rb
index 5150513080..db595c41d3 100644
--- a/spree/core/app/services/spree/seeds/roles.rb
+++ b/spree/core/app/services/spree/seeds/roles.rb
@@ -3,9 +3,13 @@ module Spree
class Roles
prepend Spree::ServiceModule::Base
+ # A role belongs to what it governs, so every store gets its own
+ # immutable admin.
def call
- admin = Spree::Role.where(name: Spree::Role::ADMIN_ROLE).first_or_create!
- admin.update_column(:mutable, false) if admin.read_attribute(:mutable)
+ Spree::Store.find_each do |store|
+ admin = Spree::Role.default_admin_role(store)
+ admin.update_column(:mutable, false) if admin.read_attribute(:mutable)
+ end
end
end
end
diff --git a/spree/core/config/locales/en.yml b/spree/core/config/locales/en.yml
index 6270c1e95f..47e7429832 100644
--- a/spree/core/config/locales/en.yml
+++ b/spree/core/config/locales/en.yml
@@ -1046,6 +1046,7 @@ en:
link_description: 'To accept this invitation, please click the link below:'
subject: Invitation to join %{resource_name}
thanks: Thank you,
+ invitation_role_resource_mismatch: must belong to the same store or vendor as the invitation
invitations: Invitations
invited_by: Invited by
iso: ISO Alpha-2
@@ -1455,7 +1456,9 @@ en:
role_cannot_be_deleted: This role is protected or still referenced by staff members or pending invitations and cannot be deleted
role_id: Role ID
role_immutable: cannot be changed on a protected role
+ role_permissions_not_grantable_for_audience: 'cannot be granted to a %{audience} role: %{keys}'
role_permissions_unknown: 'contains unknown permissions: %{keys}'
+ role_resource_immutable: cannot be changed once the role exists
roles: Roles
row: Row
rules: Rules
diff --git a/spree/core/db/migrate/20260613000001_add_store_id_to_spree_role_users.rb b/spree/core/db/migrate/20260613000001_add_store_id_to_spree_role_users.rb
index 05358abf23..2f5d697307 100644
--- a/spree/core/db/migrate/20260613000001_add_store_id_to_spree_role_users.rb
+++ b/spree/core/db/migrate/20260613000001_add_store_id_to_spree_role_users.rb
@@ -2,9 +2,12 @@ class AddStoreIdToSpreeRoleUsers < ActiveRecord::Migration[7.2]
def change
# Denormalizes the store a role assignment applies within, so role
# resolution (Spree::Ability) can scope by store without depending on the
- # polymorphic resource. Kept null: true here; existing rows are backfilled
- # by `spree:role_users:backfill_store_ids` and presence is enforced
- # on the model.
+ # polymorphic resource. Kept null: true here.
+ #
+ # Superseded in 6.0: the role itself names what it governs, so this column
+ # and the assignment's own resource are both dropped by
+ # AddResourceToSpreeRoles, which reads them one last time to decide which
+ # role each grant belongs to.
add_reference :spree_role_users, :store, null: true
end
end
diff --git a/spree/core/db/migrate/20260815000001_add_audience_to_spree_refresh_tokens.rb b/spree/core/db/migrate/20260815000001_add_audience_to_spree_refresh_tokens.rb
new file mode 100644
index 0000000000..ac421550e3
--- /dev/null
+++ b/spree/core/db/migrate/20260815000001_add_audience_to_spree_refresh_tokens.rb
@@ -0,0 +1,14 @@
+class AddAudienceToSpreeRefreshTokens < ActiveRecord::Migration[8.1]
+ # The API surface a refresh token was minted for. Without it a token minted
+ # on one surface can be presented to another surface's refresh endpoint and
+ # exchanged for that surface's access token — the cookie name is a
+ # convention, not a boundary.
+ #
+ # Nullable: tokens issued before this column exists carry no audience and
+ # are rejected on refresh, which costs their holders one login.
+ # No index on the column: every lookup finds by `token`, which is already
+ # uniquely indexed, and filters the single row it returns.
+ def change
+ add_column :spree_refresh_tokens, :audience, :string
+ end
+end
diff --git a/spree/core/db/migrate/20260815000002_add_resource_to_spree_roles.rb b/spree/core/db/migrate/20260815000002_add_resource_to_spree_roles.rb
new file mode 100644
index 0000000000..48e6efbbde
--- /dev/null
+++ b/spree/core/db/migrate/20260815000002_add_resource_to_spree_roles.rb
@@ -0,0 +1,190 @@
+class AddResourceToSpreeRoles < ActiveRecord::Migration[8.1]
+ # A role now names what it governs: a Spree::Store for back-office staff, a
+ # Spree::Vendor for a marketplace seller. That one fact replaces two — roles
+ # were global, so nothing said which store owned a definition, and nothing
+ # said which panel a role belonged to.
+ #
+ # Assignments lose their own copy of that answer. `spree_role_users` carried
+ # `resource` and `store_id`, both of which the role now supplies, so an
+ # assignment is reduced to "this user holds this role".
+ #
+ # The fan-out keys on assignments rather than roles: a bare
+ # `role_users.create!` used to bind whichever store was current, so one role
+ # row can legitimately be held on several stores. Each distinct pairing
+ # becomes its own role.
+ class MigrationRole < ActiveRecord::Base
+ self.table_name = 'spree_roles'
+ end
+
+ class MigrationRoleUser < ActiveRecord::Base
+ self.table_name = 'spree_role_users'
+ end
+
+ class MigrationInvitation < ActiveRecord::Base
+ self.table_name = 'spree_invitations'
+ end
+
+ class MigrationStore < ActiveRecord::Base
+ self.table_name = 'spree_stores'
+ end
+
+ def up
+ ensure_an_owner_is_available!
+
+ add_reference roles_table, :resource, polymorphic: true, index: false
+
+ MigrationRole.reset_column_information
+ fan_out_roles_per_resource
+ adopt_orphan_roles
+
+ change_column_null roles_table, :resource_id, false
+ change_column_null roles_table, :resource_type, false
+
+ remove_index roles_table, :name, unique: true
+ add_index roles_table, %i[resource_type resource_id name], unique: true,
+ name: 'index_spree_roles_on_resource_and_name'
+
+ dedupe_assignments
+ # Both indexes span the columns about to disappear. Dropping them first
+ # keeps adapters from silently rewriting them over what is left, which
+ # would leave a duplicate of the new index under a stale name.
+ remove_index assignments_table, name: 'index_spree_role_users_on_resource'
+ stale_index = role_user_resource_index_name
+ remove_index assignments_table, name: stale_index if stale_index
+
+ remove_column assignments_table, :resource_id
+ remove_column assignments_table, :resource_type
+ remove_column assignments_table, :store_id
+
+ add_index assignments_table, %i[user_type user_id role_id], unique: true,
+ name: 'index_spree_role_users_on_user_and_role'
+ end
+
+ # Dropping the columns discards which resource each grant applied to, and
+ # re-running `up` would have nothing left to fan out.
+ def down
+ raise ActiveRecord::IrreversibleMigration
+ end
+
+ private
+
+ # The names live on the classes above, so schema statements read them from
+ # there rather than spelling each one a second time.
+ def roles_table
+ MigrationRole.table_name
+ end
+
+ def assignments_table
+ MigrationRoleUser.table_name
+ end
+
+ # A role with no assignments has nothing to infer an owner from, so it falls
+ # back to the first store. Without one it would reach the NOT NULL constraint
+ # unowned and fail after the column was already added — say so up front
+ # instead, while nothing has been changed.
+ def ensure_an_owner_is_available!
+ return if MigrationStore.exists?
+ return unless MigrationRole.exists?
+
+ raise ActiveRecord::MigrationError,
+ 'Roles exist but no store does, so they have no owner to migrate to. ' \
+ 'Create the store these roles belong to (or delete them) and run this again.'
+ end
+
+ # The 2025 migration let Rails generate this name, so it is a digest rather
+ # than something to hardcode — find it by the columns it spans.
+ def role_user_resource_index_name
+ index = connection.indexes(assignments_table).find do |candidate|
+ candidate.columns.include?('resource_id') && candidate.columns.include?('role_id')
+ end
+
+ index&.name
+ end
+
+ # Every (role, resource) pairing an assignment or invitation names becomes a
+ # role of its own, and the rows that named it are re-pointed at it. The first
+ # pairing keeps the original row so existing ids stay valid.
+ def fan_out_roles_per_resource
+ MigrationRole.where(resource_id: nil).find_each do |role|
+ pairings = resource_pairings_for(role)
+ next if pairings.empty?
+
+ primary, *rest = pairings
+ claim_role(role.id, primary)
+
+ rest.each { |pairing| repoint(role, pairing) }
+ end
+ end
+
+ # Distinct resources this role is currently granted on, from both the
+ # assignments and any pending invitations.
+ def resource_pairings_for(role)
+ assigned = MigrationRoleUser.where(role_id: role.id).
+ where.not(resource_id: nil).
+ distinct.pluck(:resource_type, :resource_id)
+
+ invited = MigrationInvitation.where(role_id: role.id).
+ where.not(resource_id: nil).
+ distinct.pluck(:resource_type, :resource_id)
+
+ (assigned | invited).sort
+ end
+
+ def claim_role(role_id, (resource_type, resource_id))
+ MigrationRole.where(id: role_id).update_all(resource_type: resource_type, resource_id: resource_id)
+ end
+
+ def repoint(role, pairing)
+ resource_type, resource_id = pairing
+ copy_id = duplicate_role(role, pairing)
+
+ MigrationRoleUser.where(role_id: role.id, resource_type: resource_type, resource_id: resource_id).
+ update_all(role_id: copy_id)
+ MigrationInvitation.where(role_id: role.id, resource_type: resource_type, resource_id: resource_id).
+ update_all(role_id: copy_id)
+ end
+
+ # Reuses a same-named role already owned by that resource rather than
+ # creating a second one, since names are unique per resource.
+ def duplicate_role(role, (resource_type, resource_id))
+ owned = MigrationRole.where(resource_type: resource_type, resource_id: resource_id, name: role.name)
+ existing = owned.pick(:id)
+ return existing if existing
+
+ now = Time.current
+ MigrationRole.insert(
+ role.attributes.except('id').merge(
+ 'resource_type' => resource_type, 'resource_id' => resource_id,
+ 'created_at' => now, 'updated_at' => now
+ )
+ )
+ owned.pick(:id)
+ end
+
+ # Roles nobody holds have no resource to infer, so they go to the first store
+ # — the same store a bare assignment would have bound them to.
+ def adopt_orphan_roles
+ primary_store_id = MigrationStore.order(:id).pick(:id)
+ return if primary_store_id.nil?
+
+ MigrationRole.where(resource_id: nil).find_each do |role|
+ taken = MigrationRole.where(resource_type: 'Spree::Store', resource_id: primary_store_id, name: role.name)
+ next MigrationRole.where(id: role.id).delete_all if taken.exists?
+
+ MigrationRole.where(id: role.id).update_all(resource_type: 'Spree::Store', resource_id: primary_store_id)
+ end
+ end
+
+ # The old unique index spanned the resource, so one user could hold one role
+ # on several of them. The fan-out gives each pairing its own role, but a
+ # belt-and-braces collapse keeps the new index safe to add.
+ #
+ # The keepers are read out before the delete rather than left as a subquery:
+ # MySQL refuses to select from the table it is deleting from.
+ def dedupe_assignments
+ keepers = MigrationRoleUser.group(:user_type, :user_id, :role_id).minimum(:id).values
+ return if keepers.empty?
+
+ MigrationRoleUser.where.not(id: keepers).delete_all
+ end
+end
diff --git a/spree/core/lib/spree/core/permission_configuration.rb b/spree/core/lib/spree/core/permission_configuration.rb
index 58d092731b..f4af418879 100644
--- a/spree/core/lib/spree/core/permission_configuration.rb
+++ b/spree/core/lib/spree/core/permission_configuration.rb
@@ -20,6 +20,14 @@ module Spree
READ_PREFIX = 'read_'.freeze
WRITE_PREFIX = 'write_'.freeze
+ # A role's audience is its owning resource, lowercased — a role on a
+ # `Spree::Store` is `:store`, one on a `Spree::Vendor` is `:vendor` (see
+ # `Spree::Role#audience`).
+ #
+ # The store's own back office is the baseline: every resource is grantable
+ # there, so registrations name only the *additional* audiences they open up.
+ STAFF_AUDIENCE = :store
+
# A registered catalog resource. Yields one or two grantable keys and maps
# them to the CanCanCan subjects they cover.
class Resource
@@ -30,11 +38,14 @@ module Spree
# @param subjects [Proc, Array] CanCanCan subjects covered by this
# resource; pass a lambda so model classes resolve lazily
# @param write [Boolean] whether a `write_<name>` key exists
- def initialize(name:, group:, subjects:, write: true)
+ # @param audiences [Array<Symbol>] the non-staff audiences whose roles may
+ # hold this resource's keys
+ def initialize(name:, group:, subjects:, write: true, audiences: [])
@name = name.to_sym
@group = group.to_sym
@subjects = subjects
@write = write
+ @audiences = (Array(audiences).map(&:to_sym) | [STAFF_AUDIENCE]).freeze
end
# @return [Boolean]
@@ -42,6 +53,20 @@ module Spree
@write
end
+ # @return [Array<Symbol>] every audience this resource is grantable to,
+ # staff included
+ def audiences
+ @audiences
+ end
+
+ # @param audience [Symbol, String, nil]
+ # @return [Boolean]
+ def grantable_to?(audience)
+ return false if audience.blank?
+
+ @audiences.include?(audience.to_s.to_sym)
+ end
+
# @return [Array<Class, Symbol>]
def subjects
Array(@subjects.respond_to?(:call) ? @subjects.call : @subjects)
@@ -76,13 +101,20 @@ module Spree
# `:customers`, `:settings`, `:access`, `:analytics` — or your own)
# @param subjects [Proc, Array] CanCanCan subjects the keys grant
# @param write [Boolean]
+ # @param audiences [Array<Symbol>] the audiences beyond staff whose roles
+ # may hold these keys (`%i[vendor]`). Empty by default — opening a
+ # resource to another audience exposes it to a principal outside the
+ # store's own staff, so it is a deliberate act. Never open `settings`,
+ # `staff` or `api_keys`.
# @return [Resource]
- def register_resource(name, group:, subjects:, write: true)
+ def register_resource(name, group:, subjects:, write: true, audiences: [])
# `read_all` / `write_all` are the API-key wildcard aliases — a resource
# named `all` would silently mint keys that grant the whole catalog.
raise ArgumentError, "the permission resource name 'all' is reserved" if name.to_s == 'all'
- resource = Resource.new(name: name, group: group, subjects: subjects, write: write)
+ resource = Resource.new(
+ name: name, group: group, subjects: subjects, write: write, audiences: audiences
+ )
@resources[resource.name] = resource
end
@@ -135,6 +167,22 @@ module Spree
resources.flat_map(&:keys)
end
+ # Resources grantable to one audience. An unknown audience simply matches
+ # nothing, so a panel that does not exist yet reads as granting nothing
+ # rather than raising.
+ #
+ # @param audience [Symbol, String] `:store`, `:vendor`, …
+ # @return [Array<Resource>] in registration order
+ def grantable_resources(audience)
+ resources.select { |resource| resource.grantable_to?(audience) }
+ end
+
+ # @param audience [Symbol, String]
+ # @return [Array<String>] every key that audience may hold, in catalog order
+ def grantable_keys(audience)
+ grantable_resources(audience).flat_map(&:keys)
+ end
+
# @return [Array<Entry>] every grantable key with metadata, in catalog order
def entries
resources.flat_map do |resource|
@@ -229,20 +277,20 @@ module Spree
# are lambdas so model classes resolve at activation, not load, time.
# rubocop:disable Metrics/MethodLength
def register_default_resources
- register_resource(:orders, group: :orders, subjects: -> {
+ register_resource(:orders, group: :orders, audiences: %i[vendor], subjects: -> {
[Spree::Order, Spree::LineItem, Spree::TaxLine, Spree::Discount, Spree::Fee,
Spree::Return, Spree::Exchange, Spree::Claim, Spree::TaxIdentifier,
Spree::CustomField]
})
register_resource(:payments, group: :orders, subjects: -> { [Spree::Payment] })
- register_resource(:fulfillments, group: :orders, subjects: -> { [Spree::Fulfillment] })
+ register_resource(:fulfillments, group: :orders, audiences: %i[vendor], subjects: -> { [Spree::Fulfillment] })
register_resource(:refunds, group: :orders, subjects: -> { [Spree::Refund] })
register_resource(:gift_cards, group: :orders, subjects: -> {
[Spree::GiftCard, Spree::GiftCardBatch]
})
register_resource(:store_credits, group: :orders, subjects: -> { [Spree::StoreCredit] })
- register_resource(:products, group: :catalog, subjects: -> {
+ register_resource(:products, group: :catalog, audiences: %i[vendor], subjects: -> {
[Spree::Product, Spree::ProductType, Spree::Variant, Spree::OptionType,
Spree::OptionValue, Spree::Price, Spree::PriceList, Spree::PriceRule,
Spree::Asset, Spree::ProductPublication, Spree::CustomField]
@@ -253,7 +301,7 @@ module Spree
register_resource(:collections, group: :catalog, subjects: -> {
[Spree::Collection, Spree::ProductCollection, Spree::CollectionRule]
})
- register_resource(:stock, group: :catalog, subjects: -> {
+ register_resource(:stock, group: :catalog, audiences: %i[vendor], subjects: -> {
[Spree::StockItem, Spree::StockLocation, Spree::StockMovement,
Spree::StockTransfer, Spree::StockReservation]
})
@@ -289,7 +337,8 @@ module Spree
[Spree.admin_user_class, Spree::Invitation, Spree::Role, Spree::RoleUser]
})
- register_resource(:dashboard, group: :analytics, subjects: -> { [:dashboard] }, write: false)
+ register_resource(:dashboard, group: :analytics, subjects: -> { [:dashboard] },
+ write: false, audiences: %i[vendor])
end
# rubocop:enable Metrics/MethodLength
end
diff --git a/spree/core/lib/spree/core/previews/invitation_preview.rb b/spree/core/lib/spree/core/previews/invitation_preview.rb
index 6b95c19d12..f59d21f9b2 100644
--- a/spree/core/lib/spree/core/previews/invitation_preview.rb
+++ b/spree/core/lib/spree/core/previews/invitation_preview.rb
@@ -38,7 +38,7 @@ class Spree::InvitationPreview < ActionMailer::Preview
resource: store,
inviter: admin,
invitee: accepted ? admin : nil,
- role: Spree::Role.first || Spree::Role.new(name: 'admin'),
+ role: Spree::Role.for_resource(store).first || Spree::Role.new(name: 'admin', resource: store),
token: 'preview-token',
status: accepted ? 'accepted' : 'pending',
expires_at: 7.days.from_now
diff --git a/spree/core/lib/spree/testing_support/factories/refresh_token_factory.rb b/spree/core/lib/spree/testing_support/factories/refresh_token_factory.rb
index 94cc80ef26..c964b25217 100644
--- a/spree/core/lib/spree/testing_support/factories/refresh_token_factory.rb
+++ b/spree/core/lib/spree/testing_support/factories/refresh_token_factory.rb
@@ -3,9 +3,11 @@ FactoryBot.define do
association :user, factory: :user
user_type { user.class.to_s }
expires_at { Spree::RefreshToken.default_expiry.from_now }
+ audience { 'store_api' }
trait :for_admin do
association :user, factory: :admin_user
+ audience { 'admin_api' }
end
trait :expired do
diff --git a/spree/core/lib/spree/testing_support/factories/role_factory.rb b/spree/core/lib/spree/testing_support/factories/role_factory.rb
index 479a46613c..27522092b0 100644
--- a/spree/core/lib/spree/testing_support/factories/role_factory.rb
+++ b/spree/core/lib/spree/testing_support/factories/role_factory.rb
@@ -1,6 +1,7 @@
FactoryBot.define do
factory :role, class: Spree::Role do
sequence(:name) { |n| "Role #{n}" }
+ resource { Spree::Store.default || create(:store) }
factory :admin_role do
name { 'admin' }
diff --git a/spree/core/lib/spree/upgrades/5_5_to_5_6/manifest.yml b/spree/core/lib/spree/upgrades/5_5_to_5_6/manifest.yml
index 29eb2073fe..eed719b5a4 100644
--- a/spree/core/lib/spree/upgrades/5_5_to_5_6/manifest.yml
+++ b/spree/core/lib/spree/upgrades/5_5_to_5_6/manifest.yml
@@ -20,15 +20,6 @@ to: "5.6"
docs: "https://spreecommerce.org/docs/developer/upgrades/5.5-to-5.6"
steps:
- - id: role_user_store_ids
- name: "Backfill store_id on role assignments"
- task: "spree:role_users:backfill_store_ids"
- notes: |
- Sets spree_role_users.store_id from the store resource so Spree::Ability
- resolves roles by store. Store-scoped assignments only; extensions (e.g.
- spree_multi_vendor) backfill their own resource types. Store admins stay
- authorized via the spree_admin? fallback until this runs.
-
- id: single_store_promotions_payment_methods
name: "Backfill store_id on promotions and payment methods"
task: "spree:upgrade:populate_single_store_associations"
diff --git a/spree/core/lib/tasks/core.rake b/spree/core/lib/tasks/core.rake
index 01020b3941..195827a8a8 100644
--- a/spree/core/lib/tasks/core.rake
+++ b/spree/core/lib/tasks/core.rake
@@ -1,15 +1,5 @@
require 'active_record'
-namespace :db do
- task migrate_admin_users_to_role_users: :environment do |_t, _args|
- default_store = Spree::Store.default
- Spree::RoleUser.where(resource: nil).each do |role_user|
- role_user.update_columns(resource_type: default_store.class.name, resource_id: default_store.id)
- end
- end
-
-end
-
namespace :core do
desc 'Set "active" status on draft products where make_active_at is in the past'
task activate_products: :environment do |_t, _args|
diff --git a/spree/core/lib/tasks/role_users.rake b/spree/core/lib/tasks/role_users.rake
deleted file mode 100644
index eedf11fa6e..0000000000
--- a/spree/core/lib/tasks/role_users.rake
+++ /dev/null
@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-namespace :spree do
- namespace :role_users do
- desc <<~DESC
- Backfills +spree_role_users.store_id+ for store-scoped role assignments
- (resource_type = 'Spree::Store') by copying +resource_id+. Idempotent —
- only rows with a null +store_id+ are touched.
-
- Role resolution (Spree::Ability) scopes by +store_id+, so run this after
- adding the column. Until it does, the +spree_admin?+ fallback keeps store
- admins authorized. Role assignments on non-store resources (e.g.
- Spree::Vendor) are backfilled by the owning extension.
- DESC
- task backfill_store_ids: :environment do
- count = Spree::RoleUser.where(resource_type: Spree::Store.name, store_id: nil)
- .update_all('store_id = resource_id')
- puts " Backfilled store_id on #{count} store-scoped role assignment(s)."
- end
- end
-end
diff --git a/spree/core/spec/lib/spree/core/permission_configuration_spec.rb b/spree/core/spec/lib/spree/core/permission_configuration_spec.rb
index 49358d8a3c..1b460d42e4 100644
--- a/spree/core/spec/lib/spree/core/permission_configuration_spec.rb
+++ b/spree/core/spec/lib/spree/core/permission_configuration_spec.rb
@@ -45,6 +45,46 @@ RSpec.describe Spree::PermissionConfiguration do
end
end
+ describe 'audiences' do
+ it 'grants every resource to the store back office without naming it' do
+ configuration.register_resource(:reviews, group: :catalog, subjects: [Spree::Product])
+
+ expect(configuration.resource(:reviews)).to be_grantable_to(:store)
+ expect(configuration.grantable_keys(:store)).to eq(configuration.catalog_keys)
+ end
+
+ it 'grants a resource to the audiences it names, store included' do
+ configuration.register_resource(:reviews, group: :catalog, audiences: %i[vendor], subjects: [Spree::Product])
+
+ expect(configuration.resource(:reviews).audiences).to contain_exactly(:store, :vendor)
+ end
+
+ it 'withholds unnamed audiences' do
+ configuration.register_resource(:reviews, group: :catalog, subjects: [Spree::Product])
+
+ expect(configuration.resource(:reviews)).not_to be_grantable_to(:vendor)
+ expect(configuration.grantable_keys(:vendor)).not_to include('read_reviews')
+ end
+
+ it 'opens the seller-facing core resources to vendors' do
+ expect(configuration.grantable_keys(:vendor)).to include(
+ 'read_products', 'write_products', 'read_orders', 'write_orders',
+ 'read_fulfillments', 'write_fulfillments', 'read_stock', 'write_stock', 'read_dashboard'
+ )
+ end
+
+ it 'never opens the operator-only resources to vendors' do
+ expect(configuration.grantable_keys(:vendor)).not_to include(
+ 'read_settings', 'write_settings', 'read_staff', 'write_staff',
+ 'read_api_keys', 'write_api_keys', 'read_payments', 'read_refunds'
+ )
+ end
+
+ it 'reads an unregistered audience as granting nothing' do
+ expect(configuration.grantable_keys(:company)).to be_empty
+ end
+ end
+
describe '#unregister_resource' do
it 'removes the resource and its keys' do
configuration.register_resource(:reviews, group: :catalog, subjects: [Spree::Product])
diff --git a/spree/core/spec/lib/tasks/role_users_spec.rb b/spree/core/spec/lib/tasks/role_users_spec.rb
deleted file mode 100644
index 58cc6d6a36..0000000000
--- a/spree/core/spec/lib/tasks/role_users_spec.rb
+++ /dev/null
@@ -1,40 +0,0 @@
-require 'spec_helper'
-require 'rake'
-
-describe 'spree:role_users:backfill_store_ids' do
- subject { Rake::Task[task_name] }
-
- let(:task_name) { 'spree:role_users:backfill_store_ids' }
-
- before(:all) do
- Rake::Task.define_task(:environment)
- load Spree::Core::Engine.root.join('lib', 'tasks', 'role_users.rake')
- end
-
- before { subject.reenable }
-
- let!(:store) { Spree::Store.default || create(:store, default: true) }
- let(:role) { create(:role, name: 'test_role') }
- let(:user) { create(:user) }
-
- # The ensure_store callback stamps store_id on create, so null it to reproduce a
- # row created before the column existed.
- def downgrade!(role_user)
- role_user.update_columns(store_id: nil)
- role_user
- end
-
- context 'store-scoped role assignment' do
- let!(:role_user) { downgrade!(Spree::RoleUser.create!(role: role, user: user, resource: store)) }
-
- it 'backfills store_id from the store resource' do
- expect { subject.invoke }.to change { role_user.reload.store_id }.from(nil).to(store.id)
- end
-
- it 'is idempotent — a re-run changes nothing' do
- subject.invoke
- subject.reenable
- expect { subject.invoke }.not_to change { role_user.reload.store_id }
- end
- end
-end
diff --git a/spree/core/spec/models/spree/ability_spec.rb b/spree/core/spec/models/spree/ability_spec.rb
index e02e1c3405..3283ecb92b 100644
--- a/spree/core/spec/models/spree/ability_spec.rb
+++ b/spree/core/spec/models/spree/ability_spec.rb
@@ -85,7 +85,7 @@ describe Spree::Ability, type: :model do
context 'with a role granting a read key' do
before do
- admin.role_users.create!(role: create(:role, name: 'viewer', permissions: %w[read_orders]), resource: store)
+ admin.role_users.create!(role: create(:role, name: 'viewer', permissions: %w[read_orders], resource: store))
end
it 'grants read and admin on the resource subjects' do
@@ -105,7 +105,7 @@ describe Spree::Ability, type: :model do
context 'with a role granting a write key' do
before do
- admin.role_users.create!(role: create(:role, name: 'manager', permissions: %w[write_orders]), resource: store)
+ admin.role_users.create!(role: create(:role, name: 'manager', permissions: %w[write_orders], resource: store))
end
it 'grants manage on the resource subjects' do
@@ -120,8 +120,8 @@ describe Spree::Ability, type: :model do
context 'with multiple roles' do
before do
- admin.role_users.create!(role: create(:role, name: 'support', permissions: %w[read_orders]), resource: store)
- admin.role_users.create!(role: create(:role, name: 'merch', permissions: %w[write_products]), resource: store)
+ admin.role_users.create!(role: create(:role, name: 'support', permissions: %w[read_orders], resource: store))
+ admin.role_users.create!(role: create(:role, name: 'merch', permissions: %w[write_products], resource: store))
end
it 'combines keys from all roles' do
@@ -133,7 +133,7 @@ describe Spree::Ability, type: :model do
context 'with a role granting no keys' do
before do
- admin.role_users.create!(role: create(:role, name: 'empty'), resource: store)
+ admin.role_users.create!(role: create(:role, name: 'empty', resource: store))
end
it 'grants only the staff baseline' do
@@ -147,7 +147,7 @@ describe Spree::Ability, type: :model do
context 'with the admin role' do
before do
- admin.role_users.create!(role: Spree::Role.default_admin_role, resource: store)
+ admin.role_users.create!(role: Spree::Role.default_admin_role(store))
end
it 'grants everything and reports the full catalog' do
@@ -158,8 +158,8 @@ describe Spree::Ability, type: :model do
context 'with overlapping keys across roles' do
before do
- admin.role_users.create!(role: create(:role, name: 'viewer', permissions: %w[read_orders]), resource: store)
- admin.role_users.create!(role: create(:role, name: 'manager', permissions: %w[write_orders read_orders]), resource: store)
+ admin.role_users.create!(role: create(:role, name: 'viewer', permissions: %w[read_orders], resource: store))
+ admin.role_users.create!(role: create(:role, name: 'manager', permissions: %w[write_orders read_orders], resource: store))
end
it 'deduplicates into one expanded key set' do
@@ -172,8 +172,8 @@ describe Spree::Ability, type: :model do
let(:store_b) { create(:store) }
before do
- admin.role_users.create!(role: create(:role, name: 'a_orders', permissions: %w[write_orders]), resource: store)
- admin.role_users.create!(role: create(:role, name: 'b_products', permissions: %w[write_products]), resource: store_b)
+ admin.role_users.create!(role: create(:role, name: 'a_orders', permissions: %w[write_orders], resource: store))
+ admin.role_users.create!(role: create(:role, name: 'b_products', permissions: %w[write_products], resource: store_b))
end
it 'activates only the current store assignments' do
@@ -191,12 +191,73 @@ describe Spree::Ability, type: :model do
end
end
+ # A non-store resource stands in for a marketplace vendor until the Vendor
+ # model lands: what matters is that the role is owned by something other
+ # than the store, on the store's own turf.
+ context 'with a role held on a non-store resource' do
+ let(:panel) { create(:customer_group) }
+
+ before do
+ # Open orders to the stand-in's audience, as the catalog opens it to
+ # marketplace vendors.
+ Spree.permissions.register_resource(
+ :orders, group: :orders, audiences: %i[customer_group], subjects: -> { [Spree::Order] }
+ )
+ admin.role_users.create!(
+ role: create(:role, name: 'panel_orders', permissions: %w[write_orders], resource: panel)
+ )
+ end
+
+ after { Spree.permissions.reset! }
+
+ it 'is invisible to the store ability' do
+ expect(staff_ability).not_to be_able_to :read, Spree::Order.new
+ expect(staff_ability.permission_keys).to be_empty
+ end
+
+ # Capability, not tenancy: the grant is on the model class, as it is for
+ # a store admin. Which orders the panel may touch is decided by
+ # scope-fetching in its controllers, never here.
+ it 'activates when the ability is built for that resource' do
+ panel_ability = Spree::Ability.new(admin, store: store, resource: panel)
+
+ expect(panel_ability).to be_able_to :manage, Spree::Order.new
+ expect(panel_ability.permission_keys).to eq(%w[read_orders write_orders])
+ end
+
+ it 'grants only keys the role\'s audience may hold' do
+ role = Spree::Role.find_by(name: 'panel_orders')
+ role.update_column(:permissions, %w[write_orders write_settings])
+
+ panel_ability = Spree::Ability.new(admin, store: store, resource: panel)
+
+ expect(panel_ability.permission_keys).to eq(%w[read_orders write_orders])
+ expect(panel_ability).not_to be_able_to :read, Spree::TaxCategory.new
+ end
+
+ it 'reads only the store it operates under' do
+ other_store = create(:store)
+ panel_ability = Spree::Ability.new(admin, store: store, resource: panel)
+
+ expect(panel_ability).to be_able_to :read, store
+ expect(panel_ability).not_to be_able_to :read, other_store
+ end
+
+ it 'does not carry the store admin role onto the resource' do
+ admin.role_users.create!(role: Spree::Role.default_admin_role(store))
+ panel_ability = Spree::Ability.new(admin, store: store, resource: panel)
+
+ expect(panel_ability).not_to be_able_to :manage, :all
+ expect(panel_ability.permission_keys).to eq(%w[read_orders write_orders])
+ end
+ end
+
context 'as admin on one store and limited staff on another' do
let(:store_b) { create(:store) }
before do
- admin.role_users.create!(role: Spree::Role.default_admin_role, resource: store)
- admin.role_users.create!(role: create(:role, name: 'b_viewer', permissions: %w[read_orders]), resource: store_b)
+ admin.role_users.create!(role: Spree::Role.default_admin_role(store))
+ admin.role_users.create!(role: create(:role, name: 'b_viewer', permissions: %w[read_orders], resource: store_b))
end
it 'does not leak admin authority into the limited store' do
@@ -209,32 +270,40 @@ describe Spree::Ability, type: :model do
end
end
- context 'with the same role assigned on two stores' do
+ # A role belongs to one store, so "the same role on two stores" is two
+ # roles. Holding both grants each store's keys on that store alone.
+ context 'with a same-named role on two stores' do
let(:store_b) { create(:store) }
- let(:role) { create(:role, name: 'shared', permissions: %w[write_orders]) }
before do
- admin.role_users.create!(role: role, resource: store)
- admin.role_users.create!(role: role, resource: store_b)
+ admin.role_users.create!(role: create(:role, name: 'shared', permissions: %w[write_orders], resource: store))
+ admin.role_users.create!(role: create(:role, name: 'shared', permissions: %w[write_products], resource: store_b))
end
- it 'grants the same keys on each store' do
+ it 'grants each store only its own role keys' do
expect(staff_ability.permission_keys).to eq(%w[read_orders write_orders])
- expect(Spree::Ability.new(admin, store: store_b).permission_keys).to eq(%w[read_orders write_orders])
+ expect(Spree::Ability.new(admin, store: store_b).permission_keys).to eq(%w[read_products write_products])
end
end
- # A marketplace vendor's staff hold roles scoped to the vendor, which binds
- # to the vendor's store. Store-admin authority must come only from
- # store-resourced assignments, or a vendor picker would inherit the whole
- # store — including, for an `admin`-named vendor role, full access.
+ # A marketplace vendor's staff hold roles owned by the vendor. Store-admin
+ # authority must come only from the store's own roles, or a vendor picker
+ # would inherit the whole store — including, for an `admin`-named vendor
+ # role, full access.
context 'with an assignment scoped to a non-store resource' do
let(:vendor_like) { Spree::DummyModel.create!(name: 'Vendor A') }
+ before do
+ Spree.permissions.register_resource(
+ :products, group: :catalog, audiences: %i[dummy_model], subjects: -> { [Spree::Product] }
+ )
+ end
+
+ after { Spree.permissions.reset! }
+
it 'grants nothing in the store admin' do
admin.role_users.create!(
- role: create(:role, name: 'vendor_catalog', permissions: %w[write_products]),
- resource: vendor_like
+ role: create(:role, name: 'vendor_catalog', permissions: %w[write_products], resource: vendor_like)
)
expect(staff_ability).not_to be_able_to :manage, store.products.new
@@ -243,7 +312,7 @@ describe Spree::Ability, type: :model do
end
it 'does not confer full access through an admin-named role' do
- admin.role_users.create!(role: Spree::Role.default_admin_role, resource: vendor_like)
+ admin.role_users.create!(role: Spree::Role.default_admin_role(vendor_like))
expect(staff_ability).not_to be_able_to :manage, :all
expect(staff_ability.permission_keys).to eq([])
@@ -254,7 +323,7 @@ describe Spree::Ability, type: :model do
before do
role = create(:role, name: 'stale', permissions: %w[read_orders])
role.update_column(:permissions, %w[read_orders write_bogus])
- admin.role_users.create!(role: role, resource: store)
+ admin.role_users.create!(role: role)
end
it 'activates the known keys and drops the rest' do
@@ -287,8 +356,7 @@ describe Spree::Ability, type: :model do
it 'resolves staff roles for persisted customers' do
manager = create(:user)
manager.role_users.create!(
- role: create(:role, name: 'shared_manager', permissions: %w[write_orders]),
- resource: store
+ role: create(:role, name: 'shared_manager', permissions: %w[write_orders], resource: store)
)
shared_ability = Spree::Ability.new(manager, store: store)
@@ -315,7 +383,7 @@ describe Spree::Ability, type: :model do
let(:store_b) { create(:store) }
before do
- admin.role_users.create!(role: Spree::Role.default_admin_role, resource: store_a)
+ admin.role_users.create!(role: Spree::Role.default_admin_role(store_a))
end
it "grants authority on the role assignment's store" do
diff --git a/spree/core/spec/models/spree/concerns/user_management_spec.rb b/spree/core/spec/models/spree/concerns/user_management_spec.rb
index db943292c2..1a38530fbe 100644
--- a/spree/core/spec/models/spree/concerns/user_management_spec.rb
+++ b/spree/core/spec/models/spree/concerns/user_management_spec.rb
@@ -3,7 +3,8 @@ require 'spec_helper'
describe Spree::UserManagement do
let(:test_store) { create(:store) }
let(:admin_user) { create(:admin_user) }
- let(:role) { create(:role, name: 'test_role') }
+ # A role belongs to what it governs, so a grant on this store needs one here.
+ let(:role) { create(:role, name: 'test_role', resource: test_store) }
describe 'instance methods' do
describe '#add_user' do
@@ -14,6 +15,12 @@ describe Spree::UserManagement do
expect(admin_user.has_spree_role?('admin', test_store)).to be true
end
+ it 'refuses a role owned by another resource' do
+ foreign_role = create(:role, name: 'elsewhere', resource: create(:store))
+
+ expect { test_store.add_user(admin_user, foreign_role) }.to raise_error(ArgumentError)
+ end
+
it 'adds a user to the resource with a specified role' do
test_store.add_user(admin_user, role)
@@ -37,20 +44,27 @@ describe Spree::UserManagement do
end
describe '#default_user_role' do
- it 'returns the default admin role' do
- expect(test_store.default_user_role).to eq(Spree::Role.default_admin_role)
+ it 'returns the store own admin role' do
+ expect(test_store.default_user_role).to eq(Spree::Role.default_admin_role(test_store))
end
end
end
describe 'associations' do
- it 'has many role_users' do
- association = test_store.class.reflect_on_association(:role_users)
+ it 'has many roles' do
+ association = test_store.class.reflect_on_association(:roles)
expect(association.macro).to eq :has_many
- expect(association.options[:class_name]).to eq 'Spree::RoleUser'
+ expect(association.options[:class_name]).to eq 'Spree::Role'
expect(association.options[:as]).to eq :resource
end
+ # Assignments reach the resource through its roles, not directly.
+ it 'has many role_users through roles' do
+ association = test_store.class.reflect_on_association(:role_users)
+ expect(association.macro).to eq :has_many
+ expect(association.options[:through]).to eq :roles
+ end
+
it 'has many users through role_users' do
association = test_store.class.reflect_on_association(:users)
expect(association.macro).to eq :has_many
diff --git a/spree/core/spec/models/spree/concerns/user_roles_spec.rb b/spree/core/spec/models/spree/concerns/user_roles_spec.rb
index 845f923345..0def909def 100644
--- a/spree/core/spec/models/spree/concerns/user_roles_spec.rb
+++ b/spree/core/spec/models/spree/concerns/user_roles_spec.rb
@@ -14,6 +14,8 @@ describe Spree::UserRoles do
context 'when a resource parameter is provided' do
let(:resource) { create(:store) }
+ # A role belongs to what it governs, so the grant needs one here.
+ let!(:resource_role) { create(:role, name: 'test', resource: resource) }
before { test_user.add_role('test', resource) }
@@ -36,6 +38,8 @@ describe Spree::UserRoles do
context 'when a resource parameter is provided' do
let(:resource) { create(:store) }
+ # A role belongs to what it governs, so the grant needs one here.
+ let!(:resource_role) { create(:role, name: 'test', resource: resource) }
before { test_user.add_role('test', resource) }
@@ -62,6 +66,8 @@ describe Spree::UserRoles do
context 'when a resource parameter is provided' do
let(:resource) { create(:store) }
+ # A role belongs to what it governs, so the grant needs one here.
+ let!(:resource_role) { create(:role, name: 'test', resource: resource) }
context 'when the user has the role for the resource' do
before { test_user.add_role('test', resource) }
@@ -87,8 +93,11 @@ describe Spree::UserRoles do
context 'when a resource parameter is provided' do
let(:resource) { create(:store) }
+ # A role belongs to what it governs, so the grant needs one here.
+ let!(:resource_role) { create(:role, name: 'test', resource: resource) }
it 'checks against the resource' do
+ Spree::Role.default_admin_role(resource)
admin_user = create(:admin_user)
expect(admin_user.spree_admin?(resource)).to be false
diff --git a/spree/core/spec/models/spree/invitation_spec.rb b/spree/core/spec/models/spree/invitation_spec.rb
index 4f16870249..726e9e8b77 100644
--- a/spree/core/spec/models/spree/invitation_spec.rb
+++ b/spree/core/spec/models/spree/invitation_spec.rb
@@ -45,10 +45,26 @@ RSpec.describe Spree::Invitation, type: :model do
it 'sets defaults on initialization' do
invitation = build(:invitation)
expect(invitation.expires_at).to be_present
+ end
+
+ # Resolved at validation, not on initialize: the caller's own resource is
+ # not assigned yet when the record is instantiated.
+ it 'defaults the resource and its admin role before validation' do
+ invitation = build(:invitation)
+ invitation.valid?
+
expect(invitation.resource).to eq(Spree::Store.current)
expect(invitation.role).to eq(Spree::Role.default_admin_role)
end
+ it 'follows an explicitly assigned resource' do
+ other_store = create(:store)
+ invitation = build(:invitation, resource: other_store)
+ invitation.valid?
+
+ expect(invitation.role).to eq(Spree::Role.default_admin_role(other_store))
+ end
+
it 'sets invitee from email before validation' do
create(:admin_user, :without_admin_role, email: '[email protected]')
diff --git a/spree/core/spec/models/spree/refresh_token_spec.rb b/spree/core/spec/models/spree/refresh_token_spec.rb
index 729619812e..252eaf4e86 100644
--- a/spree/core/spec/models/spree/refresh_token_spec.rb
+++ b/spree/core/spec/models/spree/refresh_token_spec.rb
@@ -18,15 +18,31 @@ RSpec.describe Spree::RefreshToken, type: :model do
end
it 'auto-generates a token via has_secure_token' do
- token = described_class.create!(user: user, expires_at: 30.days.from_now)
+ token = described_class.create!(user: user, audience: 'store_api', expires_at: 30.days.from_now)
expect(token.token).to be_present
expect(token.token.length).to be >= 24
end
+
+ it 'requires an audience on create' do
+ token = described_class.new(user: user, expires_at: 30.days.from_now)
+
+ expect(token).not_to be_valid
+ expect(token.errors[:audience]).to be_present
+ end
+
+ # Rows minted before the column existed stay loadable and saveable — they
+ # are unredeemable at every refresh endpoint, which is enough.
+ it 'tolerates a legacy row with no audience on update' do
+ token = described_class.create!(user: user, audience: 'store_api', expires_at: 30.days.from_now)
+ token.update_column(:audience, nil)
+
+ expect(token.reload.update(ip_address: '10.0.0.1')).to be(true)
+ end
end
describe '.create_for' do
it 'creates a refresh token for a user' do
- token = described_class.create_for(user)
+ token = described_class.create_for(user, audience: 'store_api')
expect(token).to be_persisted
expect(token.user).to eq(user)
@@ -35,7 +51,7 @@ RSpec.describe Spree::RefreshToken, type: :model do
end
it 'stores request env data' do
- token = described_class.create_for(user, request_env: {
+ token = described_class.create_for(user, audience: 'store_api', request_env: {
ip_address: '192.168.1.1',
user_agent: 'Mozilla/5.0'
})
@@ -45,7 +61,7 @@ RSpec.describe Spree::RefreshToken, type: :model do
end
it 'sets default 30-day expiry' do
- token = described_class.create_for(user)
+ token = described_class.create_for(user, audience: 'store_api')
expect(token.expires_at).to be_within(1.minute).of(30.days.from_now)
end
@@ -53,19 +69,19 @@ RSpec.describe Spree::RefreshToken, type: :model do
describe '#expired?' do
it 'returns false for active tokens' do
- token = described_class.create_for(user)
+ token = described_class.create_for(user, audience: 'store_api')
expect(token.expired?).to be false
end
it 'returns true for expired tokens' do
- token = described_class.create_for(user)
+ token = described_class.create_for(user, audience: 'store_api')
token.update_column(:expires_at, 1.hour.ago)
expect(token.expired?).to be true
end
end
describe '#rotate!' do
- let!(:original_token) { described_class.create_for(user) }
+ let!(:original_token) { described_class.create_for(user, audience: 'store_api') }
it 'destroys the original token' do
original_id = original_token.id
@@ -101,9 +117,9 @@ RSpec.describe Spree::RefreshToken, type: :model do
end
describe 'scopes' do
- let!(:active_token) { described_class.create_for(user) }
+ let!(:active_token) { described_class.create_for(user, audience: 'store_api') }
let!(:expired_token) do
- t = described_class.create_for(user)
+ t = described_class.create_for(user, audience: 'store_api')
t.update_column(:expires_at, 1.day.ago)
t
end
@@ -125,8 +141,8 @@ RSpec.describe Spree::RefreshToken, type: :model do
describe '.revoke_all_for' do
it 'deletes all tokens for a user' do
- described_class.create_for(user)
- described_class.create_for(user)
+ described_class.create_for(user, audience: 'store_api')
+ described_class.create_for(user, audience: 'store_api')
expect {
described_class.revoke_all_for(user)
@@ -135,8 +151,8 @@ RSpec.describe Spree::RefreshToken, type: :model do
it 'does not delete tokens for other users' do
other_user = create(:user)
- described_class.create_for(user)
- other_token = described_class.create_for(other_user)
+ described_class.create_for(user, audience: 'store_api')
+ other_token = described_class.create_for(other_user, audience: 'store_api')
described_class.revoke_all_for(user)
@@ -146,8 +162,8 @@ RSpec.describe Spree::RefreshToken, type: :model do
describe '.cleanup_expired!' do
it 'deletes expired tokens' do
- active = described_class.create_for(user)
- expired = described_class.create_for(user)
+ active = described_class.create_for(user, audience: 'store_api')
+ expired = described_class.create_for(user, audience: 'store_api')
expired.update_column(:expires_at, 1.day.ago)
described_class.cleanup_expired!
@@ -159,7 +175,7 @@ RSpec.describe Spree::RefreshToken, type: :model do
describe 'prefixed_id' do
it 'uses rt_ prefix' do
- token = described_class.create_for(user)
+ token = described_class.create_for(user, audience: 'store_api')
expect(token.prefixed_id).to start_with('rt_')
end
end
diff --git a/spree/core/spec/models/spree/role_spec.rb b/spree/core/spec/models/spree/role_spec.rb
index bfa1aba44c..5dc7964152 100644
--- a/spree/core/spec/models/spree/role_spec.rb
+++ b/spree/core/spec/models/spree/role_spec.rb
@@ -3,6 +3,9 @@ require 'spec_helper'
describe Spree::Role do
let(:role) { create(:role) }
let(:user) { create(:user) }
+ # A non-store resource stands in for a marketplace vendor until that model
+ # lands: what matters is that the role is owned by something else.
+ let(:vendor_like) { create(:customer_group) }
describe 'with users' do
before do
@@ -16,11 +19,35 @@ describe Spree::Role do
describe '.default_admin_role' do
it 'returns the admin role, seeded immutable' do
- admin_role = Spree::Role.default_admin_role
+ admin_role = Spree::Role.default_admin_role(@default_store)
expect(admin_role.name).to eq('admin')
expect(admin_role.read_attribute(:mutable)).to be false
end
+
+ # Names are unique per owner, so another resource may legitimately call a
+ # role "admin" — it must never be mistaken for the store super-role.
+ it 'ignores a same-named role owned by something else' do
+ foreign_admin = create(:role, name: 'admin', resource: vendor_like)
+
+ admin_role = Spree::Role.default_admin_role(@default_store)
+
+ expect(admin_role).not_to eq(foreign_admin)
+ expect(admin_role).to be_staff
+ expect(foreign_admin).not_to be_admin
+ expect(foreign_admin).to be_mutable
+ end
+
+ # "admin" means everything in *this* store, so it cannot be one shared row.
+ it 'gives each store its own' do
+ other_store = create(:store)
+
+ first = Spree::Role.default_admin_role(@default_store)
+ second = Spree::Role.default_admin_role(other_store)
+
+ expect(second).not_to eq(first)
+ expect(second.resource).to eq(other_store)
+ end
end
describe '#permissions' do
@@ -49,6 +76,75 @@ describe Spree::Role do
end
end
+ describe '#resource' do
+ it 'reads its audience from the owning resource' do
+ expect(build(:role).audience).to eq(:store)
+ expect(build(:role)).to be_staff
+ expect(build(:role, resource: vendor_like).audience).to eq(:customer_group)
+ expect(build(:role, resource: vendor_like)).not_to be_staff
+ end
+
+ it 'is required' do
+ expect(build(:role, resource: nil)).not_to be_valid
+ end
+
+ it 'cannot be changed once the role exists' do
+ role = create(:role)
+ role.resource = create(:store)
+
+ expect(role).not_to be_valid
+ expect(role.errors[:resource]).to be_present
+ end
+
+ it 'allows the same name under a different owner' do
+ create(:role, name: 'Manager', resource: @default_store)
+
+ expect(build(:role, name: 'Manager', resource: vendor_like)).to be_valid
+ expect(build(:role, name: 'Manager', resource: create(:store))).to be_valid
+ end
+
+ it 'still rejects a duplicate name under one owner' do
+ create(:role, name: 'Manager', resource: vendor_like)
+
+ expect(build(:role, name: 'Manager', resource: vendor_like)).not_to be_valid
+ end
+
+ it 'scopes roles to their owner' do
+ staff_role = create(:role)
+ other_role = create(:role, resource: vendor_like)
+
+ expect(Spree::Role.for_resource(@default_store)).to include(staff_role)
+ expect(Spree::Role.for_resource(@default_store)).not_to include(other_role)
+ expect(Spree::Role.for_resource(vendor_like)).to eq([other_role])
+ end
+ end
+
+ describe 'resource-bounded permissions' do
+ before do
+ Spree.permissions.register_resource(
+ :products, group: :catalog, audiences: %i[customer_group], subjects: -> { [Spree::Product] }
+ )
+ end
+
+ after { Spree.permissions.reset! }
+
+ it 'allows a non-store role to hold keys its audience is granted' do
+ expect(build(:role, resource: vendor_like, permissions: %w[write_products])).to be_valid
+ end
+
+ it 'refuses keys its audience is not granted' do
+ role = build(:role, resource: vendor_like, permissions: %w[write_products write_settings])
+
+ expect(role).not_to be_valid
+ expect(role.errors[:permissions].join).to include('write_settings')
+ expect(role.errors[:permissions].join).not_to include('write_products')
+ end
+
+ it 'leaves store roles unbounded' do
+ expect(build(:role, permissions: %w[write_settings write_staff])).to be_valid
+ end
+ end
+
describe 'admin role protection' do
let(:admin_role) { Spree::Role.default_admin_role }
@@ -69,6 +165,16 @@ describe Spree::Role do
expect(admin_role).not_to be_valid
end
+ # The protection is the store's super-role, not the name: another resource
+ # may call a role "admin" and it stays an ordinary, editable role.
+ it 'leaves a same-named role owned by something else editable' do
+ foreign_admin = create(:role, name: 'admin', resource: vendor_like)
+ foreign_admin.name = 'renamed'
+
+ expect(foreign_admin).to be_mutable
+ expect(foreign_admin).to be_valid
+ end
+
it 'cannot be destroyed' do
expect(admin_role.destroy).to be false
expect(admin_role.errors[:base]).to be_present
diff --git a/spree/core/spec/models/spree/role_user_spec.rb b/spree/core/spec/models/spree/role_user_spec.rb
index 96e368d97d..e1338d3130 100644
--- a/spree/core/spec/models/spree/role_user_spec.rb
+++ b/spree/core/spec/models/spree/role_user_spec.rb
@@ -26,47 +26,28 @@ describe Spree::RoleUser do
end
end
- describe 'Callbacks' do
- describe 'before_validation :set_default_resource' do
- it 'sets the resource to the current store if it is not set' do
- role_user = described_class.new(role: role, user: spree_user)
- expect(role_user.valid?).to be_truthy
+ # An assignment carries no copy of where it applies — the role says.
+ describe '#resource' do
+ it 'comes from the role' do
+ other_store = create(:store)
+ role_user = described_class.new(role: create(:role, resource: other_store), user: spree_user)
- expect(role_user.resource).to eq(Spree::Store.current)
- end
+ expect(role_user.resource).to eq(other_store)
end
+ end
- describe 'before_validation :ensure_store' do
- it 'sets the store to the current store' do
- role_user = described_class.new(role: role, user: spree_user)
- expect(role_user.valid?).to be_truthy
-
- expect(role_user.store).to eq(Spree::Current.store)
- end
-
- it 'keeps an explicitly assigned store' do
- store = create(:store)
- role_user = described_class.new(role: role, user: spree_user, store: store)
- expect(role_user.valid?).to be_truthy
-
- expect(role_user.store).to eq(store)
- end
-
- it 'binds the store to a store resource, not the current store' do
- other_store = create(:store)
- role_user = described_class.new(role: role, user: spree_user, resource: other_store)
- expect(role_user.valid?).to be_truthy
+ describe 'uniqueness' do
+ it 'allows a user to hold a role once' do
+ create(:role_user, role: role, user: spree_user)
- expect(role_user.store).to eq(other_store)
- end
+ expect(described_class.new(role: role, user: spree_user)).not_to be_valid
+ end
- it 'defaults the resource to an explicitly assigned store' do
- store = create(:store)
- role_user = described_class.new(role: role, user: spree_user, store: store)
- expect(role_user.valid?).to be_truthy
+ it 'allows the same user to hold a role owned by another resource' do
+ create(:role_user, role: role, user: spree_user)
+ other_role = create(:role, name: 'test_role', resource: create(:store))
- expect(role_user.resource).to eq(store)
- end
+ expect(described_class.new(role: other_role, user: spree_user)).to be_valid
end
end
diff --git a/spree/core/spec/services/spree/seeds/admin_user_spec.rb b/spree/core/spec/services/spree/seeds/admin_user_spec.rb
index 68f34c6170..2f4d7bca4e 100644
--- a/spree/core/spec/services/spree/seeds/admin_user_spec.rb
+++ b/spree/core/spec/services/spree/seeds/admin_user_spec.rb
@@ -12,7 +12,7 @@ RSpec.describe Spree::Seeds::AdminUser do
expect { subject }.to change(Spree.admin_user_class, :count).by(1)
admin = Spree.admin_user_class.find_by(email: '[email protected]')
- expect(admin.role_users.exists?(store: @default_store)).to be(true)
+ expect(admin.spree_roles.for_resource(@default_store)).to exist
end
it 'does nothing when an admin already exists' do