iron_admin 0.4.1 → 0.6.0

data/app/helpers/iron_admin/field_display_helper.rb

@@ -6,6 +6,27 @@ module IronAdmin
   module FieldDisplayHelper # rubocop:disable Metrics/ModuleLength
     private
 
+    def display_hidden(_record, _field)
+      nil
+    end
+
+    def display_radio(record, field)
+      value = record.public_send(field.name)
+      return if value.blank?
+
+      content_tag(:span, value.to_s.humanize, class: "text-sm #{cp_body_text}")
+    end
+
+    def display_code(record, field)
+      value = record.public_send(field.name)
+      return if value.blank?
+
+      lang = field.options[:language].presence || ""
+      content_tag(:pre, class: "overflow-x-auto rounded-lg bg-gray-900 p-4 text-sm") do
+        content_tag(:code, value, class: "text-gray-100 font-mono language-#{lang}")
+      end
+    end
+
     def display_belongs_to(record, field)
       associated = record.public_send(field.name)
       return if associated.nil?
@@ -190,7 +211,12 @@ module IronAdmin
       return if type_value.blank? || id_value.blank?
 
       begin
-        associated = type_value.constantize.find_by(id: id_value)
+        associated_resource = IronAdmin::ResourceRegistry.find(type_value.constantize.model_name.plural)
+        associated = if associated_resource
+                       associated_resource.adapter.find_by(id: id_value)
+                     else
+                       type_value.constantize.find_by(id: id_value)
+                     end
         return "#{type_value}##{id_value}" unless associated
 
         resource = IronAdmin::ResourceRegistry.find(associated.class.model_name.plural)
@@ -209,5 +235,138 @@ module IronAdmin
         "#{type_value}##{id_value}"
       end
     end
+
+    def display_key_value(record, field)
+      value = record.public_send(field.name)
+      return if value.blank?
+
+      pairs = parse_hash_value(value)
+      return if pairs.empty?
+
+      content_tag(:dl, class: "divide-y divide-gray-100 rounded border border-gray-200 text-sm") do
+        safe_join(pairs.map { |k, v| key_value_pair_row(k, v) })
+      end
+    end
+
+    def key_value_pair_row(key, value)
+      content_tag(:div, class: "flex gap-4 px-3 py-2") do
+        content_tag(:dt, key, class: "font-medium w-1/3 #{cp_body_text}") +
+          content_tag(:dd, value.to_s, class: "flex-1 #{cp_muted_text}")
+      end
+    end
+
+    def display_boolean_group(record, field)
+      values = parse_array_value(record.public_send(field.name))
+      return if values.empty?
+
+      safe_join(values.map { |v| boolean_group_pill(v) })
+    end
+
+    def boolean_group_pill(value)
+      content_tag(
+        :span,
+        value.to_s.humanize,
+        class: "inline-block px-2 py-0.5 text-xs font-medium rounded-full bg-indigo-50 text-indigo-700 mr-1 mb-1"
+      )
+    end
+
+    def display_external_image(record, field)
+      url = record.public_send(field.name)
+      return if url.blank?
+      return if url.to_s.match?(/\Ajavascript:/i)
+
+      height = field.options[:height] || "h-32"
+      tag.img(
+        src: url,
+        alt: "",
+        class: "#{height} w-auto object-cover rounded border border-gray-200",
+        loading: "lazy",
+        onerror: "this.style.display='none'"
+      )
+    end
+
+    def display_progress_bar(record, field)
+      value = record.public_send(field.name)
+      return if value.nil?
+
+      pct = calculate_progress_percentage(value, field)
+      color = field.options[:color] || "bg-indigo-600"
+
+      content_tag(:div, class: "flex items-center gap-2") do
+        progress_bar_track(pct, color) +
+          content_tag(:span, "#{value.to_i}%", class: "text-xs tabular-nums #{cp_muted_text}")
+      end
+    end
+
+    def display_truncated_index_value(record, field)
+      value = record.public_send(field.name)
+      return if value.blank?
+
+      truncated = truncate(value.to_s, length: ApplicationHelper::INDEX_TRUNCATION_LENGTH)
+      if value.to_s.length > ApplicationHelper::INDEX_TRUNCATION_LENGTH
+        content_tag(:span, truncated, title: value.to_s)
+      else
+        truncated
+      end
+    end
+
+    def display_compact_field_value(record, field)
+      case field.type
+      when :key_value
+        pairs = parse_hash_value(record.public_send(field.name))
+        content_tag(:span, "#{pairs.size} keys", class: "text-xs #{cp_muted_text}")
+      when :boolean_group
+        items = parse_array_value(record.public_send(field.name))
+        content_tag(:span, "#{items.size} selected", class: "text-xs #{cp_muted_text}")
+      end
+    end
+
+    def parse_hash_value(value)
+      return value if value.is_a?(Hash)
+      return {} if value.nil?
+
+      safe_json_parse_hash(value.to_s)
+    end
+
+    def safe_json_parse_hash(value)
+      result = JSON.parse(value)
+      result.is_a?(Hash) ? result : {}
+    rescue JSON::ParserError
+      {}
+    end
+
+    def parse_array_value(value)
+      case value
+      when Array then value
+      when String then parse_array_string(value)
+      else []
+      end
+    end
+
+    def parse_array_string(value)
+      parsed = safe_json_parse_array(value)
+      return parsed if parsed
+
+      value.split(",").map(&:strip).compact_blank
+    end
+
+    def safe_json_parse_array(value)
+      result = JSON.parse(value)
+      result.is_a?(Array) ? result : nil
+    rescue JSON::ParserError
+      nil
+    end
+
+    def calculate_progress_percentage(value, field)
+      min = (field.options[:min] || 0).to_f
+      max = (field.options[:max] || 100).to_f
+      ((value.to_f - min) / (max - min) * 100.0).clamp(0.0, 100.0)
+    end
+
+    def progress_bar_track(pct, color)
+      content_tag(:div, class: "flex-1 h-2 rounded-full bg-gray-200 overflow-hidden") do
+        content_tag(:div, "", class: "h-2 rounded-full #{color}", style: "width: #{pct.round(1)}%")
+      end
+    end
   end
 end

data/app/javascript/iron_admin/controllers/cp_nested_form_controller.js

@@ -0,0 +1,113 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["rowsContainer", "row", "destroyField", "positionField", "dragHandle"]
+  static values = {
+    associationName: String,
+    allowDestroy: Boolean,
+    sortable: Boolean
+  }
+
+  connect() {
+    if (this.sortableValue) this.initSortable()
+  }
+
+  addRow(event) {
+    event.preventDefault()
+    const template = document.getElementById(`${this.associationNameValue}-nested-template`)
+    if (!template) return
+
+    const timestamp = new Date().getTime()
+    const clone = template.content.cloneNode(true)
+
+    clone.querySelectorAll("[name], [id], [for]").forEach((el) => {
+      if (el.name) el.name = el.name.replace(/NEW_RECORD_INDEX/g, timestamp)
+      if (el.id) el.id = el.id.replace(/NEW_RECORD_INDEX/g, timestamp)
+      if (el.htmlFor) el.htmlFor = el.htmlFor.replace(/NEW_RECORD_INDEX/g, timestamp)
+    })
+
+    this.rowsContainerTarget.appendChild(clone)
+    if (this.sortableValue) this.updatePositions()
+  }
+
+  removeRow(event) {
+    event.preventDefault()
+    const row = event.target.closest("[data-cp-nested-form-target='row']")
+    if (!row) return
+
+    const idField = row.querySelector("input[name$='[id]']")
+    if (idField && idField.value) {
+      const destroyField = row.querySelector("[data-cp-nested-form-target='destroyField']")
+      if (destroyField) destroyField.value = "1"
+      row.style.display = "none"
+    } else {
+      row.remove()
+    }
+    if (this.sortableValue) this.updatePositions()
+  }
+
+  updatePositions() {
+    this.rowTargets
+      .filter((row) => row.style.display !== "none")
+      .forEach((row, index) => {
+        const posField = row.querySelector("[data-cp-nested-form-target='positionField']")
+        if (posField) posField.value = index + 1
+      })
+  }
+
+  initSortable() {
+    this.rowTargets.forEach((row) => this.makeDraggable(row))
+
+    const observer = new MutationObserver((mutations) => {
+      mutations.forEach((mutation) => {
+        mutation.addedNodes.forEach((node) => {
+          if (node.nodeType === 1 && node.dataset.cpNestedFormTarget === "row") {
+            this.makeDraggable(node)
+          }
+        })
+      })
+    })
+    observer.observe(this.rowsContainerTarget, { childList: true })
+  }
+
+  makeDraggable(row) {
+    const handle = row.querySelector("[data-cp-nested-form-target='dragHandle']")
+    if (!handle) return
+
+    row.setAttribute("draggable", "true")
+
+    row.addEventListener("dragstart", (e) => {
+      e.dataTransfer.effectAllowed = "move"
+      e.dataTransfer.setData("text/plain", "")
+      row.classList.add("opacity-50")
+      this.draggedRow = row
+    })
+
+    row.addEventListener("dragend", () => {
+      row.classList.remove("opacity-50")
+      this.draggedRow = null
+      this.updatePositions()
+    })
+
+    row.addEventListener("dragover", (e) => {
+      e.preventDefault()
+      e.dataTransfer.dropEffect = "move"
+    })
+
+    row.addEventListener("drop", (e) => {
+      e.preventDefault()
+      if (this.draggedRow && this.draggedRow !== row) {
+        const container = this.rowsContainerTarget
+        const children = Array.from(container.children)
+        const draggedIndex = children.indexOf(this.draggedRow)
+        const targetIndex = children.indexOf(row)
+
+        if (draggedIndex < targetIndex) {
+          container.insertBefore(this.draggedRow, row.nextSibling)
+        } else {
+          container.insertBefore(this.draggedRow, row)
+        }
+      }
+    })
+  }
+}

data/app/javascript/iron_admin/controllers/filter_operator_controller.js

@@ -0,0 +1,10 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["opSelect", "betweenRow"]
+
+  toggle() {
+    const isBetween = this.opSelectTarget.value === "between"
+    this.betweenRowTarget.classList.toggle("hidden", !isBetween)
+  }
+}

data/app/javascript/iron_admin/index.js

@@ -1,6 +1,10 @@
 import CpBulkSelectController from "iron_admin/controllers/cp_bulk_select_controller"
 import CpChartController from "iron_admin/controllers/cp_chart_controller"
+import CpNestedFormController from "iron_admin/controllers/cp_nested_form_controller"
+import FilterOperatorController from "iron_admin/controllers/filter_operator_controller"
 
 const application = window.Stimulus
 application.register("cp-bulk-select", CpBulkSelectController)
 application.register("cp-chart", CpChartController)
+application.register("cp-nested-form", CpNestedFormController)
+application.register("filter-operator", FilterOperatorController)

data/app/views/iron_admin/dashboard/index.html.haml

@@ -5,7 +5,7 @@
     - if @dashboard.defined_metrics.any?
       .grid.grid-cols-1.md:grid-cols-2.lg:grid-cols-4.gap-6.mb-8
         - @dashboard.defined_metrics.each do |metric|
-          = render IronAdmin::Dashboards::MetricCardComponent.new(name: metric[:name], value: metric[:block].call, format: metric[:format])
+          = render IronAdmin::Dashboards::MetricCardComponent.new(name: metric[:name], value: metric[:block].call, format: metric[:format], icon: metric[:icon], live: metric[:live])
 
     - if @dashboard.defined_charts.any?
       = javascript_include_tag "chart.min", defer: true, onload: "document.dispatchEvent(new CustomEvent('chartjs:loaded'))"
@@ -14,7 +14,12 @@
           - chart_data = chart[:block].call
           - labels = chart_data.keys
           - data = chart_data.values
-          = render IronAdmin::Dashboards::ChartComponent.new(title: chart[:name].to_s.humanize, type: chart[:type], data: data, labels: labels, colors: chart[:colors])
+          - chart_title = chart[:label] || chart[:name].to_s.humanize
+          - if chart[:live]
+            %div{ id: "chart_#{chart[:name].to_s.parameterize(separator: "_")}" }
+              = render IronAdmin::Dashboards::ChartComponent.new(title: chart_title, type: chart[:type], data: data, labels: labels, colors: chart[:colors])
+          - else
+            = render IronAdmin::Dashboards::ChartComponent.new(title: chart_title, type: chart[:type], data: data, labels: labels, colors: chart[:colors])
 
     - if @dashboard.defined_recents.any?
       .space-y-6

data/app/views/iron_admin/form/_nested_row.html.haml

@@ -0,0 +1,70 @@
+- t = IronAdmin.configuration.theme
+
+%div.relative.border.rounded-lg.p-4.mb-3{ class: "#{t.card_border} #{t.card_bg}", data: { "cp-nested-form-target": "row" } }
+
+  -# Drag handle (only when sortable)
+  - if nested_association.position_field
+    .absolute.top-2.left-2.cursor-grab.text-gray-400{ data: { "cp-nested-form-target": "dragHandle" } }
+      = heroicon "bars-3", variant: :mini, options: { class: "h-5 w-5" }
+    = child_f.hidden_field nested_association.position_field, data: { "cp-nested-form-target": "positionField" }
+
+  -# Remove button (only when allow_destroy)
+  - if nested_association.allow_destroy
+    .absolute.top-2.right-2
+      %button.text-gray-400.transition.cursor-pointer{ type: "button", class: "hover:text-red-500", aria: { label: I18n.t("iron_admin.nested_form.remove_button", default: "Remove") }, data: { action: "cp-nested-form#removeRow" } }
+        = heroicon "x-mark", variant: :mini, options: { class: "h-5 w-5" }
+    = child_f.hidden_field :_destroy, value: "0", data: { "cp-nested-form-target": "destroyField" }
+
+  -# Hidden id field for persisted records
+  - if child.persisted?
+    = child_f.hidden_field :id
+
+  -# Field grid
+  %div{ class: "grid grid-cols-1 md:grid-cols-2 gap-x-4 gap-y-3 #{nested_association.position_field ? 'pl-6' : ''}" }
+    - nested_association.fields.each do |field|
+      - next unless field.visible?(current_user)
+      - next if field.readonly?(current_user)
+      - has_error = child.errors[field.name].any?
+      - input_class = "block w-full px-3 py-2 text-sm border #{t.input_border} #{t.border_radius} shadow-sm outline-none transition duration-150 ease-in-out #{t.input_focus}"
+      - input_class += " !border-red-400" if has_error
+      %div
+        %label.block.text-xs.font-medium.text-gray-500.mb-1
+          = field.name.to_s.humanize
+        - case field.type
+        - when :belongs_to
+          - fk = field.options[:foreign_key]
+          - assoc_class = field.options[:association_class]
+          - if assoc_class
+            = child_f.select fk, options_from_collection_for_select(assoc_class.all, :id, :name, child.public_send(fk)), { include_blank: true }, class: input_class
+          - else
+            = child_f.number_field fk, placeholder: field.name.to_s.humanize, class: input_class
+        - when :textarea
+          = child_f.text_area field.name, rows: 2, class: input_class
+        - when :json
+          - raw_json_value = child.public_send(field.name)
+          - json_str = raw_json_value.nil? ? "" : JSON.pretty_generate(raw_json_value)
+          = child_f.text_area field.name, value: json_str, rows: field.options[:rows] || 4,
+            placeholder: "{}", class: "#{input_class} font-mono"
+        - when :number
+          = child_f.number_field field.name, class: input_class
+        - when :boolean
+          .flex.items-center.gap-2
+            = child_f.check_box field.name, class: "rounded border-gray-300"
+        - when :datetime, :date
+          = child_f.datetime_local_field field.name, class: input_class
+        - when :select, :badge
+          - choices = []
+          - if field.type == :badge
+            - colors = field.options[:colors]
+            - if colors
+              - choices = colors.keys.map { |c| [c.to_s.humanize, c] }
+            - elsif child.class.respond_to?(:defined_enums)
+              - choices = child.class.defined_enums[field.name.to_s]&.keys&.map { |c| [c.humanize, c] } || []
+          - elsif field.options[:choices]
+            - choices = field.options[:choices].map { |c| [c.humanize, c] }
+          = child_f.select field.name, choices, { include_blank: true }, class: input_class
+        - else
+          = child_f.text_field field.name, placeholder: field.name.to_s.humanize, class: input_class
+
+        - if has_error
+          %p.text-xs.text-red-600.mt-1= child.errors[field.name].join(", ")

data/app/views/iron_admin/imports/new.html.haml

@@ -0,0 +1,27 @@
+.p-8.max-w-3xl.mx-auto{ class: t.font_family }
+  .mb-6
+    %h1.text-2xl{ class: cp_heading }= I18n.t("iron_admin.imports.new.title", model: @resource_class.label)
+    %p.mt-1.text-sm{ class: cp_muted_text }= I18n.t("iron_admin.imports.new.subtitle")
+
+  .border.p-6{ class: "#{t.card_border} #{t.card_bg} #{t.border_radius} #{t.card_shadow}" }
+    = form_tag resource_import_preview_path(@resource_class.resource_name), multipart: true, class: "space-y-5" do
+      .space-y-2
+        %label.block.text-sm.font-medium{ class: cp_label_text }= I18n.t("iron_admin.imports.new.file_label")
+        = file_field_tag :file, required: true, class: "block w-full text-sm #{cp_body_text}"
+      .space-y-2
+        %label.block.text-sm.font-medium{ class: cp_label_text }= I18n.t("iron_admin.imports.new.format_label")
+        = select_tag :import_format,
+          options_for_select(@formats.map { |format| [format.to_s.upcase, format] }),
+          class: "block w-full border px-3 py-2 text-sm #{t.border_radius} #{t.input_border} #{t.card_bg} #{cp_body_text} #{cp_focus}"
+      - if @fields.any?
+        .space-y-2
+          %p.text-sm.font-medium{ class: cp_label_text }= I18n.t("iron_admin.imports.new.fields_label")
+          .flex.flex-wrap.gap-2
+            - @fields.each do |field|
+              %span.inline-flex.items-center.rounded-md.bg-gray-100.px-2.py-1.text-xs.font-medium{ class: cp_muted_text }
+                = field.name.to_s.humanize
+      .flex.items-center.gap-3.pt-2
+        %button{ type: "submit", class: cp_btn_primary }
+          = heroicon "eye", variant: :mini, options: { class: "h-4 w-4" }
+          %span= I18n.t("iron_admin.imports.new.preview_button")
+        = link_to I18n.t("iron_admin.form.cancel_button"), resources_path(@resource_class.resource_name), class: cp_btn_secondary

data/app/views/iron_admin/imports/preview.html.haml

@@ -0,0 +1,31 @@
+.p-8.max-w-5xl.mx-auto{ class: t.font_family }
+  .flex.items-center.justify-between.mb-6
+    %div
+      %h1.text-2xl{ class: cp_heading }= I18n.t("iron_admin.imports.preview.title", model: @resource_class.label)
+      %p.mt-1.text-sm{ class: cp_muted_text }= I18n.t("iron_admin.imports.preview.summary", count: @preview.total_rows)
+    = link_to I18n.t("iron_admin.imports.preview.back_button"), resource_import_path(@resource_class.resource_name), class: cp_btn_secondary
+
+  .mb-6.border.p-4{ class: "#{t.card_border} #{t.card_bg} #{t.border_radius}" }
+    %h2.text-sm.font-semibold.mb-3{ class: cp_label_text }= I18n.t("iron_admin.imports.preview.mapping_title")
+    .flex.flex-wrap.gap-2
+      - @preview.mapping.each do |header, field_name|
+        %span.inline-flex.items-center.rounded-md.bg-gray-100.px-2.py-1.text-xs.font-medium{ class: cp_muted_text }
+          = "#{header} -> #{field_name.to_s.humanize}"
+
+  .overflow-x-auto
+    %table.min-w-full{ class: "#{cp_table_border} divide-y #{t.card_bg} #{t.border_radius} #{t.card_shadow}" }
+      %thead{ class: cp_table_header_bg }
+        %tr
+          - @preview.mapping.values.each do |field_name|
+            %th.px-6.py-3.text-left.text-xs.font-medium.uppercase.tracking-wider{ class: cp_muted_text }= field_name.to_s.humanize
+          %th.px-6.py-3.text-left.text-xs.font-medium.uppercase.tracking-wider{ class: cp_muted_text }= I18n.t("iron_admin.imports.preview.status_column")
+      %tbody{ class: "#{cp_table_border} divide-y" }
+        - @preview.rows.each do |row|
+          %tr
+            - @preview.mapping.values.each do |field_name|
+              %td.px-6.py-4.whitespace-nowrap.text-sm{ class: cp_body_text }= row.attributes[field_name].inspect
+            %td.px-6.py-4.text-sm{ class: row.errors.any? ? "text-red-600" : cp_muted_text }
+              - if row.errors.any?
+                = row.errors.map(&:message).join(", ")
+              - else
+                = I18n.t("iron_admin.imports.preview.valid_status")

data/app/views/iron_admin/resources/_form.html.haml

@@ -3,9 +3,12 @@
 = form_with model: @record, url: form_url, scope: :record, html: { multipart: true } do |f|
   .grid.grid-cols-1.md:grid-cols-2.2xl:grid-cols-3.gap-x-6.gap-y-5
     - @fields.each do |field|
+      - if field.type == :hidden
+        = f.hidden_field field.name
+        - next
       - next unless field.visible?(iron_admin_current_user)
       - next if field.readonly?(iron_admin_current_user)
-      - span_full = field.type.in?(%i[textarea json file files rich_text tags markdown])
+      - span_full = field.type.in?(%i[textarea json file files rich_text tags markdown code key_value boolean_group])
       - has_error = @record.errors[field.name].any?
       %div{ class: span_full ? "md:col-span-2 2xl:col-span-3" : nil }
         = f.label field.name, field.name.to_s.humanize,
@@ -15,10 +18,21 @@
           - assoc_class = field.options[:association_class]
           - fk = field.options[:foreign_key]
           - display_method = field.options[:display]
-          = f.select fk,
-            options_from_collection_for_select(assoc_class.all, :id, (display_method || :name), @record.public_send(fk)),
-            { include_blank: I18n.t("iron_admin.fields.select_placeholder") },
-            class: [cp_select_class, (error_input_class if has_error)].compact.join(" ")
+          - association_resource = association_resource_for(field, assoc_class)
+          - if field.options[:autocomplete]
+            - selected_record = @record.public_send(field.name) if @record.respond_to?(field.name)
+            - autocomplete_resource_name = association_resource&.resource_name || assoc_class.model_name.route_key
+            - autocomplete_component = IronAdmin::Form::BelongsToAutocompleteComponent.new(name: "record[#{fk}]", resource_name: autocomplete_resource_name, selected_id: @record.public_send(fk), selected_label: selected_record ? display_record_label(selected_record, display_method) : nil, has_error: has_error)
+            = render autocomplete_component
+          - else
+            - belongs_to_scope = assoc_class.all
+            - tenant_scope = IronAdmin.configuration.tenant_scope_block
+            - belongs_to_scope = tenant_scope.call(belongs_to_scope) if tenant_scope
+            - belongs_to_options = belongs_to_scope.map { |r| [display_record_label(r, display_method), r.id] }
+            = f.select fk,
+              options_for_select(belongs_to_options, @record.public_send(fk)),
+              { include_blank: I18n.t("iron_admin.fields.select_placeholder") },
+              class: [cp_select_class, (error_input_class if has_error)].compact.join(" ")
         - when :text
           = f.text_field field.name, placeholder: field.name.to_s.humanize,
             class: [cp_input_class, (error_input_class if has_error)].compact.join(" ")
@@ -180,6 +194,64 @@
                 btn.addEventListener("click", function() { btn.closest("[data-tag]").remove(); updateHidden(); });
               });
             })();
+        - when :key_value
+          = f.text_area field.name, rows: field.options[:rows] || 6,
+            placeholder: '{"key": "value"}',
+            class: ["font-mono text-sm", cp_textarea_class, (error_input_class if has_error)].compact.join(" ")
+        - when :json
+          - raw_json_value = @record.public_send(field.name)
+          - json_str = raw_json_value.nil? ? "" : JSON.pretty_generate(raw_json_value)
+          = text_area_tag "record[#{field.name}]", json_str,
+            id: "record_#{field.name}", rows: field.options[:rows] || 8, placeholder: "{}",
+            class: ["font-mono text-sm", cp_textarea_class, (error_input_class if has_error)].compact.join(" ")
+        - when :boolean_group
+          - choices = field.options[:choices] || []
+          - current_values = @record.public_send(field.name).to_s.split(",").map(&:strip)
+          - container_id = "boolean-group-#{field.name}"
+          %div{ id: container_id, data: { boolean_group_field: true } }
+            = f.hidden_field field.name, value: current_values.join(","), id: "boolean-group-hidden-#{field.name}"
+            .flex.flex-wrap.gap-3
+              - choices.each do |choice|
+                - label_text, choice_value = choice.is_a?(Array) ? choice : [choice.to_s.humanize, choice]
+                %label.inline-flex.items-center.gap-2.cursor-pointer
+                  %input{ type: "checkbox", value: choice_value,
+                          checked: current_values.include?(choice_value.to_s),
+                          class: cp_checkbox_class,
+                          data: { boolean_group_checkbox: true } }
+                  %span.text-sm= label_text
+            :javascript
+              (function() {
+                var container = document.getElementById("#{container_id}");
+                var hidden = document.getElementById("boolean-group-hidden-#{field.name}");
+                var checkboxes = container.querySelectorAll("[data-boolean-group-checkbox]");
+                function update() {
+                  var vals = [];
+                  checkboxes.forEach(function(cb) { if (cb.checked) vals.push(cb.value); });
+                  hidden.value = vals.join(",");
+                }
+                checkboxes.forEach(function(cb) { cb.addEventListener("change", update); });
+              })();
+        - when :external_image
+          = f.url_field field.name, placeholder: I18n.t("iron_admin.fields.url_placeholder"),
+            class: [cp_input_class, (error_input_class if has_error)].compact.join(" ")
+        - when :progress_bar
+          = f.number_field field.name, min: field.options[:min] || 0, max: field.options[:max] || 100,
+            placeholder: "0",
+            class: [cp_input_class, (error_input_class if has_error)].compact.join(" ")
+        - when :code
+          = f.text_area field.name, rows: field.options[:rows] || 10,
+            class: ["font-mono text-sm", cp_textarea_class, (error_input_class if has_error)].compact.join(" ")
+        - when :radio
+          - layout = field.options[:layout] == :vertical ? "flex-col space-y-2" : "flex flex-wrap gap-4"
+          - choices = field.options[:choices] || []
+          .flex{ class: layout }
+            - choices.each do |choice|
+              - label_text, choice_value = choice.is_a?(Array) ? choice : [choice.to_s.humanize, choice]
+              %label.inline-flex.items-center.gap-2.cursor-pointer
+                %input{ type: "radio", name: "record[#{field.name}]",
+                        value: choice_value,
+                        checked: @record.public_send(field.name).to_s == choice_value.to_s }
+                %span.text-sm= label_text
         - else
           - custom_config = IronAdmin::FieldTypeRegistry.find(field.type) if IronAdmin::FieldTypeRegistry.registered?(field.type)
           - if custom_config&.form_component_class
@@ -206,6 +278,10 @@
             = check_box_tag "record[#{assoc[:name].to_s.singularize}_ids][]", option.id, selected_ids.include?(option.id), class: cp_checkbox_class
             %span.text-sm{ class: cp_body_text }= display_record_label(option, assoc[:display])
 
+  - @resource_class.nested_associations.each do |nested_assoc|
+    .mt-6
+      = render IronAdmin::Form::NestedFormComponent.new(form: f, nested_association: nested_assoc, record: @record, current_user: iron_admin_current_user)
+
   .flex.items-center.gap-3.mt-8.pt-6.border-t{ class: t.card_border }
     = f.submit class: cp_btn_primary_lg
     = link_to I18n.t("iron_admin.form.cancel_button"), resources_path(@resource_class.resource_name),

data/app/views/iron_admin/resources/action_form.html.haml

@@ -0,0 +1,62 @@
+= turbo_frame_tag "action-form-modal" do
+  .p-8.max-w-lg.mx-auto{ class: t.font_family }
+    %h2.text-xl.mb-6{ class: cp_heading }= @action[:name].to_s.humanize
+
+    = form_tag @form_url, method: :post, class: "space-y-4" do
+      - @form_fields.each do |field|
+        .space-y-1
+          %label.block.text-sm.font-medium{ class: cp_label_text, for: "action_form_#{field.name}" }
+            = field.label
+            - if field.required
+              %span.text-red-500 *
+
+          - case field.type
+          - when :text
+            = text_field_tag "action_form[#{field.name}]", field.default,
+              id: "action_form_#{field.name}",
+              class: cp_filter_input_class,
+              placeholder: field.placeholder,
+              required: field.required
+          - when :textarea
+            = text_area_tag "action_form[#{field.name}]", field.default,
+              id: "action_form_#{field.name}",
+              class: "#{cp_filter_input_class} h-24",
+              placeholder: field.placeholder,
+              required: field.required
+          - when :number
+            = number_field_tag "action_form[#{field.name}]", field.default,
+              id: "action_form_#{field.name}",
+              class: cp_filter_input_class,
+              placeholder: field.placeholder,
+              step: "any",
+              required: field.required
+          - when :boolean
+            .flex.items-center.gap-2
+              = check_box_tag "action_form[#{field.name}]", "1", field.default,
+                id: "action_form_#{field.name}",
+                class: "rounded border-gray-300"
+              %span.text-sm{ class: cp_body_text }= field.label
+          - when :date
+            = date_field_tag "action_form[#{field.name}]", field.default,
+              id: "action_form_#{field.name}",
+              class: cp_filter_input_class,
+              required: field.required
+          - when :datetime
+            = datetime_field_tag "action_form[#{field.name}]", field.default,
+              id: "action_form_#{field.name}",
+              class: cp_filter_input_class,
+              required: field.required
+          - when :select
+            %select{ name: "action_form[#{field.name}]", id: "action_form_#{field.name}",
+              class: cp_filter_input_class, required: field.required }
+              %option{ value: "" }= field.placeholder || "Select..."
+              - (field.options || []).each do |opt|
+                %option{ value: opt, selected: field.default == opt }= opt.to_s.humanize
+
+      - if params[:ids].present?
+        - Array(params[:ids]).each do |id|
+          = hidden_field_tag "ids[]", id
+
+      .flex.items-center.gap-3.pt-3.border-t.border-gray-100
+        %button{ type: "submit", class: cp_btn_primary }= I18n.t("iron_admin.resources.action_form.submit", default: "Execute")
+        = link_to I18n.t("iron_admin.form.cancel_button"), "javascript:history.back()", class: "text-sm #{cp_link_muted}"