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.
Ruby b2b-commercee-commerceecommerceecommerce-apiecommerce-frameworkecommerce-platformheadlessheadless-commerceheadless-ecommercemarketplacemulti-tenantmulti-vendormulti-vendor-ecommerceopen-sourcespree-commerce
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.mdindex 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 fromvendor-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-panelendpoints scope-fetch through `current_vendor` exactly as admin endpointsscope 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 thevendor'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`, nothere. **Settled there 2026-08-15 (Decision 10):** vendor staff arediff --git a/docs/plans/6.0-multi-vendor-marketplace.md b/docs/plans/6.0-multi-vendor-marketplace.mdindex 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.mdindex 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 rewrittenAmends the 2026-08-13 first-run setup entry. Damian's call, afterdiff --git a/packages/dashboard/e2e/global-setup.ts b/packages/dashboard/e2e/global-setup.tsindex 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 namediff --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.rbindex 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_areturn false if roles.empty?return true if reject_admin_role_grant!(roles)@@ -76,7 +76,7 @@ module Spreeenddef 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 Spreeendend- # 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 Spreeuser = 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_aelse[]end@@ -132,7 +128,7 @@ module Spreedef 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)enddiff --git a/spree/api/app/controllers/concerns/spree/api/v3/admin_authentication.rb b/spree/api/app/controllers/concerns/spree/api/v3/admin_authentication.rbindex 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 Spreefalseend+ # 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?enddef set_no_store_cachediff --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.rbindex 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 destroyauthorize!(:destroy, @resource)- @resource.role_users.where(resource: current_store).destroy_all+ @resource.role_users.where(role: current_store.roles).destroy_allhead :no_contentend@@ -62,7 +62,7 @@ module Spreeenddef 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_allendendenddiff --git a/spree/api/app/controllers/spree/api/v3/admin/auth_controller.rb b/spree/api/app/controllers/spree/api/v3/admin/auth_controller.rbindex 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 Spreeif 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 Spreereturn 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_dashboardend@@ -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/logoutdef logoutrefresh_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+ endclear_refresh_cookiehead :no_contentdiff --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.rbindex 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 => ediff --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.rbindex 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.rbindex 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 Spreemodule V3module 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 < ResourceControllerinclude Spree::Api::V3::Admin::RoleGrantGuard@@ -38,14 +39,24 @@ module SpreeSpree.api.admin_role_serializerend+ # 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)enddef 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_paramsparams.permit(:name, :description, permissions: [])enddiff --git a/spree/api/app/controllers/spree/api/v3/admin/setup_controller.rb b/spree/api/app/controllers/spree/api/v3/admin/setup_controller.rbindex 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 Spreeadopt_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 => ediff --git a/spree/api/app/controllers/spree/api/v3/store/auth_controller.rb b/spree/api/app/controllers/spree/api/v3/store/auth_controller.rbindex 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 logoutrefresh_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+ endhead :no_contentend@@ -101,7 +104,7 @@ module Spreeprivatedef 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.rbindex 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.rbindex 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 Spreeif 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.rbindex 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 }endenddiff --git a/spree/api/app/serializers/spree/api/v3/admin/role_serializer.rb b/spree/api/app/serializers/spree/api/v3/admin/role_serializer.rbindex 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 Spreemodule Apimodule V3module 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::BaseSerializertypelize name: :string, description: 'string | null', mutable: :boolean,users_count: :number@@ -19,9 +20,10 @@ module Spreeattribute(: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.sizeendendenddiff --git a/spree/api/lib/spree/api/testing_support/v3/base.rb b/spree/api/lib/spree/api/testing_support/v3/base.rbindex 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' doinclude_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.rbindex 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: :controllercontext 'with X-Spree-Store-Id naming a store the admin has a role on' dobefore 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_idenddiff --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.rbindex 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) docreate(: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)endend@@ -35,14 +35,14 @@ RSpec.describe Spree::Api::V3::Admin::AdminUsersController, type: :controller dopatch :update, params: { id: target.prefixed_id, role_ids: [other_role.prefixed_id] }, as: :jsonexpect(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 existendendcontext 'authenticated as a staff JWT without staff permissions' dolet(: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) }endlet(:headers) doapi_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 doit 'cannot assign any role' doexpect {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 doit 'cannot mutate roles with unresolved role ids' doexpect {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 docontext 'authenticated as a staff JWT holding write_staff' dolet(: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) }endlet(:headers) doapi_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 dopatch :update, params: { id: target.prefixed_id, role_ids: [staff_role.prefixed_id] }, as: :jsonexpect(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 existendit 'forbids promoting an account to admin' do@@ -105,7 +105,7 @@ RSpec.describe Spree::Api::V3::Admin::AdminUsersController, type: :controller dopatch :update, params: { id: target.prefixed_id, role_ids: [owner_role.prefixed_id] }, as: :jsonexpect(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 existendenddiff --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.rbindex 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 doenddescribe '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' dobefore do@@ -261,10 +261,28 @@ RSpec.describe Spree::Api::V3::Admin::AuthController, type: :controller doexpect(set_cookie_for('spree_admin_refresh_token')).to include('=;')endend++ # 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+ endenddescribe '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' dobefore do@@ -289,6 +307,21 @@ RSpec.describe Spree::Api::V3::Admin::AuthController, type: :controller doexpect(response).to have_http_status(:no_content)endend++ 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+ endenddescribe 'response headers' dodiff --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.rbindex 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 dolet(:other_store) { create(:store) }let(:foreign_admin) docreate(: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))endendlet(:foreign_admin_jwt) do@@ -197,6 +197,39 @@ RSpec.describe Spree::Api::V3::Admin::BaseController, type: :controller doexpect(response).to have_http_status(:forbidden)endend++ # 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+ endenddescribe 'authentication priority (secret key vs JWT)' dodiff --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.rbindex 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 dcontext 'authenticated as a non-admin staff JWT' dolet(: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) }endlet(:headers) doapi_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 dexpect(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)+ endendendenddiff --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.rbindex 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 docontext 'as a staffer with a limited role' dolet(:staffer) docreate(: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))endendlet(:headers) do@@ -91,8 +91,8 @@ RSpec.describe Spree::Api::V3::Admin::MeController, type: :controller dolet(:store_b) { create(:store) }let(:staffer) docreate(: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))endendlet(:headers) dodiff --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.rbindex 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: :controlleendit '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: :controlleexpect(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' dopatch :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.rbindex 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 dcontext 'with a limited staff JWT' dolet(:staffer) docreate(: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))endendlet(:headers) dodiff --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.rbindex 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 doexpect(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' doget :index, as: :json@@ -53,10 +64,8 @@ RSpec.describe Spree::Api::V3::Admin::RolesController, type: :controller docontext 'as a staffer with limited permissions' dolet(:staffer) docreate(: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]))endendlet(:headers) do@@ -77,29 +86,30 @@ RSpec.describe Spree::Api::V3::Admin::RolesController, type: :controller doexpect(Spree::Role.find_by(name: 'sneaky')).to be_nilend- # 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: :jsonexpect(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' dostore_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 doit 'refuses to delete a role still assigned to staff' dorole = 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: :jsondiff --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.rbindex 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 doexpect(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_nilexpect(response.cookies['spree_admin_refresh_token']).to be_presentdiff --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.rbindex 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 docontext 'as a staffer without any settings permission' dolet(:staffer) docreate(: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]))endendlet(:headers) dodiff --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.rbindex 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: :controllercontext 'as a staffer holding read_products' dolet(:staffer) docreate(: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))endendlet(:headers) do@@ -63,7 +63,7 @@ RSpec.describe Spree::Api::V3::Admin::TranslationsController, type: :controllercontext 'as a staffer without a products permission' dolet(:staffer) docreate(: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))endendlet(:headers) dodiff --git a/spree/api/spec/controllers/spree/api/v3/scoped_authorization_spec.rb b/spree/api/spec/controllers/spree/api/v3/scoped_authorization_spec.rbindex 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 docontext 'as a staffer whose roles grant the required key' dolet(:staffer) docreate(: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))endendlet(: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 docontext 'as a staffer whose roles lack the required key' dolet(:staffer) docreate(: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))endendlet(: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.rbindex 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 doexpect(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' dopost :logoutdiff --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.rbindex 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.rbindex 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) douser = admin_user- user.role_users.find_or_create_by!(role: admin_role, resource: store)+ user.role_users.find_or_create_by!(role: admin_role)userend@@ -123,7 +123,7 @@ RSpec.describe 'Admin Staff API', type: :request, swagger_doc: 'api-reference/adrun_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 falseendendenddiff --git a/spree/api/spec/integration/spree/api/v3/admin/auth_spec.rb b/spree/api/spec/integration/spree/api/v3/admin/auth_spec.rbindex 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-refresponse '200', 'refresh successful' dolet(:'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 integrationdiff --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.rbindex 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 dodescribe 'stores' doit 'lists every store the user holds a role on, not just the current one' doother_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 doendit '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])enddiff --git a/spree/core/app/models/concerns/spree/user_management.rb b/spree/core/app/models/concerns/spree/user_management.rbindex 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 UserManagementextend ActiveSupport::Concernincluded 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_usershas_many :users, through: :role_users, source: :user, source_type: Spree.admin_user_class.to_shas_many :invitations, class_name: 'Spree::Invitation', as: :resource, dependent: :destroyend@@ -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_allend# 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)endendenddiff --git a/spree/core/app/models/concerns/spree/user_roles.rb b/spree/core/app/models/concerns/spree/user_roles.rbindex 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 Spreeincluded dohas_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 destroyinghas_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: :destroyhas_many :sent_invitations, class_name: 'Spree::Invitation', as: :inviter, dependent: :destroy@@ -18,10 +18,10 @@ module Spree# @return [Spree::RoleUser] The role user createddef 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 fromdef 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_allend# has_spree_role? simply needs to return true or false whether a user has a role or not.@@ -44,7 +44,7 @@ module Spreedef 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 Spreedef invited_byinvitations.first&.inviterend+endendenddiff --git a/spree/core/app/models/spree/ability.rb b/spree/core/app/models/spree/ability.rbindex 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 storeattr_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 Spreedef apply_staff_permissionsroles = staff_roles- if roles.any? { |role| role.name == Spree::Role::ADMIN_ROLE } || implicit_admin?(roles)+ if full_access?(roles)activate_full_accesselseapply_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) }endend- # 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+ []+ endend# 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_baselinecan :read, Spree::Countrycan :read, Spree::State- can :read, Spree::Store++ if store_resource? || @store.nil?+ can :read, Spree::Store+ else+ can :read, Spree::Store, id: @store.id+ endendenddiff --git a/spree/core/app/models/spree/invitation.rb b/spree/core/app/models/spree/invitation.rbindex 9377111895..818140f290 100644--- a/spree/core/app/models/spree/invitation.rb+++ b/spree/core/app/models/spree/invitation.rb@@ -27,6 +27,7 @@ module Spreevalidates :inviter, :resource, :role, presence: truevalidate :invitee_is_not_inviter, on: :createvalidate :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: :createafter_commit :publish_invitation_created_event, on: :create, unless: :skip_email@@ -110,8 +112,15 @@ module Spreedef set_defaultsself.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)enddef invitee_is_not_inviter@@ -120,6 +129,15 @@ module Spreeendend+ # 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_existsreturn if resource.blank?diff --git a/spree/core/app/models/spree/refresh_token.rb b/spree/core/app/models/spree/refresh_token.rbindex 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 Spreehas_secure_token :tokenvalidates :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: :createscope :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.currentend@@ -22,6 +30,7 @@ module Spreetransaction donew_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 Spreenew_tokenend- # 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.rbindex 83ff487aa4..6992d0efb8 100644--- a/spree/core/app/models/spree/role.rb+++ b/spree/core/app/models/spree/role.rb@@ -2,7 +2,10 @@ module Spreeclass Role < Spree.base_classhas_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: :destroyhas_many :users, through: :role_users, source: :user, source_type: Spree.customer_class.to_shas_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 = falseendend- # 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_symend# Whether the dashboard may edit or delete this role. False for the admin@@ -91,6 +137,27 @@ module Spreeerrors.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_immutableerrors.add(:name, Spree.t(:role_immutable)) unless mutable_was_and_not_admin?end@@ -103,10 +170,12 @@ module Spreeerrors.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?enddef ensure_can_be_deleteddiff --git a/spree/core/app/models/spree/role_user.rb b/spree/core/app/models/spree/role_user.rbindex 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_idbelongs_to :user, polymorphic: true- belongs_to :resource, polymorphic: truebelongs_to :invitation, class_name: 'Spree::Invitation', optional: true, inverse_of: :role_user#@@ -15,40 +15,12 @@ module Spree#validates :role, presence: truevalidates :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: :roleendenddiff --git a/spree/core/app/services/spree/seeds/all.rb b/spree/core/app/services/spree/seeds/all.rbindex 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 dataStoreCreditCategories.callTaxCategories.call@@ -20,6 +17,9 @@ module Spree# store & channelsStores.callChannels.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: theirdiff --git a/spree/core/app/services/spree/seeds/roles.rb b/spree/core/app/services/spree/seeds/roles.rbindex 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 Spreeclass Rolesprepend 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)+ endendendenddiff --git a/spree/core/config/locales/en.yml b/spree/core/config/locales/en.ymlindex 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 invitationinvitations: Invitationsinvited_by: Invited byiso: 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 deletedrole_id: Role IDrole_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 existsroles: Rolesrow: Rowrules: Rulesdiff --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.rbindex 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: trueendenddiff --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.rbnew file mode 100644index 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+enddiff --git a/spree/core/db/migrate/20260815000002_add_resource_to_spree_roles.rb b/spree/core/db/migrate/20260815000002_add_resource_to_spree_roles.rbnew file mode 100644index 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+enddiff --git a/spree/core/lib/spree/core/permission_configuration.rb b/spree/core/lib/spree/core/permission_configuration.rbindex 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 SpreeREAD_PREFIX = 'read_'.freezeWRITE_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]).freezeend# @return [Boolean]@@ -42,6 +53,20 @@ module Spree@writeend+ # @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 subjectsArray(@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] = resourceend@@ -135,6 +167,22 @@ module Spreeresources.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 orderdef entriesresources.flat_map do |resource|@@ -229,20 +277,20 @@ module Spree# are lambdas so model classes resolve at activation, not load, time.# rubocop:disable Metrics/MethodLengthdef 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 Spreeregister_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/MethodLengthenddiff --git a/spree/core/lib/spree/core/previews/invitation_preview.rb b/spree/core/lib/spree/core/previews/invitation_preview.rbindex 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::Previewresource: 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_nowdiff --git a/spree/core/lib/spree/testing_support/factories/refresh_token_factory.rb b/spree/core/lib/spree/testing_support/factories/refresh_token_factory.rbindex 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 doassociation :user, factory: :useruser_type { user.class.to_s }expires_at { Spree::RefreshToken.default_expiry.from_now }+ audience { 'store_api' }trait :for_admin doassociation :user, factory: :admin_user+ audience { 'admin_api' }endtrait :expired dodiff --git a/spree/core/lib/spree/testing_support/factories/role_factory.rb b/spree/core/lib/spree/testing_support/factories/role_factory.rbindex 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 dofactory :role, class: Spree::Role dosequence(:name) { |n| "Role #{n}" }+ resource { Spree::Store.default || create(:store) }factory :admin_role doname { '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.ymlindex 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_methodsname: "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.rakeindex 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 dodesc '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.rakedeleted file mode 100644index 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-enddiff --git a/spree/core/spec/lib/spree/core/permission_configuration_spec.rb b/spree/core/spec/lib/spree/core/permission_configuration_spec.rbindex 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 doendend+ 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' doit 'removes the resource and its keys' doconfiguration.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.rbdeleted file mode 100644index 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-enddiff --git a/spree/core/spec/models/spree/ability_spec.rb b/spree/core/spec/models/spree/ability_spec.rbindex 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 docontext 'with a role granting a read key' dobefore 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))endit 'grants read and admin on the resource subjects' do@@ -105,7 +105,7 @@ describe Spree::Ability, type: :model docontext 'with a role granting a write key' dobefore 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))endit 'grants manage on the resource subjects' do@@ -120,8 +120,8 @@ describe Spree::Ability, type: :model docontext 'with multiple roles' dobefore 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))endit 'combines keys from all roles' do@@ -133,7 +133,7 @@ describe Spree::Ability, type: :model docontext 'with a role granting no keys' dobefore do- admin.role_users.create!(role: create(:role, name: 'empty'), resource: store)+ admin.role_users.create!(role: create(:role, name: 'empty', resource: store))endit 'grants only the staff baseline' do@@ -147,7 +147,7 @@ describe Spree::Ability, type: :model docontext 'with the admin role' dobefore do- admin.role_users.create!(role: Spree::Role.default_admin_role, resource: store)+ admin.role_users.create!(role: Spree::Role.default_admin_role(store))endit 'grants everything and reports the full catalog' do@@ -158,8 +158,8 @@ describe Spree::Ability, type: :model docontext 'with overlapping keys across roles' dobefore 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))endit 'deduplicates into one expanded key set' do@@ -172,8 +172,8 @@ describe Spree::Ability, type: :model dolet(: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))endit 'activates only the current store assignments' do@@ -191,12 +191,73 @@ describe Spree::Ability, type: :model doendend+ # 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' dolet(: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))endit 'does not leak admin authority into the limited store' do@@ -209,32 +270,40 @@ describe Spree::Ability, type: :model doendend- 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' dolet(: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' doexpect(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])endend- # 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' dolet(: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' doadmin.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 doendit '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, :allexpect(staff_ability.permission_keys).to eq([])@@ -254,7 +323,7 @@ describe Spree::Ability, type: :model dobefore dorole = 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)endit 'activates the known keys and drops the rest' do@@ -287,8 +356,7 @@ describe Spree::Ability, type: :model doit 'resolves staff roles for persisted customers' domanager = 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 dolet(: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))endit "grants authority on the role assignment's store" dodiff --git a/spree/core/spec/models/spree/concerns/user_management_spec.rb b/spree/core/spec/models/spree/concerns/user_management_spec.rbindex 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 dolet(: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' dodescribe '#add_user' do@@ -14,6 +15,12 @@ describe Spree::UserManagement doexpect(admin_user.has_spree_role?('admin', test_store)).to be trueend+ 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' dotest_store.add_user(admin_user, role)@@ -37,20 +44,27 @@ describe Spree::UserManagement doenddescribe '#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))endendenddescribe '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 :resourceend+ # 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' doassociation = test_store.class.reflect_on_association(:users)expect(association.macro).to eq :has_manydiff --git a/spree/core/spec/models/spree/concerns/user_roles_spec.rb b/spree/core/spec/models/spree/concerns/user_roles_spec.rbindex 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 docontext 'when a resource parameter is provided' dolet(: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 docontext 'when a resource parameter is provided' dolet(: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 docontext 'when a resource parameter is provided' dolet(: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' dobefore { test_user.add_role('test', resource) }@@ -87,8 +93,11 @@ describe Spree::UserRoles docontext 'when a resource parameter is provided' dolet(: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 falsediff --git a/spree/core/spec/models/spree/invitation_spec.rb b/spree/core/spec/models/spree/invitation_spec.rbindex 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 doit 'sets defaults on initialization' doinvitation = 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' docreate(: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.rbindex 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 doendit '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_presentexpect(token.token.length).to be >= 24end++ 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)+ endenddescribe '.create_for' doit '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_persistedexpect(token.user).to eq(user)@@ -35,7 +51,7 @@ RSpec.describe Spree::RefreshToken, type: :model doendit '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 doendit '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 dodescribe '#expired?' doit '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 falseendit '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 trueendenddescribe '#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' dooriginal_id = original_token.id@@ -101,9 +117,9 @@ RSpec.describe Spree::RefreshToken, type: :model doenddescribe '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)tend@@ -125,8 +141,8 @@ RSpec.describe Spree::RefreshToken, type: :model dodescribe '.revoke_all_for' doit '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 doit 'does not delete tokens for other users' doother_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 dodescribe '.cleanup_expired!' doit '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 dodescribe 'prefixed_id' doit '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_')endenddiff --git a/spree/core/spec/models/spree/role_spec.rb b/spree/core/spec/models/spree/role_spec.rbindex 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 dolet(: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' dobefore do@@ -16,11 +19,35 @@ describe Spree::Role dodescribe '.default_admin_role' doit '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 falseend++ # 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)+ endenddescribe '#permissions' do@@ -49,6 +76,75 @@ describe Spree::Role doendend+ 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' dolet(:admin_role) { Spree::Role.default_admin_role }@@ -69,6 +165,16 @@ describe Spree::Role doexpect(admin_role).not_to be_validend+ # 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' doexpect(admin_role.destroy).to be falseexpect(admin_role.errors[:base]).to be_presentdiff --git a/spree/core/spec/models/spree/role_user_spec.rb b/spree/core/spec/models/spree/role_user_spec.rbindex 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 doendend- 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_validendenddiff --git a/spree/core/spec/services/spree/seeds/admin_user_spec.rb b/spree/core/spec/services/spree/seeds/admin_user_spec.rbindex 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 doexpect { 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 existendit 'does nothing when an admin already exists' do