habarico 7.3.0.pre.beta.7 → 7.3.0.pre.beta.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccab4855ae575799d8c7b8dc724f8b56d5115d77f1aa3fe8a69f8c57d39b002a
-  data.tar.gz: 89d5e992dc3aa9121a26d25c72f1151b34c0136d01b05edc9e98d3e4f8de8a6d
+  metadata.gz: d4d4ae92bdfc004471375643191a1ca845fb27d8e5186906c185e683705e2277
+  data.tar.gz: da980d711e305d3cf7b3fb892845068945d308bf0bda223d9ae8f8b5e48e803b
 SHA512:
-  metadata.gz: 98b13911cb62726a2816019e305479afc1ee08e138afb608999902ad7ef95dca786642114a03fc96cc89c51d017574d66fe2eca46af29cda7ab4a4b07bf84b37
-  data.tar.gz: 5f411af0470bd6c2320a669e479173693025f60463568fa1d21d085773bd4c0b19f87837d5200184279df71ed8fcef9caeddb1210e13d1caa22fb5cde6adf2c6
+  metadata.gz: 9b4846e10c4ca8541a121e8a552fd6dc6265e2de4716e50e9af4c97ed5a2b4a4e781b4b69f7e3edb2330374eaf90b80bb20f516fcefdd8474576ae08f9942a40
+  data.tar.gz: 5592767aca7bd94f9748dea4e0770daaa110f5dd04ca61b21ec2472c7e838fbba74b77f0685e7f613a30c564116eb8aea2795db8922f45bb5337daf2a6635cff

data/VERSION

@@ -1 +1 @@
-7.3.0-beta.7
+7.3.0-beta.9

data/lib/habarico/contrib/preferences/base_preferences.rb

@@ -5,7 +5,6 @@ module Habarico
       BASE_PREFERENCES = {
         "theme" => Schemas::THEME,
         "locale" => Schemas::LOCALE,
-        "preferences.dashboard" => Schemas::DASHBOARD,
         "preferences.layout.app.pageWidth" => Schemas::APP_PAGE_WIDTH,
         "preferences.layout.app.contrastMode" => Schemas::CONTRAST_MODE,
         "preferences.layout.app.stripedRows" => Schemas::STRIPED_ROWS,

data/lib/habarico/contrib/preferences/config.rb

@@ -13,11 +13,10 @@ module Habarico
       # no limit. Mirrors the Python `HABARICO_PREFERENCES["MAX_VALUE_BYTES"]` setting.
       #
       # The values below sit an order of magnitude above what the frontend actually writes:
-      # 100 datagrid columns are ~2 KB of `columns`/`columnWidths`, a 30-widget dashboard
-      # ~19 KB and 20 saved queries ~11 KB at their fullest.
+      # 100 datagrid columns are ~2 KB of `columns`/`columnWidths` and 20 saved queries ~11 KB at
+      # their fullest. A package registering its own key brings its own limit with it.
       mattr_accessor :max_value_bytes, default: {
         "default" => 16 * 1024,
-        "preferences.dashboard" => 32 * 1024,
         %r{[a-zA-Z][a-zA-Z0-9_./-]*\.savedQueries} => 32 * 1024,
       }
 

data/lib/habarico/contrib/preferences/registry.rb

@@ -23,7 +23,7 @@ module Habarico
       # `max_bytes` needs no sentinel, unlike `default`: nil is not a usable size, so it simply
       # means "not given at registration" and defers to `max_value_bytes`. It is resolved once, at
       # registration, exactly like `defaults` - nothing reads the configuration per write.
-      Entry = Struct.new(:schema, :default, :validator, :max_bytes, keyword_init: true)
+      Entry = Struct.new(:schema, :default, :validator, :max_bytes, :migrate_value, keyword_init: true)
 
       class PreferenceRegistry
         def initialize
@@ -37,11 +37,14 @@ module Habarico
           @pattern_entries.clear
         end
 
-        def register(key, schema:, default: EMPTY, max_bytes: nil)
+        # `migrate_value` is called with a stored value that no longer validates, before it would be
+        # deleted; whatever it returns is validated and saved. It is how the package that owns a
+        # shape changes it without a data migration.
+        def register(key, schema:, default: EMPTY, max_bytes: nil, migrate_value: nil)
           raise InvalidPreferenceKey, key unless key.is_a?(String) && key.match?(KEY_PATTERN)
           raise PreferenceAlreadyRegistered, key if @entries.key?(key)
 
-          @entries[key] = build_entry(key, schema, default, max_bytes)
+          @entries[key] = build_entry(key, schema, default, max_bytes, migrate_value)
           nil
         end
 
@@ -147,20 +150,20 @@ module Habarico
           raise PreferenceValueTooLarge.new(key, limit, size) if size > limit
         end
 
-        # Configured limit for the key - or pattern - a preference is being registered under. An
-        # explicit `max_bytes:` wins; otherwise `max_value_bytes` decides, by the very string the
-        # preference is registered under, falling back to its "default" entry; a nil there means
-        # unlimited. A pattern may be configured as a Regexp or as its source string. Read once, at
-        # registration, exactly like `defaults`: changing the config afterwards does not move an
-        # already-registered limit.
+        # Configured limit for the key - or pattern - a preference is being registered under.
+        # `max_value_bytes` decides first, by the very string the preference is registered under: a
+        # deployment's word outranks a limit a gem registered, which is itself a default above the
+        # hash's "default" entry. A nil anywhere there means unlimited. A pattern may be configured as
+        # a Regexp or as its source string. Read once, at registration, exactly like `defaults`:
+        # changing the config afterwards does not move an already-registered limit.
         def resolve_max_bytes(registered_as, max_bytes)
-          return max_bytes unless max_bytes.nil?
-
           limits = Preferences.max_value_bytes || {}
           limits.each do |configured, bytes|
             name = configured.is_a?(Regexp) ? configured.source : configured.to_s
             return bytes if name == registered_as
           end
+          return max_bytes unless max_bytes.nil?
+
           limits["default"]
         end
 
@@ -191,10 +194,10 @@ module Habarico
           raise PreferenceNotRegistered, key
         end
 
-        def build_entry(key, schema, default, max_bytes = nil)
+        def build_entry(key, schema, default, max_bytes = nil, migrate_value = nil)
           validator = JSONSchemer.schema(schema)
           entry = Entry.new(schema: schema, default: default, validator: validator,
-                            max_bytes: resolve_max_bytes(key, max_bytes))
+                            max_bytes: resolve_max_bytes(key, max_bytes), migrate_value: migrate_value)
           return entry if default.equal?(EMPTY) || default.respond_to?(:call)
 
           errors = validator.validate(default).to_a
@@ -203,6 +206,22 @@ module Habarico
           entry
         end
 
+        # Gives the owner's schema a chance to bring a stored value up to date, in place.
+        #
+        # A migration that does not validate, or one that raises, leaves the record to be deleted:
+        # a schema's own bug must not make reading preferences fail.
+        def migrate_stored_value(entry, record)
+          return false if entry.migrate_value.nil?
+
+          migrated = entry.migrate_value.call(record.value)
+          return false unless entry.validator.valid?(migrated)
+
+          record.update!(value: migrated)
+          true
+        rescue StandardError
+          false
+        end
+
         # Resolves a (possibly callable) default. A callable that returns EMPTY or an
         # invalid value degrades to EMPTY, mirroring Python `_resolve_default`.
         def resolve_default(entry)
@@ -221,7 +240,7 @@ module Habarico
         # returns nil (single-GET => 404, list => omit).
         def resolve(key, entry, record)
           if record
-            if entry.validator.valid?(record.value)
+            if entry.validator.valid?(record.value) || migrate_stored_value(entry, record)
               return ResolvedPreference.new(key: key, value: record.value, updated_at: record.updated_at)
             end
 
@@ -241,8 +260,8 @@ module Habarico
         @registry ||= PreferenceRegistry.new
       end
 
-      def self.register_preference(key, schema:, default: EMPTY, max_bytes: nil)
-        registry.register(key, schema: schema, default: default, max_bytes: max_bytes)
+      def self.register_preference(key, schema:, default: EMPTY, max_bytes: nil, migrate_value: nil)
+        registry.register(key, schema: schema, default: default, max_bytes: max_bytes, migrate_value: migrate_value)
       end
 
       def self.register_preference_pattern(pattern, schema:, max_bytes: nil)

data/lib/habarico/contrib/preferences/schemas.rb

@@ -46,86 +46,6 @@ module Habarico
             },
           },
         }.freeze
-
-        WIDGET_LAYOUT = {
-          "type" => "object",
-          "required" => %w[x y w h],
-          "properties" => {
-            "x" => { "type" => "integer", "minimum" => 0 },
-            "y" => { "type" => "integer", "minimum" => 0 },
-            "w" => { "type" => "integer", "minimum" => 1 },
-            "h" => { "type" => "integer", "minimum" => 1 },
-            "stackedH" => { "type" => "integer", "minimum" => 1 },
-            "minW" => { "type" => "integer", "minimum" => 1 },
-            "minH" => { "type" => "integer", "minimum" => 1 },
-          },
-        }.freeze
-
-        GROUP_BY_BUCKET = {
-          "oneOf" => [
-            {
-              "type" => "object",
-              "required" => %w[type granularity],
-              "properties" => {
-                "type" => { "const" => "trunc" },
-                "granularity" => { "enum" => %w[second minute hour day week month quarter year] },
-              },
-            },
-            {
-              "type" => "object",
-              "required" => %w[type size],
-              "properties" => {
-                "type" => { "const" => "width" },
-                "size" => { "type" => "number" },
-              },
-            },
-          ],
-        }.freeze
-
-        GROUP_BY_ITEM = {
-          "type" => "object",
-          "required" => %w[field],
-          "properties" => {
-            "field" => { "type" => "string" },
-            "bucket" => { "anyOf" => [GROUP_BY_BUCKET, { "type" => "null" }] },
-          },
-        }.freeze
-
-        CHART_OPTIONS = {
-          "type" => "object",
-          "properties" => {
-            "orientation" => { "enum" => %w[vertical horizontal] },
-            "variant" => { "enum" => %w[pie doughnut] },
-          },
-        }.freeze
-
-        WIDGET_CONFIG = {
-          "type" => "object",
-          "required" => %w[id type layout],
-          "properties" => {
-            "id" => { "type" => "string" },
-            "type" => { "type" => "string" },
-            "resource" => { "type" => %w[string null] },
-            "label" => { "type" => %w[string null] },
-            "layout" => WIDGET_LAYOUT,
-            "filters" => { "type" => %w[object null], "additionalProperties" => { "type" => "string" } },
-            "sort" => { "anyOf" => [SORT, { "type" => "null" }] },
-            "perPage" => { "type" => %w[integer null], "minimum" => 1 },
-            "columns" => { "type" => %w[array null], "items" => { "type" => "string" } },
-            "field" => { "type" => %w[string null] },
-            "aggregateFunction" => { "type" => %w[string null], "enum" => [nil, "count", "sum", "avg", "min", "max"] },
-            "color" => { "type" => %w[string null], "enum" => [nil, "primary", "secondary", "success", "error", "warning", "info", "inherit"] },
-            "groupBy" => { "type" => %w[array null], "items" => GROUP_BY_ITEM },
-            "chartOptions" => { "anyOf" => [CHART_OPTIONS, { "type" => "null" }] },
-          },
-        }.freeze
-
-        DASHBOARD = {
-          "type" => "object",
-          "properties" => {
-            "widgets" => { "type" => "array", "items" => WIDGET_CONFIG },
-          },
-        }.freeze
       end
     end
   end

data/lib/habarico/definition/action_reference.rb

@@ -2,7 +2,8 @@ module Habarico
   class ActionReference
     include DefinitionModel
 
-    attr_accessor :name, :label, :icon, :color, :action, :if, :permission, :menu_items, :view_mode, :dialog_width, :view_choices, :view_parameters, :view_keep_linked_parent
+    attr_accessor :name, :label, :icon, :color, :action, :if, :permission, :menu_items, :view_mode, :dialog_width, :view_choices, :view_parameters, :view_keep_linked_parent,
+                  :reference, :confirm_dialog_title, :confirm_dialog_message
 
     def initialize(params = {})
       @permission = case params[:name].to_s

data/lib/habarico/definition/boxes/box.rb

@@ -15,7 +15,7 @@ module Habarico
     attr_accessor :grid_item
 
     # List
-    attr_accessor :reference, :target, :extra_filters, :row_actions, :list_toolbar_actions, :list_actions, :filters, :default_sorting, # rubocop:disable Lint/DuplicateMethods -- intentional for readability
+    attr_accessor :reference, :target, :extra_filters, :row_actions, :list_actions, :filters, :default_sorting, # rubocop:disable Lint/DuplicateMethods -- intentional for readability
                   :sortable_field_name, :sortable_sort_for_filters, :single_click_action, :double_click_action
 
     # Object

data/lib/habarico/definition/concerns/definition_model.rb

@@ -3,11 +3,15 @@ module Habarico
     extend ActiveSupport::Concern
 
     def initialize(params = {})
-      self.class.attrs.each do |attr|
-        if params.key?(attr)
-          self.send("#{attr}=", params[attr])
-        end
-      end
+      assign(params)
+    end
+
+    # Whether the author said anything about this attribute, as opposed to leaving it alone.
+    #
+    # The distinction an action slot needs: a slot nobody mentioned publishes the resource's default
+    # actions, while `nil` and `[]` are both decisions to render none of them.
+    def assigned?(attr)
+      @assigned_attrs.present? && @assigned_attrs.include?(attr)
     end
 
     def assign(params = {})
@@ -28,9 +32,17 @@ module Habarico
         @attrs
       end
 
+      # Records every assignment, so `assigned?` can tell a slot left alone from one emptied on
+      # purpose - whichever way the host app wrote it, a constructor hash or a plain setter.
       def attr_accessor(*attrs)
         self.attrs.concat(attrs)
         super(*attrs)
+        attrs.each do |attr|
+          define_method("#{attr}=") do |value|
+            (@assigned_attrs ||= []) << attr
+            instance_variable_set("@#{attr}", value)
+          end
+        end
       end
     end
 

data/lib/habarico/definition/default_actions_reference.rb

@@ -0,0 +1,18 @@
+module Habarico
+  # What an author writes in an action slot to mean "this resource's default actions".
+  #
+  # The client expands it into one ordinary action descriptor per supported action, so it names no
+  # action and carries none of a button's appearance - a label, an icon and a colour belong to each
+  # action it expands into.
+  class DefaultActionsReference
+    include DefinitionModel
+
+    # Resource whose defaults expand here: a name, `ResourceReference::CURRENT`,
+    # `ResourceReference::LIST`, or nothing for the resource the slot is read in
+    attr_accessor :reference
+
+    # Which of them: `:list`, `:detail` or `:all`
+    attr_accessor :scope
+
+  end
+end

data/lib/habarico/definition/definition.rb

@@ -38,7 +38,7 @@ module Habarico
                   # Generator classes - action
                   :link_action_parameters_generator, :resource_action_endpoint_parameters_generator,
                   :resource_action_parameters_generator, :save_action_parameters_generator, :action_schema_generator,
-                  :view_action_endpoint_parameters_generator, :view_action_parameters_generator,
+                  :view_action_parameters_generator,
                   :confirm_dialog_properties_generator, :global_resource_action_schema_generator,
                   :resource_action_schema_generator, :upload_files_action_parameters_generator,
                   :trigger_action_schema_generator,
@@ -117,7 +117,6 @@ module Habarico
       @resource_action_parameters_generator = Habarico::ResourceActionParametersGenerator
       @save_action_parameters_generator = Habarico::SaveActionParametersGenerator
       @action_schema_generator = Habarico::ActionSchemaGenerator
-      @view_action_endpoint_parameters_generator = Habarico::ViewActionEndpointParametersGenerator
       @view_action_parameters_generator = Habarico::ViewActionParametersGenerator
       @confirm_dialog_properties_generator = Habarico::ConfirmDialogPropertiesGenerator
       @global_resource_action_schema_generator = Habarico::GlobalResourceActionSchemaGenerator

data/lib/habarico/generators/action/resource_action_endpoint_parameters_generator.rb

@@ -9,9 +9,7 @@ module Habarico
       Habarico::ResourceActionEndpointParameters.new(
         path: generate_path(action, context),
         method: generate_method(action, context),
-        reference: generate_reference(action, context),
-        action_name: generate_action_name(action, context),
-        record_pk: generate_record_pk(action, context)
+        reference: generate_endpoint_reference(action, context),
       )
     end
 
@@ -59,6 +57,18 @@ module Habarico
       action.endpoint_reference
     end
 
+    # What the endpoint addresses, as one address. `action_name` and `record_pk` live inside it, so
+    # they need a resource to belong to: an action without a declared reference is this admin's own.
+    def generate_endpoint_reference(action, context)
+      action_name = generate_action_name(action, context)
+      record_pk = generate_record_pk(action, context)
+      reference = generate_reference(action, context)
+      reference = resource_name if reference.blank? && (action_name.present? || record_pk.present?)
+      return nil if reference.blank?
+
+      Habarico::ResourceReference.build(reference, action_name: action_name, record_pk: record_pk)
+    end
+
     def generate_action_name(action, _context)
       return action.endpoint_action_name if action.endpoint_action_name.present?
       return nil if Habarico::ActionHelper.is_standard_action?(action)

data/lib/habarico/generators/action/trigger_action_schema_generator.rb

@@ -17,7 +17,7 @@ module Habarico
         )
       end
 
-      action_schema_generator.generate(retarget(action, record_pk, reference), context)
+      action_schema_generator.generate(retarget(action, record_pk || detail_record_pk(action, context), reference), context)
     end
 
     protected
@@ -26,6 +26,12 @@ module Habarico
       @action_schema_generator ||= definition.action_schema_generator.new(definition, resource_path)
     end
 
+    # A trigger runs outside the page of the record it was raised for, so a detail action names
+    # that record explicitly - a schema endpoint leaves it to the page.
+    def detail_record_pk(action, context)
+      context.record_pk if action.is_detail && action.endpoint_record_pk.blank?
+    end
+
     # Copies the action before setting the target, so a declared action is never mutated.
     def retarget(action, record_pk, reference)
       return action if record_pk.blank? && reference.blank?

data/lib/habarico/generators/action/upload_files_action_parameters_generator.rb

@@ -8,7 +8,7 @@ module Habarico
 
       # Create model
       Habarico::UploadFilesActionParameters.new(
-        reference: generate_reference(action, context),
+        reference: Habarico::ResourceReference.build(generate_reference(action, context)),
         target: generate_target(action, context),
         accept: generate_accept(action, context),
         file_field: generate_file_field(action, context),

data/lib/habarico/generators/action/view_action_parameters_generator.rb

@@ -20,8 +20,28 @@ module Habarico
 
     protected
 
-    def view_action_endpoint_parameters_generator
-      @view_action_endpoint_parameters_generator ||= definition.view_action_endpoint_parameters_generator.new(definition, resource_path)
+    # What the view's endpoint addresses, left unaddressed when the action points at nothing of its
+    # own. `action_name` and `record_pk` live inside the address, so an action that has either names
+    # the resource it belongs to - the same rule the resource action endpoint follows. Only an
+    # explicit `endpoint_record_pk` is carried: the record of the request is the one the frontend
+    # already renders.
+    def view_action_endpoint_reference(action, _context)
+      action_name = target_view_action_name(action)
+      record_pk = action.endpoint_record_pk.presence
+      reference = action.endpoint_reference
+      reference = resource_name if reference.blank? && (action_name.present? || record_pk.present?)
+      return nil if reference.blank?
+
+      Habarico::ResourceReference.build(reference, action_name: action_name, record_pk: record_pk)
+    end
+
+    # The action segment is the *target view's*, not the action's own name: a reserved view
+    # (`list` / `create` / `edit` / `show`) is addressed by its type and has none, so an action
+    # opening one carries no address at all.
+    def target_view_action_name(action)
+      return action.endpoint_action_name if action.endpoint_action_name.present?
+
+      definition.normalized_views.find { |view| view.name == action.view_name }&.endpoint_action_name
     end
 
     # ***********************************************************************
@@ -53,7 +73,7 @@ module Habarico
       # over the record it already has. One that names its own target does: the endpoint is where
       # the target resource and record are written down.
       return nil if Habarico::ActionHelper.is_standard_action?(action) && !Habarico::ActionHelper.has_explicit_target?(action)
-      view_action_endpoint_parameters_generator.generate(action, context)
+      view_action_endpoint_reference(action, context)
     end
 
     def generate_keep_linked_parent(action, _context)

data/lib/habarico/generators/endpoint/field_schema_generator.rb

@@ -44,7 +44,7 @@ module Habarico
         required: generate_required(model, field_name, attr_name, variant),
         sortable: generate_sortable(model, field_name, attr_name, variant),
         sort_by: generate_sort_by(model, field_name, attr_name, variant),
-        reference: generate_reference(model, field_name, attr_name, variant),
+        reference: Habarico::ResourceReference.build(generate_reference(model, field_name, attr_name, variant)),
         enum: generate_enum(model, field_name, attr_name, variant),
         items: generate_items(model, field_name, attr_name, variant, subfields),
         properties: generate_properties(model, field_name, attr_name, variant, subfields),
@@ -315,7 +315,7 @@ module Habarico
             label: label,
             type: 'string',
             format: 'relation',
-            reference: reference_class.const_get(:REFERENCE),
+            reference: Habarico::ResourceReference.build(reference_class.const_get(:REFERENCE)),
           )
         end
       end

data/lib/habarico/generators/endpoint/filter_schema_generator.rb

@@ -14,7 +14,7 @@ module Habarico
         format: generate_format(model, filter_name, filter_param),
         label: generate_label(model, filter_name, filter_param),
         help_text: generate_help_text(model, filter_name, filter_param),
-        reference: generate_reference(model, filter_name, filter_param),
+        reference: Habarico::ResourceReference.build(generate_reference(model, filter_name, filter_param)),
         enum: generate_enum(model, filter_name, filter_param),
         items: generate_items(model, filter_name, filter_param),
         properties: generate_properties(model, filter_name, filter_param),

data/lib/habarico/generators/menu/menu_view_endpoint_parameters_generator.rb

@@ -7,10 +7,10 @@ module Habarico
       raise Eluvia::Errors::StandardError.new('Argument `menu_item` must be of :view type') unless menu_item.type.to_sym == :view
 
       # Create model
-      Habarico::ViewActionEndpointParameters.new(
-        reference: generate_reference(menu_item),
+      Habarico::ResourceReference.build(
+        generate_reference(menu_item) || resource_name,
         action_name: generate_action_name(menu_item),
-        record_pk: generate_record_pk(menu_item)
+        record_pk: generate_record_pk(menu_item),
       )
     end
 

data/lib/habarico/generators/view/action_descriptor_generator.rb

@@ -1,10 +1,15 @@
 module Habarico
   class ActionDescriptorGenerator < AbstractGenerator
 
-    def generate(action_reference, context)
+    # `list_source` is the address of the resource a surrounding box lists, which only that box
+    # knows - it is what `ResourceReference::LIST` resolves to.
+    def generate(action_reference, context, list_source: nil)
       # Fallback to a simple ActionReference object if a string or symbol is provided
       action_reference = Habarico::ActionReference.new(name: action_reference.to_s) if action_reference.is_a?(String) || action_reference.is_a?(Symbol)
 
+      # A group of defaults names no action, so none of the checks below apply to it
+      return generate_default_actions(action_reference, list_source) if action_reference.is_a?(Habarico::DefaultActionsReference)
+
       # Validate arguments
       raise Eluvia::Errors::StandardError.new('Argument `action_reference` must be a Habarico::ActionReference') unless action_reference.is_a?(Habarico::ActionReference)
 
@@ -25,6 +30,8 @@ module Habarico
         icon: generate_icon(action_reference, context),
         color: generate_color(action_reference, context),
         action: generate_action(action_reference, context),
+        reference: resolve_reference(action_reference.reference, context, list_source),
+        confirm_dialog: generate_confirm_dialog(action_reference, context),
         view: generate_view(action_reference, context),
         menu_items: generate_menu_items(action_reference, context),
       )
@@ -32,6 +39,34 @@ module Habarico
 
     protected
 
+    def confirm_dialog_properties_generator
+      @confirm_dialog_properties_generator ||= definition.confirm_dialog_properties_generator.new(definition, resource_path)
+    end
+
+    def generate_default_actions(action_reference, list_source)
+      Habarico::DefaultActionsDescriptor.new(
+        reference: resolve_reference(action_reference.reference, nil, list_source),
+        scope: action_reference.scope,
+      )
+    end
+
+    # The address a descriptor binds to: a name as written, or what a sentinel stands for.
+    #
+    # `CURRENT` is the resource the schema is being generated for, narrowed to the record when the
+    # request has one. `LIST` is the collection the surrounding box lists, which the box passes in.
+    def resolve_reference(reference, context, list_source)
+      case reference
+      when nil then nil
+      when Habarico::ResourceReference then reference
+      when Habarico::ResourceReference::CURRENT
+        Habarico::ResourceReference.build(resource_name, record_pk: context&.record_pk)
+      when Habarico::ResourceReference::LIST
+        raise Eluvia::Errors::StandardError.new('`ResourceReference::LIST` is stamped by the box that lists a resource, so this reference is not inside a list or gallery box') if list_source.nil?
+        list_source
+      else Habarico::ResourceReference.build(reference)
+      end
+    end
+
     def action_schema_generator
       @action_schema_generator ||= definition.action_schema_generator.new(definition, resource_path)
     end
@@ -56,6 +91,12 @@ module Habarico
       action_reference.color
     end
 
+    def generate_confirm_dialog(action_reference, context)
+      return nil if action_reference.confirm_dialog_title.blank? && action_reference.confirm_dialog_message.blank?
+      raise Eluvia::Errors::StandardError.new('A confirm dialog needs both a title and a message, or neither') if action_reference.confirm_dialog_title.blank? || action_reference.confirm_dialog_message.blank?
+      confirm_dialog_properties_generator.generate(action_reference, context)
+    end
+
     def generate_action(action_reference, context)
       if action_reference.action.present?
         return action_schema_generator.generate(action_reference.action, context)

data/lib/habarico/generators/view/box_schema_generator.rb

@@ -124,18 +124,36 @@ module Habarico
 
     # Box-level toolbar (box header / card header area), relative to the box root. Emitted for all box types
     # including 'list' - for a list box the table's own toolbar is carried separately by 'list.toolbar_actions'.
+    # A descriptor here is rendered in the parent's context, so one meant for the resource a list or
+    # gallery box points at has to name it - `ResourceReference::LIST` is how an author says that
+    # without repeating the name the box already carries.
     def generate_toolbar_actions(_view, box, _index, context)
       return nil if box.toolbar_actions.nil?
+      list_source = listed_resource_address(box, context)
       box.toolbar_actions.map do |action|
-        action_descriptor_generator.generate(action, context)
+        action_descriptor_generator.generate(action, context, list_source: list_source)
       end.compact
     end
 
-    # Box-level bottom actions (rendered below the box fields), relative to the box root.
+    # What `ResourceReference::LIST` stands for inside this box: the collection it lists, with the
+    # query its own schema request carries. Only a list or gallery box has one.
+    LISTING_BOX_TYPES = %i[list gallery].freeze
+
+    def listed_resource_address(box, context)
+      return nil unless LISTING_BOX_TYPES.include?(box.type&.to_sym)
+      return nil if box.reference.blank?
+
+      link = Habarico::BoxHelper.parent_link_params(box, context, resource_name)
+      Habarico::ResourceReference.build(box.reference, params: (box.schema_params || {}).merge(link || {}).presence)
+    end
+
+    # Box-level bottom actions (rendered below the box fields), relative to the box root - the same
+    # parent context as the header, so a descriptor here resolves `ResourceReference::LIST` too.
     def generate_bottom_actions(_view, box, _index, context)
       return nil if box.bottom_actions.nil?
+      list_source = listed_resource_address(box, context)
       box.bottom_actions.map do |action|
-        action_descriptor_generator.generate(action, context)
+        action_descriptor_generator.generate(action, context, list_source: list_source)
       end.compact
     end
 

data/lib/habarico/generators/view/detail_view_parameters_generator.rb

@@ -33,13 +33,17 @@ module Habarico
       box_schema_generator.generate(view, view.box, 0, context)
     end
 
+    # Everything the resource supports, until the view says otherwise. Only a slot the author never
+    # mentioned carries the default: `nil` and `[]` are both decisions to render nothing.
     def generate_toolbar_actions(view, context)
-      unless view.toolbar_actions.nil?
-        return view.toolbar_actions.map do |action|
-          action_descriptor_generator.generate(action, context)
-        end.compact
+      unless view.assigned?(:toolbar_actions)
+        return [action_descriptor_generator.generate(Habarico::DefaultActionsReference.new, context)].compact
       end
-      nil
+      return nil if view.toolbar_actions.nil?
+
+      view.toolbar_actions.map do |action|
+        action_descriptor_generator.generate(action, context)
+      end.compact
     end
 
     def generate_bottom_actions(view, context)