spree_api 6.0.0.beta1 → 6.0.0.beta3

data/app/controllers/spree/api/v3/seller/me_controller.rb

@@ -20,11 +20,32 @@ module Spree
             render json: me_response
           end
 
+          # Self-service update of the signed-in person's own account — the
+          # name and photo their team sees, and the panel's language. It
+          # operates on `current_user` directly, so it needs no per-record
+          # authorization, and no seller role either: this is theirs whichever
+          # seller they are acting for.
+          #
+          # Distinct from PATCH /profile, which writes the seller business.
+          # `avatar` accepts an ActiveStorage direct-upload signed id to set
+          # the photo, or `null` to remove it.
+          def update
+            if current_user.update(permitted_params)
+              render json: me_response
+            else
+              render_validation_error(current_user.errors)
+            end
+          end
+
           private
 
+          def permitted_params
+            params.permit(:selected_locale, :first_name, :last_name, :avatar)
+          end
+
           def me_response
             {
-              user: Spree.api.seller_team_member_serializer.new(current_user, params: serializer_params).to_h,
+              user: Spree.api.seller_account_serializer.new(current_user, params: serializer_params).to_h,
               sellers: serialized_sellers,
               # Both shapes, exactly as the admin `/me`: the panel's `<Can>`
               # reads CanCanCan rules, the key gate reads keys. Sending only
@@ -44,7 +65,9 @@ module Spree
           # Empty until a seller is named: capability is per seller, so there is
           # no meaningful answer spanning all of them. A bare ability (no
           # resource) serializes to nothing rather than raising, so the panel
-          # can call `/me` before choosing a seller.
+          # can call `/me` before choosing a seller. Deliberately the core
+          # class, not `Spree.ability_class`: a custom ability may add rules
+          # after `super`, and those must not leak into the no-seller answer.
           def seller_ability
             return Spree::Ability.new(nil) if current_seller.nil?
 

data/app/controllers/spree/api/v3/seller/orders_controller.rb

@@ -43,7 +43,7 @@ module Spree
             with_order_lock do
               result = Spree.order_cancel_workflow.call(
                 order: @resource,
-                canceler: try_spree_current_user,
+                canceler: current_actor,
                 reason: cancel_reason,
                 note: params[:cancel_note].presence,
                 refund_payments: params[:refund_payments].to_b,
@@ -77,7 +77,11 @@ module Spree
             # each lay their fields over the same snapshot, and the later one
             # would undo the earlier one's lines.
             with_order_lock do
-              if @resource.update(address_params)
+              addresses = corrected_addresses
+              invalid = addresses.values.find(&:invalid?)
+              next render_validation_error(invalid.errors) if invalid
+
+              if @resource.update(addresses)
                 render json: serialize_resource(@resource.reload)
               else
                 render_validation_error(@resource.errors)
@@ -115,9 +119,10 @@ module Spree
           # Either address, as a correction rather than a replacement: the
           # sent fields are laid over what the order already holds, so a
           # request naming one line does not blank out the country and
-          # postcode beside it. The nested writer builds a fresh address row
-          # either way, which is what keeps a shared customer address book
-          # entry from being rewritten by an order-level fix.
+          # postcode beside it. Written as a fresh ownerless snapshot straight
+          # onto the order — never through the buyer's nested writer, which
+          # files the address in their book and makes it their default for
+          # every later checkout on the marketplace.
           def sent_addresses
             @sent_addresses ||= params.permit(
               shipping_address: address_permitted_keys,
@@ -125,32 +130,22 @@ module Spree
             ).slice(:shipping_address, :billing_address).reject { |_key, value| value.blank? }
           end
 
-          def address_params
-            permitted = sent_addresses
-
-            {}.tap do |attributes|
-              if permitted[:shipping_address].present?
-                attributes[:ship_address_attributes] =
-                  merged_address(@resource.ship_address, permitted[:shipping_address])
+          def corrected_addresses
+            {}.tap do |addresses|
+              if sent_addresses[:shipping_address].present?
+                addresses[:ship_address] = corrected_address(@resource.ship_address, sent_addresses[:shipping_address])
               end
 
-              if permitted[:billing_address].present?
-                attributes[:bill_address_attributes] =
-                  merged_address(@resource.bill_address, permitted[:billing_address])
+              if sent_addresses[:billing_address].present?
+                addresses[:bill_address] = corrected_address(@resource.bill_address, sent_addresses[:billing_address])
               end
             end
           end
 
-          def merged_address(address, sent)
-            current = address ? address.attributes.slice(*address_attribute_names) : {}
-            current.merge(sent.to_h)
-          end
-
-          # The permitted keys that are real columns; the rest are the writer
-          # aliases a client may send, which have no value to carry over.
-          def address_attribute_names
-            @address_attribute_names ||=
-              address_permitted_keys.map(&:to_s) & Spree::Address.column_names
+          def corrected_address(address, sent)
+            # No label: an address-book label means nothing on an order's copy,
+            # and labels are unique per owner, which an ownerless copy lacks.
+            (address&.snapshot || Spree::Address.new).tap { |copy| copy.assign_attributes(sent.to_h.except('label', :label)) }
           end
 
           def address_permitted_keys

data/app/controllers/spree/api/v3/seller/password_resets_controller.rb

@@ -128,7 +128,7 @@ module Spree
           def auth_response(user)
             {
               token: generate_jwt(user, audience: Spree::Api::V3::JwtAuthentication::JWT_AUDIENCE_SELLER),
-              user: Spree.api.seller_team_member_serializer.new(
+              user: Spree.api.seller_account_serializer.new(
                 user, params: { store: seller_store(user) }
               ).to_h,
               sellers: serialized_sellers(user)

data/app/controllers/spree/api/v3/seller/resource_controller.rb

@@ -18,6 +18,10 @@ module Spree
             authenticate_seller!
           end
 
+          def ransack_auth_object
+            :seller
+          end
+
           # Every collection is rooted in the seller's own records.
           #
           # The inherited implementation roots at `for_store(current_store)`,

data/app/controllers/spree/api/v3/store/carts/items_controller.rb

@@ -97,12 +97,15 @@ module Spree
             end
 
             # Extension attributes ride in `options`, which is how AddItem
-            # forwards per-line-item values onto the record.
+            # forwards per-line-item values onto the record. Only those reach
+            # it: anything else in `options` is internal to AddItem (the
+            # fulfillment an admin pins a line to) and not the shopper's to set.
             def item_options
-              keys = Spree::LineItem.additional_permitted_attributes.flat_map { |a| a.is_a?(Hash) ? a.keys : a }
-              extras = permitted_params.to_h.slice(*keys.map(&:to_s)).symbolize_keys
+              keys = Spree::LineItem.additional_permitted_attributes.flat_map { |a| a.is_a?(Hash) ? a.keys : a }.map(&:to_s)
 
-              (permitted_params[:options] || {}).to_h.symbolize_keys.merge(extras)
+              (permitted_params[:options] || {}).to_h.slice(*keys).
+                merge(permitted_params.to_h.slice(*keys)).
+                symbolize_keys
             end
 
             def permitted_params

data/app/controllers/spree/api/v3/store/carts/payment_sessions_controller.rb

@@ -13,7 +13,16 @@ module Spree
             # POST /api/v3/store/carts/:cart_id/payment_sessions
             def create
               with_order_lock do
-                payment_method = current_store.payment_methods.find_by_prefix_id!(permitted_params[:payment_method_id])
+                payment_method = current_store.payment_methods.active.storefront_visible.
+                                 find_by_prefix_id!(permitted_params[:payment_method_id])
+
+                unless payment_method.available_for_order?(@cart)
+                  return render_error(
+                    code: 'payment_method_unavailable',
+                    message: Spree.t('api.v3.payments.method_unavailable'),
+                    status: :unprocessable_content
+                  )
+                end
 
                 @payment_session = payment_method.create_payment_session(
                   order: @cart,

data/app/controllers/spree/api/v3/store/carts/payments_controller.rb

@@ -11,7 +11,11 @@ module Spree
             # POST /api/v3/store/carts/:cart_id/payments
             # Creates a payment for non-session payment methods (e.g. Check, Cash on Delivery, Bank Transfer)
             def create
-              payment_method = current_store.payment_methods.find_by_prefix_id!(params[:payment_method_id])
+              # The same methods the cart offers: a disabled or staff-only
+              # method (an offline one marks the order paid) must not be
+              # reachable by naming its id.
+              payment_method = current_store.payment_methods.active.storefront_visible.
+                               find_by_prefix_id!(params[:payment_method_id])
 
               if payment_method.session_required?
                 return render_error(

data/app/controllers/spree/api/v3/store/companies/members_controller.rb

@@ -4,26 +4,25 @@ module Spree
       module Store
         module Companies
           # The people with standing over one node, listed and added by its
-          # members. Adding takes an email and does the right thing: a
-          # membership for an existing customer, an invitation otherwise —
-          # the same convergent behavior as the dashboard endpoint. Any member
-          # can invite; restraint is Enterprise's policy layer.
+          # members. Adding takes an email and always sends an invitation,
+          # even to an existing customer: a member typing an address cannot
+          # vouch that it is the person they mean, so the invitee accepts with
+          # the emailed token. The response is the same whether or not the
+          # email has an account. Any member can invite; restraint is
+          # Enterprise's policy layer.
           class MembersController < BaseController
             # POST /api/v3/store/companies/:company_id/members
             def create
               result = Spree.company_add_member_service.call(
                 company: @parent,
                 email: params.require(:customer_email),
-                inviter: current_user
+                inviter: current_user,
+                require_acceptance: true
               )
 
               if result.success?
-                serializer = if result.value.is_a?(Spree::CompanyInvitation)
-                               Spree.api.company_invitation_serializer
-                             else
-                               serializer_class
-                             end
-                render json: serializer.new(result.value, params: serializer_params).to_h, status: :created
+                render json: Spree.api.company_invitation_serializer.new(result.value, params: serializer_params).to_h,
+                       status: :created
               else
                 render_validation_error(result.value.errors)
               end

data/app/controllers/spree/api/v3/store/companies/orders_controller.rb

@@ -20,6 +20,12 @@ module Spree
               current_store.orders.complete.
                 where(company_id: @parent.self_and_descendants.select(:id))
             end
+
+            # These are other members' orders: gift card codes and download
+            # links are the buyer's credentials, not the company's.
+            def serializer_params
+              super.merge(hide_credentials: true)
+            end
           end
         end
       end

data/app/controllers/spree/api/v3/store/products/filters_controller.rb

@@ -40,6 +40,7 @@ module Spree
                 current_store.id,
                 current_currency,
                 current_locale,
+                (hide_prices? ? 'prices_hidden' : nil),
                 category&.cache_key_with_version,
                 collection&.cache_key_with_version,
                 search_query,

data/app/controllers/spree/api/v3/store/products_controller.rb

@@ -5,6 +5,7 @@ module Spree
         class ProductsController < ResourceController
           include Spree::Api::V3::HttpCaching
           include Spree::Api::V3::Store::SearchProviderSupport
+          include Spree::Api::V3::Store::StorefrontProducts
 
           protected
 
@@ -28,19 +29,12 @@ module Spree
             end
           end
 
+          # Catalog narrowing for the buyer: their company's effective
+          # catalogs, their group's, or the channel default — union of
+          # assortments, resolved in one place
+          # (docs/plans/6.0-b2b-companies-and-catalogs.md).
           def scope
-            base = super.available(Time.current, Spree::Current.currency, include_preorderable: true)
-
-            # Catalog narrowing for the buyer: their company's effective
-            # catalogs, their group's, or the channel default — union of
-            # assortments, resolved in one place
-            # (docs/plans/6.0-b2b-companies-and-catalogs.md).
-            Spree.products_for_context_service.call(
-              store: current_store,
-              channel: current_channel,
-              customer: current_user,
-              base: base
-            ).value
+            storefront_products(super)
           end
 
           # these scopes are not automatically picked by ar_lazy_preload gem and we need to explicitly include them

data/app/controllers/spree/api/v3/store/resource_controller.rb

@@ -28,6 +28,10 @@ module Spree
           def authenticate_request!
             authenticate_api_key!
           end
+
+          def ransack_auth_object
+            :store
+          end
         end
       end
     end

data/app/controllers/spree/api/v3/store/wishlist_items_controller.rb

@@ -3,6 +3,8 @@ module Spree
     module V3
       module Store
         class WishlistItemsController < ResourceController
+          include Spree::Api::V3::Store::StorefrontProducts
+
           prepend_before_action :require_authentication!
 
           protected
@@ -29,6 +31,15 @@ module Spree
           def resource_permitted_attributes
             [:variant_id, :quantity]
           end
+
+          # The item renders its variant and product, so the variant must be
+          # one the buyer could find in the listing — not a draft, another
+          # catalog's product, or an id guessed from the sequence.
+          def permitted_params
+            @permitted_params ||= super.tap do |attributes|
+              attributes[:variant_id] = storefront_variants.find_by_prefix_id!(params[:variant_id]).id if params.key?(:variant_id)
+            end
+          end
         end
       end
     end

data/app/controllers/spree/api/v3/webhooks/fulfillments_controller.rb

@@ -15,7 +15,6 @@ module Spree
         # sender's timeout.
         class FulfillmentsController < ActionController::API
           include ActionController::RateLimiting
-          include Spree::Core::ControllerHelpers::Store
 
           # Must render — instance_exec'd in a before_action, where only
           # render/redirect halts the chain.
@@ -31,12 +30,17 @@ module Spree
                      with: RATE_LIMIT_RESPONSE
 
           def create
-            integration = current_store.integrations.active.find_by_prefix_id!(params[:integration_id])
+            # By id alone: providers call back without an API key or store
+            # header, so the request cannot name the store — the record does.
+            # The signature check below, against the record's own secret, is
+            # what authenticates the request.
+            integration = Spree::Integration.active.find_by_prefix_id!(params[:integration_id])
+            Spree::Current.store = integration.store
 
             event = integration.parse_webhook_event(request.raw_post, request.headers)
             return head :ok if event.nil?
 
-            delivery = find_delivery(event[:tracking_code])
+            delivery = find_delivery(integration.store, event[:tracking_code])
             return head :ok if delivery.nil?
 
             Spree.delivery_update_tracking_workflow.call(
@@ -57,7 +61,7 @@ module Spree
           private
 
           # Scoped to the store the verified integration belongs to — a
-          # tracking code can never address another tenant's parcel — and to
+          # tracking code can never address another store's parcel — and to
           # consignments whose parcel was not canceled, so a recycled code
           # cannot reopen an old one. The newest wins when a code was reused.
           # Carriers reuse tracking numbers across years, so a code can match
@@ -67,14 +71,14 @@ module Spree
           # database. The newest survivor wins.
           CANDIDATE_LIMIT = 20
 
-          def find_delivery(tracking_code)
+          def find_delivery(store, tracking_code)
             return if tracking_code.blank?
 
             # Paged rather than capped: a tracking number reused across
             # canceled owners would otherwise fill the window and hide the
             # live delivery behind them, and the webhook would be
             # acknowledged without applying the carrier's update.
-            current_store.deliveries.
+            store.deliveries.
               where(tracking_number: tracking_code).
               order(created_at: :desc, id: :desc).
               includes(:owner).

data/app/controllers/spree/api/v3/webhooks/payments_controller.rb

@@ -4,7 +4,6 @@ module Spree
       module Webhooks
         class PaymentsController < ActionController::API
           include ActionController::RateLimiting
-          include Spree::Core::ControllerHelpers::Store
 
           # Must render — instance_exec'd in a before_action, where only
           # render/redirect halts the chain.
@@ -24,7 +23,12 @@ module Spree
           # Verifies the webhook signature synchronously (returns 401 if invalid),
           # then enqueues async processing and returns 200 immediately.
           def create
-            payment_method = current_store.payment_methods.find_by_prefix_id!(params[:payment_method_id])
+            # By id alone: providers call back without an API key or store
+            # header, so the request cannot name the store — the record does.
+            # The signature check below, against the record's own secret, is
+            # what authenticates the request.
+            payment_method = Spree::PaymentMethod.find_by_prefix_id!(params[:payment_method_id])
+            Spree::Current.store = payment_method.store
 
             # Signature verification must be synchronous — invalid = 401
             result = payment_method.parse_webhook_event(request.raw_post, request.headers)

data/app/controllers/spree/api/v3/webhooks/payouts_controller.rb

@@ -19,7 +19,6 @@ module Spree
         # database writes, well inside any sender's timeout.
         class PayoutsController < ActionController::API
           include ActionController::RateLimiting
-          include Spree::Core::ControllerHelpers::Store
 
           # Must render — instance_exec'd in a before_action, where only
           # render/redirect halts the chain.
@@ -35,7 +34,12 @@ module Spree
                      with: RATE_LIMIT_RESPONSE
 
           def create
-            payment_method = current_store.payment_methods.find_by_prefix_id!(params[:payment_method_id])
+            # By id alone: providers call back without an API key or store
+            # header, so the request cannot name the store — the record does.
+            # The signature check below, against the record's own secret, is
+            # what authenticates the request.
+            payment_method = Spree::PaymentMethod.find_by_prefix_id!(params[:payment_method_id])
+            Spree::Current.store = payment_method.store
             return head :not_found unless payment_method.respond_to?(:handle_payout_webhook)
 
             payment_method.handle_payout_webhook(request.raw_post, request.headers)

data/app/jobs/spree/webhook_delivery_job.rb

@@ -2,11 +2,19 @@
 
 module Spree
   class WebhookDeliveryJob < Spree::BaseJob
+    # Raised when the endpoint answered with anything other than 2xx, timed
+    # out or could not be reached, so the delivery is sent again with backoff.
+    class DeliveryFailed < StandardError; end
+
     queue_as Spree.queues.webhooks
 
-    # Webhook delivery hits external endpoints; broad retry covers network timeouts,
-    # 5xx, DNS failures, etc.
+    # Delivery is retry-safe: each attempt overwrites the outcome on the same
+    # delivery record, and receivers deduplicate on the event id.
     retry_on StandardError, wait: :polynomially_longer, attempts: 5
+    # The outcome of the last attempt is already on the delivery record, so an
+    # exhausted retry is not re-raised into the queue backend.
+    retry_on DeliveryFailed, wait: :polynomially_longer, attempts: 5 do |_job, _error|
+    end
     # Must come after `retry_on StandardError` so DeserializationError lands in discard
     # (ActiveJob handler lookup is reverse-declaration-order).
     discard_on ActiveJob::DeserializationError
@@ -21,9 +29,15 @@ module Spree
       delivery = Spree::WebhookDelivery.find_by(id: delivery_id)
       return if delivery.nil?
 
+      endpoint = delivery.webhook_endpoint
+      return if endpoint.nil?
+      # A retry stops once the endpoint was switched off, by hand or by auto-disable.
+      return if executions > 1 && !endpoint.active?
+
       delivery.payload_secrets = payload_secrets
-      secret_key = delivery.webhook_endpoint.secret_key
-      Spree::Webhooks::DeliverWebhook.call(delivery: delivery, secret_key: secret_key)
+      Spree::Webhooks::DeliverWebhook.call(delivery: delivery, secret_key: endpoint.secret_key)
+
+      raise DeliveryFailed, "Webhook delivery #{delivery.prefixed_id} failed" if delivery.failed?
     end
   end
 end

data/app/serializers/spree/api/v3/admin/actor_serializer.rb

@@ -0,0 +1,28 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # Whoever performed an action — an admin user, an API key, or a class
+        # an extension registered in `Spree.actor_classes`.
+        #
+        # One shape for every kind, so a client renders "cancelled by" the same
+        # way whether a person clicked the button or a warehouse connector
+        # called the endpoint. See docs/plans/6.0-action-actors.md.
+        class ActorSerializer < V3::BaseSerializer
+          typelize type: [:string, enum: Spree::Actor::BUILT_IN_KINDS, enum_type_name: 'ActorKind'],
+                   label: [:string, nullable: true]
+
+          # `admin_user` / `api_key`, never the Ruby class name.
+          attribute :type do |actor|
+            actor.actor_kind
+          end
+
+          # What a timeline shows: a person's name or email, a key's name.
+          attribute :label do |actor|
+            actor.actor_label
+          end
+        end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v3/admin/api_key_serializer.rb

@@ -19,6 +19,8 @@ module Spree
                    revoked_at: [:string, nullable: true],
                    last_used_at: [:string, nullable: true],
                    created_by_email: [:string, nullable: true],
+                   created_by_type: [:string, nullable: true, enum: Spree::Actor::BUILT_IN_KINDS, enum_type_name: 'ActorKind'],
+                   created_by_label: [:string, nullable: true],
                    channel_id: [:string, nullable: true]
 
           attributes :name, :key_type, :token_prefix, :scopes,
@@ -37,8 +39,19 @@ module Spree
             key.plaintext_token
           end
 
+          # A key can be minted by another key, which has no email — so the
+          # address is answered only for the actors that have one, and
+          # `created_by_label` is what a list column should render.
           attribute :created_by_email do |key|
-            key.created_by&.email
+            key.created_by.try(:email)
+          end
+
+          attribute :created_by_type do |key|
+            Spree::Base.polymorphic_api_type(key.created_by_type)
+          end
+
+          attribute :created_by_label do |key|
+            key.created_by.try(:actor_label)
           end
         end
       end

data/app/serializers/spree/api/v3/admin/claim_serializer.rb

@@ -7,13 +7,12 @@ module Spree
         class ClaimSerializer < V3::ClaimSerializer
           typelize memo: [:string, nullable: true],
                    metadata: 'Record<string, unknown>',
-                   created_by_id: [:string, nullable: true]
+                   created_by_id: [:string, nullable: true],
+                   created_by_type: [:string, nullable: true, enum: Spree::Actor::BUILT_IN_KINDS, enum_type_name: 'ActorKind']
 
           attributes :memo, :metadata, created_at: :iso8601, updated_at: :iso8601
 
-          attribute :created_by_id do |claim|
-            claim.created_by&.prefixed_id
-          end
+          actor_attributes :created_by
 
           many :claim_line_items,
                resource: proc { Spree.api.admin_claim_line_item_serializer },

data/app/serializers/spree/api/v3/admin/exchange_serializer.rb

@@ -8,7 +8,8 @@ module Spree
           typelize memo: [:string, nullable: true],
                    metadata: 'Record<string, unknown>',
                    stock_location_id: [:string, nullable: true],
-                   created_by_id: [:string, nullable: true]
+                   created_by_id: [:string, nullable: true],
+                   created_by_type: [:string, nullable: true, enum: Spree::Actor::BUILT_IN_KINDS, enum_type_name: 'ActorKind']
 
           attributes :memo, :metadata, created_at: :iso8601, updated_at: :iso8601
 
@@ -16,9 +17,7 @@ module Spree
             exchange.stock_location&.prefixed_id
           end
 
-          attribute :created_by_id do |exchange|
-            exchange.created_by&.prefixed_id
-          end
+          actor_attributes :created_by
 
           many :exchange_line_items,
                resource: proc { Spree.api.admin_exchange_line_item_serializer },

data/app/serializers/spree/api/v3/admin/gift_card_serializer.rb

@@ -18,6 +18,12 @@ module Spree
 
           attributes created_at: :iso8601, updated_at: :iso8601
 
+          # A bearer credential: in full only to a caller who may read gift
+          # cards, masked when the card rides along on an order.
+          attribute :code do |gift_card|
+            params[:gift_card_codes] ? gift_card.display_code : gift_card.masked_code
+          end
+
           attribute :customer_id do |gift_card|
             gift_card.customer&.prefixed_id
           end

data/app/serializers/spree/api/v3/admin/invitation_acceptance_link_serializer.rb

@@ -0,0 +1,15 @@
+module Spree
+  module Api
+    module V3
+      module Admin
+        # The acceptance link of one staff invitation, served on its own so the
+        # token never travels with the invitation listing.
+        class InvitationAcceptanceLinkSerializer < V3::BaseSerializer
+          typelize acceptance_url: :string
+
+          attributes :acceptance_url
+        end
+      end
+    end
+  end
+end

data/app/serializers/spree/api/v3/admin/invitation_serializer.rb

@@ -13,7 +13,6 @@ module Spree
                    role_name: :string,
                    inviter_email: :string,
                    expires_at: :string,
-                   acceptance_url: :string,
                    invitee_exists: :boolean,
                    store: '{ id: string; name: string }'
 
@@ -34,16 +33,6 @@ module Spree
             invitation.inviter.email
           end
 
-          # Absolute URL when a dashboard origin is configured, otherwise the
-          # path so the SPA can prepend `window.location.origin`.
-          attribute :acceptance_url do |invitation|
-            if Spree::Config[:dashboard_url].present?
-              Rails.application.routes.url_helpers.admin_invitation_acceptance_url(invitation)
-            else
-              "/accept-invitation/#{invitation.prefixed_id}?token=#{invitation.token}"
-            end
-          end
-
           # Drives the SPA's sign-in vs sign-up branch on the acceptance page.
           # Looked up by email so an admin who's already on another store sees
           # the password prompt, not a fresh account form.