plutonium 0.62.2 → 0.63.0

data/lib/plutonium/resource/controller.rb

@@ -12,9 +12,14 @@ module Plutonium
       include Plutonium::Resource::Controllers::Defineable
       include Plutonium::Resource::Controllers::Authorizable
       include Plutonium::Resource::Controllers::Presentable
+      include Plutonium::Resource::Controllers::EagerLoading
       include Plutonium::Resource::Controllers::Queryable
       include Plutonium::Resource::Controllers::CrudActions
       include Plutonium::Resource::Controllers::KanbanActions
+      # After CrudActions on purpose: PositionActions overrides
+      # pagy_request_context / current_page_* so the reposition drop re-renders
+      # the collection for the INDEX page rather than for its own POST path.
+      include Plutonium::Resource::Controllers::PositionActions
       include Plutonium::Resource::Controllers::InteractiveActions
       include Plutonium::Resource::Controllers::WizardActions
       include Plutonium::Resource::Controllers::Typeahead
@@ -24,7 +29,8 @@ module Plutonium
       included do
         after_action { response.headers.merge!(@pagy.headers_hash) if @pagy }
 
-        helper_method :current_parent, :current_nested_association, :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,
+          :singular_resource_context?, :singular_resource_route_for?
 
         # Use class_attribute for proper inheritance
         class_attribute :_resource_class, instance_accessor: false
@@ -101,11 +107,14 @@ module Plutonium
       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
+        # The nested registration when the route says it is nested, and the
+        # top-level one otherwise. Previously rebuilt the nested lookup key from
+        # the parent's class and the association — which meant resolving the
+        # parent first, and reconstructing a string the router was already
+        # carrying.
+        @current_resource_route_config ||=
+          current_nested_route_config ||
           current_engine.routes.resource_route_config_for(resource_class.model_name.plural)[0]
-        end
       end
 
       # Returns true if current resource is registered as a singular route
@@ -115,23 +124,22 @@ module Plutonium
         current_resource_route_config&.[](:route_type) == :resource
       end
 
-      # Extracts the association name from the current nested route
-      # e.g., for route /posts/:post_id/nested_comments, returns :comments
+      # The same question asked about another resource — a breadcrumb needs to
+      # know whether the parent it is linking to has an index before it builds a
+      # collection URL for one.
+      # @param resource_class [Class]
+      # @return [Boolean]
+      def singular_resource_route_for?(resource_class)
+        current_engine.routes.singular_resource_route?(resource_class.model_name.plural)
+      end
+
+      # The association this request is nested through, as declared by the
+      # route. Previously scraped out of the request path by looking for a
+      # "nested_" segment, which meant stripping format extensions and could
+      # not survive a parent that contributes no id parameter.
       # @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
+        current_nested_route_config&.[](:association_name)
       end
 
       def resource_record!
@@ -185,9 +193,8 @@ module Plutonium
       # `:attachment`). Excluded from the extraction-record pre-assignment so a
       # single-read Rack upload isn't consumed before create/update reads it.
       def attachment_input_keys
-        file_types = Plutonium::UI::Form::Base::Builder::FILE_INPUT_TYPES
         current_definition.defined_inputs.filter_map { |name, config|
-          name.to_s if file_types.include?(config.dig(:options, :as)&.to_sym)
+          name.to_s if Plutonium::Definition::InputAliases.file_input?(config.dig(:options, :as))
         }
       end
 
@@ -237,24 +244,79 @@ module Plutonium
 
       # Returns the current parent based on path parameters
       # @return [ActiveRecord::Base, nil] The current parent
+      # The record this request is nested under, if any.
+      #
+      # The route says which parent it nests under (see
+      # Plutonium::Routing::PARENT_KEY_PARAM); all that is
+      # left is to load it. A plural parent narrows by the id in the path. A
+      # singular parent has no id to narrow by — it is whichever record the
+      # viewer's scope resolves to, which is what `singular: true` promises.
+      #
+      # Memoised through `defined?` so a genuine nil is remembered rather than
+      # re-resolved on every call.
       def current_parent
-        return unless parent_route_param
-
-        @current_parent ||= begin
-          parent_route_key = parent_route_param.to_s.gsub(/_id$/, "").to_sym
-          parent_class = current_engine.resource_register.route_key_lookup[parent_route_key]
-          parent_scope = authorized_scope(parent_class.all, context: {entity_scope: entity_scope_for_authorize})
-          parent_scope = parent_scope.from_path_param(params[parent_route_param])
-          current_parent = parent_scope.first!
-          authorize! current_parent, to: :read?
-          current_parent
+        return @current_parent if defined?(@current_parent)
+
+        @current_parent = begin
+          parent_class = current_parent_class
+          if parent_class
+            scope = authorized_scope(parent_class.all, context: {entity_scope: entity_scope_for_authorize})
+            parent = if singular_resource_route_for?(parent_class)
+              # A singular parent puts no id in the path, so the scope must
+              # already identify exactly one record. `sole` says so: `first!`
+              # would quietly hand back whichever row sorted first if the scope
+              # ever resolved to several, and silently nesting under the wrong
+              # parent is far worse than failing loudly.
+              resolve_singular_parent(scope, parent_class)
+            else
+              # The id parameter is named by the parent's own route, so it is
+              # derived rather than discovered. Scanning path_parameters for
+              # anything ending in _id would also match an unrelated parameter
+              # an application happens to name that way.
+              scope.from_path_param(params[:"#{parent_class.model_name.singular}_id"]).first!
+            end
+            parent.tap { authorize! parent, to: :read? }
+          end
         end
       end
 
-      # Returns the parent route parameter
-      # @return [Symbol, nil] The parent route parameter
-      def parent_route_param
-        @parent_route_param ||= request.path_parameters.keys.reverse.find { |key| /_id$/.match? key }
+      # `sole`, but reporting the registration mistake instead of the symptom.
+      #
+      # `SoleRecordExceeded` says "Wanted only one User" — true, and useless to
+      # the person who has to fix it, because the cause is two files away: the
+      # resource was registered `singular: true` while its policy still scopes to
+      # many. Say that, and name both halves of the fix.
+      # @raise [Plutonium::SingularScopeError]
+      def resolve_singular_parent(scope, parent_class)
+        scope.sole
+      rescue ActiveRecord::SoleRecordExceeded
+        # Deliberately says nothing about the viewer: this runs while raising, and
+        # reaching for `current_user` here would swap the useful error for a
+        # NoMethodError in any context that has no such helper.
+        raise Plutonium::SingularScopeError,
+          "#{parent_class} is registered `singular: true`, but its authorized scope " \
+          "resolved to #{scope.count} records. A singular route carries no :id, so the " \
+          "scope has to identify exactly one record. Either give #{parent_class}'s policy " \
+          "a `relation_scope` that narrows to one, or register it without `singular: true`."
+      end
+
+      # The parent resource class, taken from the registration rather than
+      # re-derived from a name. Registration had the class in hand; carrying the
+      # name instead would mean looking it back up by a string that two
+      # differently-namespaced resources can share.
+      # @return [Class, nil]
+      def current_parent_class
+        current_nested_route_config&.[](:parent_class)
+      end
+
+      # The registration for the nesting this request arrived through, if any.
+      # @return [Hash, nil]
+      def current_nested_route_config
+        return @current_nested_route_config if defined?(@current_nested_route_config)
+
+        nested_key = request.path_parameters[Plutonium::Routing::NESTED_KEY_PARAM]
+        @current_nested_route_config =
+          nested_key && current_engine.routes.resource_route_config_lookup[nested_key]
       end
 
       # Returns the parent input parameter (the belongs_to association name on the child)
@@ -275,10 +337,28 @@ module Plutonium
         # 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
+        # Fall back to finding belongs_to by foreign key.
+        #
+        # Polymorphic reflections are skipped rather than compared: asking a
+        # polymorphic belongs_to for its klass raises, and one sharing the
+        # parent's foreign key name would take the whole request down.
+        #
+        # The class is matched with is_a? rather than ==, so a parent that is an
+        # STI subclass still matches an association declared against its base.
         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
+          next false unless assoc.foreign_key.to_s == foreign_key
+
+          if assoc.polymorphic?
+            # A polymorphic belongs_to cannot be asked for its class — that
+            # raises. Its counterpart is the type column, which is exactly what
+            # `has_many :things, as: :owner` names on the parent side, so the
+            # two are matched on that instead. Assigning the parent to the
+            # association then sets both the id and the type.
+            parent_assoc.type.present? && assoc.foreign_type.to_s == parent_assoc.type.to_s
+          else
+            current_parent.is_a?(assoc.klass)
+          end
         end
         child_assoc&.name&.to_sym
       end

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

@@ -7,8 +7,38 @@ module Plutonium
 
           private
 
-          def setup_index_action!
-            @pagy, @resource_records = pagy(:offset, filtered_resource_collection)
+          # `action` names the action whose field set is about to be rendered.
+          # It defaults to the current one, and the reposition drop POST passes
+          # "index" for the same reason it does when building the collection: it
+          # re-renders the index on the index's behalf, and a resource must not
+          # have to define permitted_attributes_for_reposition to be draggable.
+          def setup_index_action!(action: action_name)
+            # Applied HERE, not inside filtered_resource_collection: what to
+            # preload depends on what is about to be RENDERED, and
+            # filtered_resource_collection is shared with the CSV export, which
+            # renders a different column set (`permitted_attributes_for_export`).
+            # Reading the index's fields in there resolved the wrong policy
+            # method for that action and raised. Keeping the hook to filtering and
+            # eager-loading at the point of use also leaves an app's own
+            # `filtered_resource_collection` override unaffected.
+            collection = auto_eager_load(filtered_resource_collection, presentable_attributes_for(action))
+            @pagy, @resource_records = pagy(:offset, collection, request: pagy_request_context)
+          end
+
+          # What Pagy builds its page URLs from. Pagy accepts either the real
+          # request object or a plain hash (Pagy::Request), which is the seam we
+          # need: an action that re-renders the collection on the index's behalf
+          # (the reposition drop POST) must emit page links pointing at the index
+          # page, not at its own POST-only path. current_page_path is that page —
+          # it equals request.path for a genuine index request, so the default is
+          # exactly today's behaviour.
+          def pagy_request_context
+            {
+              base_url: request.base_url,
+              path: current_page_path,
+              params: request.GET.merge(request.POST).to_h,
+              cookie: request.cookies["pagy"]
+            }
           end
 
           def filtered_resource_collection

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

@@ -38,7 +38,7 @@ module Plutonium
           authorize_current! resource_class
           set_page_title "Create #{resource_class.model_name.human.titleize}"
 
-          @resource_record = resource_class.new
+          @resource_record = build_resource_record
           maybe_apply_submitted_resource_params!
 
           render :new, formats: [:html]
@@ -49,7 +49,7 @@ module Plutonium
           authorize_current! resource_class
           set_page_title "Create #{resource_class.model_name.human.titleize}"
 
-          @resource_record = resource_class.new resource_params
+          @resource_record = build_resource_record resource_params
 
           respond_to do |format|
             if params[:pre_submit]
@@ -165,6 +165,34 @@ module Plutonium
 
         private
 
+        # Builds the record that :new renders a form for and :create saves.
+        #
+        # Through a nested route it is built on the parent's association rather
+        # than on the class, so an association carrying a scope supplies that
+        # scope's attributes as defaults — exactly what `parent.things.new` does
+        # in Rails. The list side already honours the scope (the policy merges
+        # the relation into that same association), so building on the class
+        # instead produces a record the list filters straight back out: the
+        # create reports success and the row never appears.
+        #
+        # Only equality conditions carry over. `where(published: true)` becomes
+        # an attribute; `where("expires_at > ?", Time.current)` cannot, because
+        # that is all Rails derives create attributes from.
+        #
+        # The foreign key is still injected as an attribute by
+        # override_parent_params, which stays the authority for the value. This
+        # only adds what the association declares beyond it.
+        def build_resource_record(attributes = {})
+          return resource_class.new(attributes) unless current_parent
+
+          association = current_parent.class.reflect_on_association(current_nested_association)
+          if association.collection?
+            current_parent.public_send(current_nested_association).new(attributes)
+          else
+            current_parent.public_send(:"build_#{current_nested_association}", attributes)
+          end
+        end
+
         # Hook fired once, immediately after a successful create-save and BEFORE
         # the response is built. No-op by default. KanbanActions overrides it to
         # apply a kanban quick-add column's on_enter + positioning to the freshly

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Resource
+    module Controllers
+      # Preloads the associations and attachments a collection is about to
+      # render, without being told which.
+      #
+      # Plutonium can do this where a general-purpose Rails app cannot. The
+      # rendered field set is DECLARED — resolved from the policy — rather than
+      # discovered by running a template, and resolving it never touches the
+      # collection. So the exact set of associations a page will read is known
+      # before the query is built. There is no `includes` list to write, and none
+      # to keep in step with the definition as fields come and go.
+      #
+      # Every collection rendering passes its OWN field set, because they differ:
+      # the index renders `presentable_attributes`, the CSV export renders
+      # `permitted_attributes_for_export`, and a kanban card renders its
+      # `card_fields` (falling back to the grid fields). Reading one action's
+      # fields from another's code path resolves the wrong policy method.
+      module EagerLoading
+        extend ActiveSupport::Concern
+
+        private
+
+        # Whether this controller preloads what it is about to render.
+        # Override to opt a single resource out (or in, against a global off).
+        # @return [Boolean]
+        def auto_eager_load_collections?
+          Plutonium.configuration.auto_eager_load_collections
+        end
+
+        # @param collection [ActiveRecord::Relation]
+        # @param fields [Array<Symbol>] the field set about to be rendered
+        # @return [ActiveRecord::Relation]
+        def auto_eager_load(collection, fields)
+          return collection unless auto_eager_load_collections?
+
+          fields = Array(fields).map(&:to_sym)
+
+          associations = fields & eager_loadable_associations
+          collection = collection.includes(*associations) if associations.any?
+
+          # Attachments are not associations under their declared name: for BOTH
+          # backends `reflect_on_association(:file)` is nil, and the reflections
+          # that exist are `file_attachment`/`file_blob`. `with_attached_*` is the
+          # supported preload and ActiveStorage and active_shrine both expose it,
+          # so one path serves both.
+          (fields & eager_loadable_attachments).each do |name|
+            collection = collection.public_send(:"with_attached_#{name}")
+          end
+
+          collection
+        end
+
+        # Every association kind, `has_many` included.
+        #
+        # `has_many` is preloaded because of what Plutonium actually renders: an
+        # association field renders the associated records' LABELS, not a count.
+        # The rows are read either way, so preloading only decides whether that
+        # costs one query or one per parent. (Excluding it on the usual "a count
+        # beats loading every child row" reasoning is an argument about a
+        # rendering this framework doesn't do.)
+        #
+        # Both lists are memoised on the model (outside dev) by
+        # Resource::Record::FieldNames. Its association lists already strip the
+        # `_attachment`/`_blob` reflections backing an attachment, so those cannot
+        # be loaded twice by the two branches above. Its attachment lists go
+        # through `reflect_on_all_attachments`, which — unlike
+        # `attachment_reflections`, empty under active_shrine — reports both
+        # backends.
+        def eager_loadable_associations
+          @eager_loadable_associations ||=
+            resource_class.belongs_to_association_field_names +
+            resource_class.has_one_association_field_names +
+            resource_class.has_many_association_field_names
+        end
+
+        def eager_loadable_attachments
+          @eager_loadable_attachments ||=
+            resource_class.has_one_attached_field_names +
+            resource_class.has_many_attached_field_names
+        end
+      end
+    end
+  end
+end

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

@@ -34,6 +34,9 @@ module Plutonium
       module ExportCsv
         extend ActiveSupport::Concern
 
+        # Collections rendered here preload what they are about to show.
+        include Plutonium::Resource::Controllers::EagerLoading
+
         # Placeholder written when a column is neither an `export` block nor a
         # real attribute on the record, so the export degrades to a usable file
         # instead of a mid-stream NoMethodError (which would truncate the
@@ -84,7 +87,13 @@ module Plutonium
         #   object entirely (no scope/filter/search/default-scope).
         # Both still respect tenant/parent scoping (current_authorized_scope).
         def export_csv_collection
-          export_all_requested? ? current_authorized_scope : filtered_resource_collection
+          scope = export_all_requested? ? current_authorized_scope : filtered_resource_collection
+          # Preloaded against the EXPORT's own column set, which is
+          # `permitted_attributes_for_export` and need not match the index's.
+          # This is the worst N+1 of the three collection renderings: an export
+          # streams every matching row, not a page of them, so a per-row
+          # association read is unbounded.
+          auto_eager_load(scope, exportable_attributes)
         end
 
         def export_all_requested?

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

@@ -32,6 +32,9 @@ module Plutonium
       module KanbanActions
         extend ActiveSupport::Concern
 
+        # Collections rendered here preload what they are about to show.
+        include Plutonium::Resource::Controllers::EagerLoading
+
         # Tags board-bound redirects with kanban_reload=1 so the permanent board
         # refreshes its cached column frames on arrival (see #kanban_reload_url).
         # Wraps ALL three redirect helpers — create/update (after_submit), destroy
@@ -133,7 +136,7 @@ module Plutonium
           # neighbor computation and WIP count are correct in all cases
           # (cross-column, same-column reorder, record already in destination).
           dest_scoped = Plutonium::Kanban::Grouping.apply_scope(kanban_base_relation, to.scope)
-          dest_cards = board.position_config.order(dest_scoped).where.not(id: record.id).to_a
+          dest_cards = board.position_config_for(current_definition).order(dest_scoped).where.not(id: record.id).to_a
           # to_index is client-supplied. Clamp to [0, dest_cards.size] so a negative
           # value can't wrap via Ruby's negative array indexing (dest_cards[-1] would
           # silently anchor the drop to the LAST card) and an over-large value simply
@@ -197,7 +200,27 @@ module Plutonium
             @resource_record = record
           end
 
-          ActiveRecord::Base.transaction do
+          # Opened on the RECORD'S OWN connection, not ActiveRecord::Base's. A
+          # transaction lives on the receiver's connection pool, and every write
+          # this block owns — the on_exit/on_enter save!, reposition!'s update!
+          # (and any rebalance it triggers), the final save! — goes out on
+          # `record`'s pool. For a resource on a secondary database
+          # ActiveRecord::Base.transaction would BEGIN on primary and leave all of
+          # those autocommitting unprotected: a failure mid-move could persist an
+          # on_enter column change with no reposition, or a half-applied
+          # rebalance. Do not "simplify" this back to ActiveRecord::Base.
+          #
+          # LIMIT — this is a single-connection guarantee, and the drop
+          # interaction (step 2) plus user-supplied on_exit/on_enter blocks may
+          # write models the framework knows nothing about. Those are covered iff
+          # they sit on the SAME connection as `record` (the overwhelmingly common
+          # case: one database, or the same secondary as the resource). Writes to
+          # a model on a DIFFERENT database are NOT rolled back by this block, and
+          # no choice of receiver can fix that — Rails has no two-phase commit
+          # across pools, and nesting a second transaction would only shrink the
+          # window, not close it. record.class is the best available receiver
+          # because it is the one whose writes this action definitely owns.
+          record.class.transaction do
             # (1) Apply on_exit (SOURCE column) then on_enter (DESTINATION column),
             # CROSS-column moves only. A same-column reorder skips both (see
             # cross_column above) and only repositions; on_exit/on_enter represent
@@ -256,7 +279,7 @@ module Plutonium
             # Mode A delegates to record.reposition! (calls update! for position).
             # Mode B calls the user-supplied block.
             # Mode C is a no-op (no ordering; position unchanged).
-            board.position_config.reposition!(
+            board.position_config_for(current_definition).reposition!(
               record:,
               column: to.key,
               prev_record:,
@@ -320,7 +343,7 @@ module Plutonium
               if run_enter_interaction
                 streams += [turbo_stream.update(Plutonium::REMOTE_MODAL_FRAME, "")]
                 outcome.messages.each do |msg, type|
-                  streams += [turbo_stream.append("kanban-flash", partial: "plutonium/toast",
+                  streams += [turbo_stream.append(Plutonium::FLASH_REGION, partial: "plutonium/toast",
                     locals: {type: ((type == :notice) ? :success : type), msg:})]
                 end
               end
@@ -519,10 +542,26 @@ module Plutonium
               .extract_input(params, view_context:)[:q]
 
             base_query = current_authorized_scope
-            current_query_object.apply(base_query, query_params, context: self)
+            collection = current_query_object.apply(base_query, query_params, context: self)
+            # Preloaded here rather than at each `.to_a`, because every card query
+            # on the board derives from this relation — the column body, the
+            # lazy-loaded frames, the post-move re-render. The sites that `pluck`
+            # or `count` off it instantiate no records, so the preload does not
+            # run for them.
+            auto_eager_load(collection, kanban_card_field_names)
           end
         end
 
+        # The fields a card actually renders. A board's `card_fields` is a slot
+        # layout — each slot holds one field name, several, or `false` to hide the
+        # slot — so it is flattened to names. A board that declares no layout falls
+        # back to the read attribute set, the same one the column component is
+        # handed as `resource_fields`.
+        def kanban_card_field_names
+          slots = current_kanban_board.card_fields
+          slots ? slots.values.flatten.grep(Symbol) : permitted_attributes_for("index")
+        end
+
         # Intercepts the index action when view=kanban + column= is present.
         # Renders only the turbo-frame body for the requested column and halts.
         def maybe_render_kanban_column
@@ -535,9 +574,9 @@ module Plutonium
           board = current_kanban_board
 
           # Resolve only the requested column rather than grouping the whole
-          # board: Grouping.call would scope+count+limit every column (~2 queries
-          # each) on every lazy frame request. We compare keys as strings to
-          # avoid interning arbitrary request input into symbols.
+          # board: grouping every column would scope+count+limit all of them
+          # (~2 queries each) on every lazy frame request. We compare keys as
+          # strings to avoid interning arbitrary request input into symbols.
           columns = Plutonium::Kanban::Grouping.resolve_columns(board, kanban_context)
           column = columns.find { |c| c.key.to_s == params[:column] }
 
@@ -578,7 +617,7 @@ module Plutonium
           return "".html_safe unless column
 
           scoped = Plutonium::Kanban::Grouping.apply_scope(kanban_base_relation, column.scope)
-          ordered = board.position_config.order(scoped)
+          ordered = board.position_config_for(current_definition).order(scoped)
 
           if board.per_column
             total = ordered.count
@@ -729,7 +768,7 @@ module Plutonium
           case on.to_sym
           when :visible
             board = current_kanban_board
-            ordered = board.position_config.order(scoped)
+            ordered = board.position_config_for(current_definition).order(scoped)
             limited = board.per_column ? ordered.limit(board.per_column) : ordered
             limited.pluck(resource_class.primary_key)
           else # :all and any unknown value
@@ -780,8 +819,8 @@ module Plutonium
           # nil), via the board's position_config — the same path a drag-drop uses.
           board = current_kanban_board
           dest_scoped = Plutonium::Kanban::Grouping.apply_scope(kanban_base_relation, column.scope)
-          dest_cards = board.position_config.order(dest_scoped).where.not(id: record.id).to_a
-          board.position_config.reposition!(
+          dest_cards = board.position_config_for(current_definition).order(dest_scoped).where.not(id: record.id).to_a
+          board.position_config_for(current_definition).reposition!(
             record:,
             column: column.key,
             prev_record: dest_cards.last,
@@ -795,7 +834,7 @@ module Plutonium
         # unchanged, allowing the Stimulus drag controller to snap the card back.
         #
         # When a reason is given, a single dismissable toast is appended to the
-        # board's #kanban-flash region so the snap-back is explained rather than
+        # page's shared toast region so the snap-back is explained rather than
         # silent. It renders the shared _toast partial directly (not via flash)
         # so a stale, undisplayed flash from an earlier request can't leak into
         # the turbo_stream response — these move POSTs never render the layout
@@ -810,7 +849,7 @@ module Plutonium
 
           if reason
             streams << turbo_stream.append(
-              "kanban-flash",
+              Plutonium::FLASH_REGION,
               partial: "plutonium/toast",
               locals: {type: :warning, msg: reason}
             )