plutonium 0.37.0 → 0.38.0

data/lib/plutonium/core/controller.rb

@@ -5,12 +5,26 @@ module Plutonium
       include Plutonium::Core::Controllers::Bootable
       include Plutonium::Core::Controllers::EntityScoping
       include Plutonium::Core::Controllers::Authorizable
+      include Plutonium::Core::Controllers::AssociationResolver
 
       included do
         add_flash_types :success, :warning, :error
 
         protect_from_forgery with: :null_session, if: -> { request.headers["Authorization"].present? }
 
+        rescue_from ::ActionPolicy::Unauthorized do |exception|
+          respond_to do |format|
+            format.any(:html, :turbo_stream) do
+              raise exception
+            end
+            format.any do
+              @errors = ActiveModel::Errors.new(exception.policy.record)
+              @errors.add(:base, :unauthorized, message: exception.result.message)
+              render "errors", status: :forbidden
+            end
+          end
+        end
+
         before_action do
           next unless defined?(ActiveStorage)
 
@@ -60,33 +74,155 @@ module Plutonium
       # `resource_url_args_for @post`                  => `entity_user_post_*`
       # `resource_url_args_for @post, action: :edit`   => `edit_entity_user_post_*`
       #
-      # @param [Class, ApplicationRecord] *args arguments you would normally pass to `url_for`
+      # - with explicit association (for multiple associations to same class)
+      #
+      # `resource_url_args_for :authored_posts, parent: @user` => `entity_user_authored_posts_*`
+      #
+      # @param [Class, ApplicationRecord, Symbol] *args arguments you would normally pass to `url_for`.
+      #   When parent is specified, can be a Symbol to explicitly name the association.
       # @param [Symbol] action optional action to invoke, e.g., :new, :edit
       # @param [ApplicationRecord] parent the parent record for nested routes, if any
+      # @param [Symbol] association explicit association name (when multiple associations to same class)
       # @param [Hash] kwargs additional keyword arguments to pass to `url_for`
       #
       # @return [Hash] args to pass to `url_for`
       #
-      def resource_url_args_for(*args, action: nil, parent: nil, **kwargs)
+      def resource_url_args_for(*args, action: nil, parent: nil, association: nil, package: nil, **kwargs)
+        target_package = package || current_package
+
+        # For nested resources, use named route helpers to avoid Rails param recall ambiguity
+        if parent.present?
+          assoc_name = if args.first.is_a?(Symbol)
+            args.first
+          else
+            association || resolve_association(args.first, parent)
+          end
+
+          nested_route_key = "#{parent.class.model_name.plural}/#{assoc_name}"
+          route_config = current_engine.routes.resource_route_config_for(nested_route_key)[0]
+
+          if route_config
+            return build_nested_resource_url_args(
+              args.first,
+              parent: parent,
+              association_name: assoc_name,
+              route_config: route_config,
+              action: action,
+              **kwargs
+            )
+          end
+        end
+
+        # Top-level resource: build controller/action hash for url_for
+        build_top_level_resource_url_args(*args, action: action, parent: parent, association: association, package: target_package, **kwargs)
+      end
+
+      def resource_url_for(*args, package: nil, **kwargs)
+        url_args = resource_url_args_for(*args, package: package, **kwargs)
+        url_helpers = route_url_helpers_for(package)
+
+        if url_args[:_named_route]
+          url_helpers.send(url_args[:_named_route], *url_args[:_args], **url_args[:_options])
+        else
+          url_helpers.url_for(url_args)
+        end
+      end
+
+      def route_url_helpers_for(package = nil)
+        pkg = package || current_package
+        pkg.present? ? send(pkg.name.underscore.to_sym) : current_engine.routes.url_helpers
+      end
+
+      private
+
+      def build_nested_resource_url_args(element, parent:, association_name:, route_config:, action: nil, **kwargs)
+        prefix = Plutonium::Routing::NESTED_ROUTE_PREFIX
+        is_singular = route_config[:route_type] == :resource
+
+        # For singular resources (has_one), Class/Symbol/nil without action means "no record exists" -> default to :new
+        if is_singular && (element.is_a?(Class) || element.is_a?(Symbol) || element.nil?) && action.nil?
+          action = :new
+        end
+
+        # Build the named helper: e.g., "blogging_post_nested_post_metadata_path"
+        parent_singular = parent.model_name.singular
+        nested_resource_name = "#{prefix}#{association_name}"
+
+        # Determine if this is a collection action (no specific record)
+        no_record = element.is_a?(Class) || element.is_a?(Symbol) || element.nil?
+
+        # Determine the helper name based on action and route type
+        # For singular routes (has_one), always use the association name as-is (no singularize)
+        # For plural routes (has_many):
+        #   - :index action uses plural (blogging_post_nested_comments)
+        #   - :new action uses singular (new_blogging_post_nested_comment)
+        #   - member actions (show/edit/destroy) use singular (blogging_post_nested_comment)
+        helper_base = if is_singular
+          "#{parent_singular}_#{nested_resource_name}"
+        elsif action == :index || (no_record && action != :new)
+          "#{parent_singular}_#{nested_resource_name}"
+        else
+          "#{parent_singular}_#{nested_resource_name.to_s.singularize}"
+        end
+
+        helper_suffix = case action
+        when :new then "new_"
+        when :edit then "edit_"
+        else ""
+        end
+
+        helper_name = :"#{helper_suffix}#{helper_base}_path"
+
+        # Build the arguments for the helper
+        helper_args = [parent.to_param]
+        # Include element ID for plural routes (has_many) when we have a record instance
+        unless is_singular || no_record
+          helper_args << element.to_param
+        end
+
+        # Build URL options
+        url_options = kwargs.dup
+        if !url_options.key?(:format) && request.present? && request.format.present? && !request.format.symbol.in?([:html, :turbo_stream])
+          url_options[:format] = request.format.symbol
+        end
+
+        {_named_route: helper_name, _args: helper_args, _options: url_options}
+      end
+
+      def build_top_level_resource_url_args(*args, action: nil, parent: nil, association: nil, package: nil, **kwargs)
         url_args = {**kwargs, action: action}.compact
 
-        controller_chain = [current_package&.to_s].compact
+        controller_chain = [package&.to_s].compact
         [*args].compact.each_with_index do |element, index|
-          if element.is_a?(Class)
+          if element.is_a?(Symbol)
+            raise ArgumentError, "parent is required when using symbol association name" unless parent
+
+            assoc = parent.class.reflect_on_association(element)
+            raise ArgumentError, "Unknown association :#{element} on #{parent.class}" unless assoc
+
+            controller_chain << assoc.klass.to_s.pluralize
+            url_args[:action] ||= :index if index == args.length - 1
+          elsif element.is_a?(Class)
             controller_chain << element.to_s.pluralize
+            url_args[:action] ||= :index if index == args.length - 1 && parent.present?
           else
-            # For STI models, use the base class for routing if the specific class isn't registered
             model_class = element.class
             if model_class.respond_to?(:base_class) && model_class != model_class.base_class
-              # Check if the STI model is registered, if not use base class
               route_configs = current_engine.routes.resource_route_config_for(model_class.model_name.plural)
               model_class = model_class.base_class if route_configs.empty?
             end
 
             controller_chain << model_class.to_s.pluralize
             if index == args.length - 1
-              resource_route_config = current_engine.routes.resource_route_config_for(model_class.model_name.plural)[0]
-              url_args[:id] = element.to_param unless resource_route_config[:route_type] == :resource
+              route_key = if parent.present?
+                assoc_name = association || resolve_association(element, parent)
+                "#{parent.class.model_name.plural}/#{assoc_name}"
+              else
+                model_class.model_name.plural
+              end
+              resource_route_config = current_engine.routes.resource_route_config_for(route_key)[0]
+              is_singular = resource_route_config&.dig(:route_type) == :resource
+              url_args[:id] = element.to_param unless is_singular
               url_args[:action] ||= :show
             else
               url_args[model_class.to_s.underscore.singularize.to_sym] = element.to_param
@@ -100,8 +236,6 @@ module Plutonium
           url_args[scoped_entity_param_key] = current_scoped_entity
         end
 
-        # Preserve the request format unless explicitly specified
-        # Don't preserve turbo_stream as it's for streaming updates, not page navigation
         if !url_args.key?(:format) && request.present? && request.format.present? && !request.format.symbol.in?([:html, :turbo_stream])
           url_args[:format] = request.format.symbol
         end
@@ -109,15 +243,6 @@ module Plutonium
         url_args
       end
 
-      def resource_url_for(...)
-        args = resource_url_args_for(...)
-        if current_package.present?
-          send(current_package.name.underscore.to_sym).url_for(args)
-        else
-          url_for(args)
-        end
-      end
-
       def root_path(*)
         return send(:"#{scoped_entity_param_key}_root_path", *) if scoped_to_entity? && scoped_entity_strategy == :path
 

data/lib/plutonium/core/controllers/association_resolver.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Core
+    module Controllers
+      # Resolves target classes/instances to association names on a parent model.
+      #
+      # This module handles the mapping between resource classes and their association
+      # names when generating nested resource URLs. It supports:
+      # - Explicit association names (symbols)
+      # - Class-based resolution with namespace fallback
+      # - Instance-based resolution
+      #
+      # @example Explicit association
+      #   resolve_association(:comments, @post) # => :comments
+      #
+      # @example Class-based resolution
+      #   resolve_association(Comment, @post) # => :comments
+      #
+      # @example Namespaced class resolution
+      #   resolve_association(Blogging::Comment, @post) # => :comments (tries :blogging_comments first)
+      #
+      module AssociationResolver
+        class AmbiguousAssociationError < StandardError; end
+
+        # Resolves a target to an association name on the parent
+        #
+        # @param target [Class, Object, Symbol] The target class, instance, or association name
+        # @param parent [Object] The parent instance
+        # @return [Symbol] The resolved association name
+        # @raise [ArgumentError] If no matching association is found
+        # @raise [AmbiguousAssociationError] If multiple associations match
+        def resolve_association(target, parent)
+          return target if target.is_a?(Symbol)
+
+          target_class = target.is_a?(Class) ? target : target.class
+          candidates = association_candidates_for(target_class)
+
+          matching = candidates.filter_map do |assoc_name|
+            assoc = parent.class.reflect_on_association(assoc_name)
+            assoc_name if assoc && assoc.klass >= target_class
+          end
+
+          case matching.size
+          when 0
+            raise ArgumentError,
+              "No association found for #{target_class} on #{parent.class}. " \
+              "Tried: #{candidates.join(", ")}"
+          when 1
+            matching.first
+          else
+            raise AmbiguousAssociationError,
+              "Multiple associations to #{target_class} on #{parent.class}: #{matching.join(", ")}. " \
+              "Please specify explicitly using a symbol: resource_url_for(:association_name, parent: ...)"
+          end
+        end
+
+        private
+
+        # Returns candidate association names for a class
+        #
+        # For Blogging::Comment, returns [:blogging_comments, :comments]
+        # For Comment, returns [:comments]
+        #
+        # @param klass [Class] The target class
+        # @return [Array<Symbol>] Candidate association names in priority order
+        def association_candidates_for(klass)
+          candidates = []
+
+          # Full namespaced name: Blogging::Comment => :blogging_comments
+          full_name = klass.model_name.plural.to_sym
+          candidates << full_name
+
+          # Demodulized name: Blogging::Comment => :comments
+          demodulized = klass.name.demodulize
+          if demodulized != klass.name
+            short_name = demodulized.underscore.pluralize.to_sym
+            candidates << short_name unless candidates.include?(short_name)
+          end
+
+          candidates
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/helpers/display_helper.rb

@@ -14,6 +14,18 @@ module Plutonium
         resource_name resource_class, 2
       end
 
+      # Returns a human-readable name for a nested collection using the association name.
+      # Falls back to resource_name_plural if not in a nested context.
+      # Uses I18n via human_attribute_name for proper localization.
+      # e.g., "Authored Comments" for has_many :authored_comments
+      def nestable_resource_name_plural(resource_class)
+        if current_parent && current_nested_association
+          current_parent.class.human_attribute_name(current_nested_association).titleize
+        else
+          resource_name_plural(resource_class)
+        end
+      end
+
       def display_field(value:, helper: nil, **options)
         return "-" unless value.present?
 

data/lib/plutonium/query/filters/association.rb

@@ -12,10 +12,15 @@ module Plutonium
       # @example With multiple selection
       #   filter :tags, with: :association, class_name: Tag, multiple: true
       #
+      # @example With custom scope
+      #   filter :user, with: :association, class_name: User, scope: ->(s) { s.active }
+      #
       class Association < Filter
-        def initialize(class_name: nil, multiple: false, **)
+        def initialize(class_name: nil, resource_class: nil, scope: nil, multiple: false, **)
           super(**)
-          @association_class = class_name
+          @class_name = class_name
+          @resource_class = resource_class
+          @scope_proc = scope
           @multiple = multiple
         end
 
@@ -41,7 +46,24 @@ module Plutonium
         private
 
         def association_class
-          @association_class || key.to_s.classify.constantize
+          @association_class ||= resolve_class_name || detect_class_from_reflection || infer_class_from_key
+        end
+
+        def resolve_class_name
+          return nil unless @class_name
+
+          @class_name.is_a?(String) ? @class_name.constantize : @class_name
+        end
+
+        def detect_class_from_reflection
+          return nil unless @resource_class
+
+          reflection = @resource_class.reflect_on_association(key)
+          reflection&.klass
+        end
+
+        def infer_class_from_key
+          key.to_s.classify.constantize
         end
       end
     end

data/lib/plutonium/resource/controller.rb

@@ -1,5 +1,6 @@
 require "action_controller"
 require "pagy"
+require_relative "../routing/mapper_extensions"
 
 module Plutonium
   module Resource
@@ -19,7 +20,7 @@ module Plutonium
         # https://github.com/ddnexus/pagy/blob/master/docs/extras/headers.md#headers
         after_action { pagy_headers_merge(@pagy) if @pagy }
 
-        helper_method :current_parent, :resource_record!, :resource_record?, :resource_param_key, :resource_class
+        helper_method :current_parent, :current_nested_association, :resource_record!, :resource_record?, :resource_param_key, :resource_class
 
         # Use class_attribute for proper inheritance
         class_attribute :_resource_class, instance_accessor: false
@@ -39,9 +40,22 @@ module Plutonium
         def resource_class
           return _resource_class if _resource_class
 
+          base_name = name.to_s.gsub(/^#{current_package}::/, "").gsub(/Controller$/, "")
+          singularized_name = base_name.singularize.camelize
+
           # Use singularize + camelize to respect custom inflections
-          name.to_s.gsub(/^#{current_package}::/, "").gsub(/Controller$/, "").singularize.camelize.constantize
+          singularized_name.constantize
         rescue NameError
+          # Check if inflection is the issue (e.g., PostMetadata -> PostMetadatum)
+          if base_name != singularized_name && base_name.camelize.safe_constantize
+            raise NameError, <<~MSG.squish
+              Failed to determine the resource class for #{name}.
+              Rails singularized "#{base_name}" to "#{singularized_name}", but "#{base_name.camelize}" exists.
+              Add an inflection rule to config/initializers/inflections.rb.
+              See: https://radioactive-labs.github.io/plutonium-core/guides/troubleshooting
+            MSG
+          end
+
           raise NameError, "Failed to determine the resource class. Please call `controller_for(MyResource)` in #{name}."
         end
         # memoize_unless_reloading :resource_class
@@ -49,13 +63,29 @@ module Plutonium
 
       private
 
+      # Override to prepend parent label for nested resources in the browser tab title.
+      # e.g., "John Doe › Authored Comments"
+      def set_page_title(page_title)
+        @page_title = if current_parent
+          "#{current_parent.to_label} › #{page_title}"
+        else
+          page_title
+        end
+      end
+
       def resource_class
-        self.class.resource_class
+        if current_parent
+          # Nested route: resource_class must come from route config
+          current_resource_route_config&.dig(:resource_class) or
+            raise "No resource_class found in route config for nested route"
+        else
+          self.class.resource_class
+        end
       end
 
       def resource_record_relation
         @resource_record_relation ||= begin
-          resource_route_config = current_engine.routes.resource_route_config_for(resource_class.model_name.plural)[0]
+          resource_route_config = current_resource_route_config
           if resource_route_config[:route_type] == :resource
             current_authorized_scope
           elsif params[:id]
@@ -66,6 +96,33 @@ module Plutonium
         end
       end
 
+      def current_resource_route_config
+        @current_resource_route_config ||= if current_parent
+          current_engine.routes.resource_route_config_lookup["#{current_parent.class.model_name.plural}/#{current_nested_association}"]
+        else
+          current_engine.routes.resource_route_config_for(resource_class.model_name.plural)[0]
+        end
+      end
+
+      # Extracts the association name from the current nested route
+      # e.g., for route /posts/:post_id/nested_comments, returns :comments
+      # @return [Symbol, nil] The association name
+      def current_nested_association
+        return unless parent_route_param
+
+        # Extract from request path: find the nested_* segment after the parent param
+        # e.g., /posts/123/nested_comments/456 => "comments"
+        # Note: Strip format extension (.json, .xml, etc.) from the segment
+        prefix = Plutonium::Routing::NESTED_ROUTE_PREFIX
+        path_segments = request.path.split("/")
+        nested_segment = path_segments.find { |seg| seg.start_with?(prefix) }
+        return unless nested_segment
+
+        # Remove prefix and any format extension (e.g., "nested_versions.json" -> "versions")
+        association_name = nested_segment.delete_prefix(prefix).sub(/\.\w+\z/, "")
+        association_name.to_sym
+      end
+
       def resource_record!
         @resource_record ||= resource_record_relation.first!
       end
@@ -77,7 +134,9 @@ module Plutonium
       # Returns the submitted resource parameters
       # @return [Hash] The submitted resource parameters
       def submitted_resource_params
-        @submitted_resource_params ||= build_form(resource_class.new).extract_input(params, view_context:)[resource_param_key.to_sym].compact
+        # Use existing record (cloned) for context during param extraction, or new instance for create
+        extraction_record = resource_record?&.dup || resource_class.new
+        @submitted_resource_params ||= build_form(extraction_record).extract_input(params, view_context:)[resource_param_key.to_sym].compact
       end
 
       # Returns the resource parameters, including scoped and parent parameters
@@ -93,9 +152,9 @@ module Plutonium
       end
 
       # Returns the resource parameter key
-      # @return [Symbol] The resource parameter key
+      # @return [Symbol] The resource parameter key (for form params)
       def resource_param_key
-        resource_class.model_name.singular_route_key
+        resource_class.model_name.param_key
       end
 
       # Creates a resource context
@@ -146,12 +205,30 @@ module Plutonium
         @parent_route_param ||= request.path_parameters.keys.reverse.find { |key| /_id$/.match? key }
       end
 
-      # Returns the parent input parameter
+      # Returns the parent input parameter (the belongs_to association name on the child)
+      # Finds the belongs_to association on the child that matches the parent's foreign key
       # @return [Symbol, nil] The parent input parameter
       def parent_input_param
         return unless current_parent
 
-        resource_class.reflect_on_all_associations(:belongs_to).find { |assoc| assoc.klass.name == current_parent.class.name }&.name&.to_sym
+        unless current_nested_association
+          raise "parent exists but current_nested_association is nil - routing misconfiguration"
+        end
+
+        parent_assoc = current_parent.class.reflect_on_association(current_nested_association)
+        unless parent_assoc
+          raise "#{current_parent.class} does not have association :#{current_nested_association}"
+        end
+
+        # Try inverse_of first (if explicitly set)
+        return parent_assoc.inverse_of.name.to_sym if parent_assoc.inverse_of
+
+        # Fall back to finding belongs_to by foreign key
+        foreign_key = parent_assoc.foreign_key.to_s
+        child_assoc = resource_class.reflect_on_all_associations(:belongs_to).find do |assoc|
+          assoc.foreign_key.to_s == foreign_key && assoc.klass == current_parent.class
+        end
+        child_assoc&.name&.to_sym
       end
 
       # Ensures the method is a GET request
@@ -195,6 +272,10 @@ module Plutonium
       # @return [Array] The URL arguments
       def resource_url_args_for(*, **kwargs)
         kwargs[:parent] = current_parent unless kwargs.key?(:parent)
+        # Pass the current association when in a nested context
+        if current_parent && !kwargs.key?(:association) && current_nested_association
+          kwargs[:association] = current_nested_association
+        end
         super
       end
     end

data/lib/plutonium/resource/controllers/authorizable.rb

@@ -108,11 +108,16 @@ module Plutonium
           authorized_scope(resource_class.all, context: current_policy_context)
         end
 
-        # Sets the policy context scope value to the current parent if available
+        # Returns the policy context for the current resource
+        # Separates parent scoping (nested routes) from entity scoping (multi-tenancy)
         #
-        # @return [Hash] default context for the current resource's policy
+        # @return [Hash] context containing parent, parent_association, and entity_scope
         def current_policy_context
-          {entity_scope: current_parent || entity_scope_for_authorize}
+          {
+            parent: current_parent,
+            parent_association: current_nested_association,
+            entity_scope: entity_scope_for_authorize
+          }
         end
 
         # Authorizes the current action for the given record of the current resource
@@ -130,7 +135,15 @@ module Plutonium
         #
         # @return [Array<Symbol>] the list of permitted attributes for the current action
         def permitted_attributes
-          @permitted_attributes ||= current_policy.send_with_report(:"permitted_attributes_for_#{action_name}").freeze
+          @permitted_attributes ||= permitted_attributes_for(action_name)
+        end
+
+        # Returns the list of permitted attributes for a specific action on the current resource
+        #
+        # @param action [String, Symbol] the action to get permitted attributes for
+        # @return [Array<Symbol>] the list of permitted attributes for the action
+        def permitted_attributes_for(action)
+          current_policy.send_with_report(:"permitted_attributes_for_#{action}").freeze
         end
 
         # Returns the list of permitted associations for the current resource

data/lib/plutonium/resource/controllers/crud_actions.rb

@@ -12,7 +12,7 @@ module Plutonium
         # GET /resources(.{format})
         def index
           authorize_current! resource_class
-          set_page_title resource_class.model_name.human.pluralize.titleize
+          set_page_title helpers.nestable_resource_name_plural(resource_class)
 
           setup_index_action!
 
@@ -53,7 +53,7 @@ module Plutonium
 
           respond_to do |format|
             if params[:pre_submit]
-              format.turbo_stream { render turbo_stream: turbo_stream.replace("resource-form", view_context.render(build_form)) }
+              format.turbo_stream { render turbo_stream: turbo_stream.replace("resource-form", view_context.render(build_form(action: :new))) }
               format.html { render :new, status: :unprocessable_content }
             elsif resource_record!.save
               format.turbo_stream do
@@ -71,7 +71,8 @@ module Plutonium
                   location: redirect_url_after_submit
               end
             else
-              format.any(:html, :turbo_stream) { render :new, formats: [:html], status: :unprocessable_content }
+              format.turbo_stream { render turbo_stream: turbo_stream.replace("resource-form", view_context.render(build_form(action: :new))), status: :unprocessable_content }
+              format.html { render :new, status: :unprocessable_content }
               format.any do
                 @errors = resource_record!.errors
                 render "errors", status: :unprocessable_content
@@ -99,7 +100,7 @@ module Plutonium
 
           respond_to do |format|
             if params[:pre_submit]
-              format.turbo_stream { render turbo_stream: turbo_stream.replace("resource-form", view_context.render(build_form)) }
+              format.turbo_stream { render turbo_stream: turbo_stream.replace("resource-form", view_context.render(build_form(action: :edit))) }
               format.html { render :edit, status: :unprocessable_content }
             elsif resource_record!.save
               format.turbo_stream do
@@ -115,7 +116,8 @@ module Plutonium
                 render :show, status: :ok, location: redirect_url_after_submit
               end
             else
-              format.any(:html, :turbo_stream) { render :edit, formats: [:html], status: :unprocessable_content }
+              format.turbo_stream { render turbo_stream: turbo_stream.replace("resource-form", view_context.render(build_form(action: :edit))), status: :unprocessable_content }
+              format.html { render :edit, status: :unprocessable_content }
               format.any do
                 @errors = resource_record!.errors
                 render "errors", status: :unprocessable_content

data/lib/plutonium/resource/controllers/interactive_actions.rb

@@ -62,6 +62,9 @@ module Plutonium
                 format.html do
                   redirect_to return_url, status: :see_other
                 end
+                format.any do
+                  render :show, status: :ok, location: return_url
+                end
               else
                 format.any(:html, :turbo_stream) do
                   render :interactive_record_action, formats: [:html], status: :unprocessable_content
@@ -117,6 +120,9 @@ module Plutonium
                 format.html do
                   redirect_to return_url, status: :see_other
                 end
+                format.any do
+                  head :no_content, location: return_url
+                end
               else
                 format.any(:html, :turbo_stream) do
                   render :interactive_resource_action, formats: [:html], status: :unprocessable_content
@@ -166,6 +172,9 @@ module Plutonium
                 format.html do
                   redirect_to return_url, status: :see_other
                 end
+                format.any do
+                  head :no_content, location: return_url
+                end
               else
                 format.any(:html, :turbo_stream) do
                   render :interactive_bulk_action, formats: [:html], status: :unprocessable_content