iron_admin 0.4.1 → 0.6.0

data/app/controllers/iron_admin/resources_controller.rb

@@ -20,6 +20,11 @@ module IronAdmin
   #
   # @see IronAdmin::Resource
   class ResourcesController < ApplicationController
+    include Concerns::ActionExecutable
+    include Concerns::Filterable
+    include Concerns::JsonParamsCoercion
+    include Concerns::NestedPermittable
+    include Concerns::Scopeable
     include Concerns::Searchable
 
     before_action :set_resource_class
@@ -29,12 +34,7 @@ module IronAdmin
     #
     # @return [void]
     def index
-      scope = apply_scopes(apply_filters(base_scope))
-      scope = apply_search(scope)
-      scope = apply_sorting(scope)
-      scope = apply_preloading(scope)
-
-      @pagy, @records = pagy(scope, limit: IronAdmin.configuration.per_page)
+      @pagy, @records = pagy(collection_scope, limit: IronAdmin.configuration.per_page)
       @fields = index_fields
       @current_scope = current_scope_name
     end
@@ -42,9 +42,9 @@ module IronAdmin
     # Shows a single record.
     #
     # @return [void]
-    # @raise [ActiveRecord::RecordNotFound] if record doesn't exist
+    # @raise [IronAdmin::RecordNotFound] if record doesn't exist
     def show
-      @record = record_scope.find(params[:id])
+      @record = find_record(record_scope, params[:id])
       @fields = @resource_class.resolved_fields
     end
 
@@ -52,16 +52,16 @@ module IronAdmin
     #
     # @return [void]
     def new
-      @record = @resource_class.model.new
+      @record = adapter.build
       @fields = form_fields
     end
 
     # Renders the edit form for an existing record.
     #
     # @return [void]
-    # @raise [ActiveRecord::RecordNotFound] if record doesn't exist
+    # @raise [IronAdmin::RecordNotFound] if record doesn't exist
     def edit
-      @record = record_scope.find(params[:id])
+      @record = find_record(record_scope, params[:id])
       @fields = form_fields
     end
 
@@ -69,12 +69,12 @@ module IronAdmin
     #
     # @return [void]
     def create
-      @record = @resource_class.model.new(resource_params)
+      @record = adapter.build(resource_params)
 
-      if @record.save
+      if adapter.save(@record)
         emit_event(:create, @record)
         redirect_to resource_path(@resource_class.resource_name, @record),
-                    notice: I18n.t("iron_admin.resources.create.success", model: @resource_class.model.model_name.human)
+                    notice: I18n.t("iron_admin.resources.create.success", model: adapter.human_name)
       else
         @fields = form_fields
         render :new, status: :unprocessable_content
@@ -84,15 +84,15 @@ module IronAdmin
     # Updates an existing record.
     #
     # @return [void]
-    # @raise [ActiveRecord::RecordNotFound] if record doesn't exist
+    # @raise [IronAdmin::RecordNotFound] if record doesn't exist
     def update
-      @record = record_scope.find(params[:id])
+      @record = find_record(record_scope, params[:id])
       purge_attachments(@record)
 
-      if @record.update(resource_params)
+      if adapter.update(@record, resource_params)
         emit_event(:update, @record)
         redirect_to resource_path(@resource_class.resource_name, @record),
-                    notice: I18n.t("iron_admin.resources.update.success", model: @resource_class.model.model_name.human)
+                    notice: I18n.t("iron_admin.resources.update.success", model: adapter.human_name)
       else
         @fields = form_fields
         render :edit, status: :unprocessable_content
@@ -102,34 +102,63 @@ module IronAdmin
     # Deletes a record.
     #
     # @return [void]
-    # @raise [ActiveRecord::RecordNotFound] if record doesn't exist
+    # @raise [IronAdmin::RecordNotFound] if record doesn't exist
     def destroy
-      @record = record_scope.find(params[:id])
-      @record.destroy!
+      @record = find_record(record_scope, params[:id])
+      adapter.destroy!(@record)
       emit_event(:destroy, @record)
       redirect_to resources_path(@resource_class.resource_name),
-                  notice: I18n.t("iron_admin.resources.destroy.success", model: @resource_class.model.model_name.human)
+                  notice: I18n.t("iron_admin.resources.destroy.success", model: adapter.human_name)
     end
 
-    # Executes a custom action on a single record.
+    # Renders the action form for a single record action with form_fields.
     #
     # @return [void]
-    def execute_action
-      action = @resource_class.defined_actions.find { |a| a[:name].to_s == params[:action_name] }
+    def action_form
+      @action = find_single_record_action
+      return unless @action
+
+      return unless prepare_action_record?(@action)
+
+      @form_fields = @action[:form_fields]
+      @form_url = resource_action_path(@resource_class.resource_name, @record, @action[:name])
+    end
+
+    # Renders the action form for a bulk action with form_fields.
+    #
+    # @return [void]
+    def bulk_action_form
+      action = find_bulk_action
       return head(:not_found) unless action
       return head(:forbidden) unless action_authorized?(action[:name])
 
-      @record = record_scope.find(params[:id])
+      @action = action
+      @form_fields = action[:form_fields]
+      @form_url = resource_bulk_action_path(@resource_class.resource_name, action[:name])
+    end
+
+    # Executes a custom action on a single record.
+    #
+    # @return [void]
+    def execute_action
+      action = find_single_record_action
+      return unless action
+
+      return unless prepare_action_record?(action)
 
-      ActiveRecord::Base.transaction do
-        result = action[:block].call(@record)
-        emit_event(params[:action_name], @record)
-        raise ActiveRecord::Rollback if result == false
+      collected = action_form_params(action)
+
+      adapter.transaction do
+        adapter.wrap_rollback do
+          result = call_action_block(action[:block], @record, collected)
+          emit_event(params[:action_name], @record)
+          raise IronAdmin::Rollback if result == false
+        end
       end
 
       redirect_to resource_path(@resource_class.resource_name, @record),
                   notice: I18n.t("iron_admin.resources.action.success")
-    rescue ActiveRecord::RecordNotFound
+    rescue IronAdmin::RecordNotFound
       head(:not_found)
     rescue StandardError => e
       redirect_to resources_path(@resource_class.resource_name),
@@ -146,7 +175,7 @@ module IronAdmin
       ids = bulk_action_ids
       return redirect_bulk(:alert, I18n.t("iron_admin.resources.bulk_action.no_records")) if ids.empty?
 
-      records = base_scope.where(id: ids)
+      records = adapter.filter(base_scope, :id, ids)
       action = find_bulk_action
 
       return head(:not_found) unless action
@@ -169,31 +198,20 @@ module IronAdmin
       return render json: [] if query.blank?
 
       display = @resource_class.display_attribute
-      conn = @resource_class.model.connection
-      table = conn.quote_table_name(@resource_class.model.table_name)
-      column = conn.quote_column_name(display)
-      like_operator = conn.adapter_name.downcase.include?("postgresql") ? "ILIKE" : "LIKE"
+      display = searchable_display_attribute unless adapter.has_column?(display)
+      return render json: [] unless display
 
-      records = base_scope
-        .where("#{table}.#{column} #{like_operator} ?", "%#{query}%")
-        .limit(20)
-        .map { |r| { id: r.id, label: r.public_send(display) } }
+      scope = adapter.search_column(base_scope, display, query)
+      records = adapter.limit(scope, 20)
+        .map { |record| { id: record.to_param.to_s, label: record.public_send(display).to_s } }
 
       render json: records
     end
 
     private
 
-    def base_scope
-      scope = @resource_class.model.all
-      scope = IronAdmin.configuration.tenant_scope_block.call(scope) if IronAdmin.configuration.tenant_scope_block
-      scope
-    end
-
-    def record_scope
-      scope = base_scope
-      scope = scope.unscope(where: @resource_class.soft_delete_column.to_sym) if @resource_class.soft_delete?
-      scope
+    def adapter
+      @resource_class.adapter
     end
 
     def set_resource_class
@@ -229,7 +247,21 @@ module IronAdmin
     end
 
     def bulk_action_ids
-      Array(params[:ids]).map(&:to_i).reject(&:zero?)
+      Array(params[:ids]).compact_blank
+    end
+
+    def find_single_record_action
+      action = @resource_class.defined_actions.find { |defined| defined[:name].to_s == params[:action_name] }
+      unless action
+        head(:not_found)
+        return nil
+      end
+      unless action_authorized?(action[:name])
+        head(:forbidden)
+        return nil
+      end
+
+      action
     end
 
     def find_bulk_action
@@ -245,12 +277,34 @@ module IronAdmin
     end
 
     def run_bulk_action_in_transaction(action, records)
-      ActiveRecord::Base.transaction do
-        result = action[:block].call(records)
-        raise ActiveRecord::Rollback if result == false
+      collected = action_form_params(action)
+      adapter.transaction do
+        adapter.wrap_rollback do
+          result = call_action_block(action[:block], records, collected)
+          raise IronAdmin::Rollback if result == false
+        end
       end
     end
 
+    def searchable_display_attribute
+      @resource_class.searchable_columns.find { |column| adapter.has_column?(column) }
+    end
+
+    def action_condition_met?(action, record)
+      condition = action[:condition]
+      return true unless condition
+
+      condition.call(record)
+    end
+
+    def prepare_action_record?(action)
+      @record = find_record(record_scope, params[:id])
+      return true if action_condition_met?(action, @record)
+
+      head(:forbidden)
+      false
+    end
+
     def index_fields
       base_fields = if @resource_class.index_field_names
                       fields_by_name = @resource_class.resolved_fields.index_by(&:name)
@@ -274,7 +328,7 @@ module IronAdmin
 
     def purge_attachments(record)
       form_fields.select { |f| f.type == :file }.each do |field|
-        next unless params.dig(:record, :"#{field.name}_purge") == "1" && record.respond_to?(field.name)
+        next unless iron_admin_param_dig(params[:record], :"#{field.name}_purge") == "1" && record.respond_to?(field.name)
 
         record.public_send(field.name).then { |a| a.purge if a.attached? }
       end
@@ -291,70 +345,17 @@ module IronAdmin
       end
 
       @resource_class.habtm_associations.each { |a| permitted << { "#{a[:name].to_s.singularize}_ids": [] } }
-      params.require(:record).permit(*permitted) # rubocop:disable Rails/StrongParametersExpect
-    end
-
-    def apply_filters(scope)
-      @resource_class.all_filters.each do |filter|
-        if filter[:type] == :date_range
-          from = params.dig(:filters, "#{filter[:name]}_from")
-          to = params.dig(:filters, "#{filter[:name]}_to")
-          scope = scope.where(filter[:name] => parse_date(from)..) if from.present? && parse_date(from)
-          scope = scope.where(filter[:name] => ..parse_date(to)&.end_of_day) if to.present? && parse_date(to)
-          next
-        end
-
-        value = params.dig(:filters, filter[:name])
-        next if value.blank?
-        next unless value.is_a?(String)
 
-        value = ActiveModel::Type::Boolean.new.cast(value) if filter[:type] == :boolean
-
-        scope = if filter[:scope]
-                  filter[:scope].call(value, scope)
-                else
-                  scope.where(filter[:name] => value)
-                end
+      @resource_class.nested_associations.each do |nested|
+        permitted << { "#{nested.name}_attributes": build_nested_permit_list(nested) }
       end
-      scope
-    end
-
-    def parse_date(value)
-      return nil if value.blank?
-
-      Date.parse(value)
-    rescue ArgumentError, TypeError
-      nil
-    end
-
-    def current_scope_name
-      scope_name = params[:scope]
-      defined_scope = @resource_class.all_scopes.find { |s| s[:name].to_s == scope_name }
-      defined_scope ||= @resource_class.all_scopes.find { |s| s[:default] }
-      defined_scope&.dig(:name)&.to_s
-    end
-
-    def apply_scopes(scope)
-      defined_scope = @resource_class.all_scopes.find { |s| s[:name].to_s == params[:scope] }
-      defined_scope ||= @resource_class.all_scopes.find { |s| s[:default] }
-
-      return scope unless defined_scope
 
-      scope.merge(defined_scope[:scope])
-    end
-
-    def apply_sorting(scope)
-      sort_col = params[:sort].to_s
-      valid_columns = @resource_class.model.column_names
-      sort_col = IronAdmin.configuration.default_sort.to_s unless valid_columns.include?(sort_col)
-      valid_dir = %w[asc desc].include?(params[:direction].to_s.downcase)
-      sort_dir = valid_dir ? params[:direction] : IronAdmin.configuration.default_sort_direction
-      scope.order(sort_col => sort_dir)
-    end
+      record_params = params.require(:record)
+      raise ActionController::ParameterMissing, :record unless record_params.respond_to?(:permit)
 
-    def apply_preloading(scope)
-      preloads = @resource_class.preload_associations
-      preloads.any? ? scope.includes(*preloads) : scope
+      parsed = record_params.permit(*permitted)
+      coerce_json_field_params!(parsed)
+      parsed
     end
 
     def emit_event(action, record)
@@ -362,8 +363,8 @@ module IronAdmin
         user: iron_admin_current_user,
         action: action,
         resource: @resource_class.name,
-        record_id: record.id,
-        changes: record.saved_changes,
+        record_id: record.id.to_s,
+        changes: adapter.record_changes(record),
         ip_address: request.remote_ip
       )
 

data/app/controllers/iron_admin/search_controller.rb

@@ -19,11 +19,11 @@ module IronAdmin
         columns = resource_class.searchable_columns
         next if columns.empty?
 
-        conn = resource_class.model.connection
-        table = conn.quote_table_name(resource_class.model.table_name)
-        like_operator = conn.adapter_name.downcase.include?("postgresql") ? "ILIKE" : "LIKE"
-        conditions = columns.map { |col| "#{table}.#{conn.quote_column_name(col)} #{like_operator} :q" }
-        records = resource_class.model.where(conditions.join(" OR "), q: "%#{@query}%").limit(5)
+        resource_adapter = resource_class.adapter
+        scope = resource_adapter.all
+        scope = IronAdmin.configuration.tenant_scope_block.call(scope) if IronAdmin.configuration.tenant_scope_block
+        records = resource_adapter.search_columns(scope, columns, @query)
+        records = resource_adapter.limit(records, 5)
 
         next if records.empty?
 

data/app/controllers/iron_admin/tools_controller.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 module IronAdmin
+  # Controller for rendering and executing admin tools.
+  #
+  # Supports both legacy bare-method tools and enhanced tools with
+  # tool_action declarations, context injection, and authorization.
   class ToolsController < ApplicationController
     before_action :set_tool
 
@@ -10,19 +14,74 @@ module IronAdmin
     end
 
     def execute
-      action = params[:action_name]
-      return head(:not_found) unless @tool_class.method_defined?(action)
+      action_name = params[:action_name]
+      declared = @tool_class.find_tool_action(action_name)
+
+      if declared
+        return head(:forbidden) unless declared.allowed?(iron_admin_current_user)
+        return unless run_tool_action(declared)
+      elsif @tool_class.method_defined?(action_name)
+        run_legacy_action(action_name)
+      else
+        return head(:not_found)
+      end
 
-      tool_instance = @tool_class.new
-      tool_instance.public_send(action)
       redirect_to tool_path(@tool_class.tool_name)
     end
 
+    # Renders the form for a tool action with form_fields.
+    def action_form
+      @declared_action = @tool_class.find_tool_action(params[:action_name])
+      return head(:not_found) unless @declared_action&.has_form?
+      return head(:forbidden) unless @declared_action.allowed?(iron_admin_current_user)
+
+      @form_fields = @declared_action.form_fields
+      @form_url = tool_action_path(@tool_class.tool_name, @declared_action.name)
+    end
+
     private
 
     def set_tool
       @tool_class = ToolRegistry.find(params[:tool_name])
       head(:not_found) and return unless @tool_class
     end
+
+    def run_tool_action(declared)
+      unless @tool_class.method_defined?(declared.name)
+        head(:not_found)
+        return nil
+      end
+
+      tool_instance = build_tool_instance
+      dispatch_with_arity(tool_instance, declared.name)
+      true
+    end
+
+    def run_legacy_action(action_name)
+      tool_instance = build_tool_instance
+      dispatch_with_arity(tool_instance, action_name)
+    end
+
+    def build_tool_instance
+      tool = @tool_class.new
+      tool.context = build_context
+      tool
+    end
+
+    def dispatch_with_arity(tool_instance, method_name)
+      if tool_instance.method(method_name).arity.zero?
+        tool_instance.public_send(method_name)
+      else
+        tool_instance.public_send(method_name, tool_instance.context)
+      end
+    end
+
+    def build_context
+      ToolContext.new(
+        params: params,
+        current_user: iron_admin_current_user,
+        flash: flash
+      )
+    end
   end
 end

data/app/helpers/iron_admin/application_helper.rb

@@ -17,6 +17,9 @@ module IronAdmin
     # Field types that should be truncated on index pages.
     TRUNCATABLE_TYPES = %i[text textarea].freeze
 
+    # Field types that show compact summaries on index pages.
+    INDEX_COMPACT_TYPES = %i[key_value boolean_group].freeze
+
     # Maps field types to their display method names.
     # @return [Hash{Symbol => Symbol}]
     FIELD_DISPLAY_METHODS = {
@@ -36,6 +39,13 @@ module IronAdmin
       date: :display_date,
       datetime: :display_datetime,
       polymorphic_belongs_to: :display_polymorphic_belongs_to,
+      hidden: :display_hidden,
+      radio: :display_radio,
+      code: :display_code,
+      progress_bar: :display_progress_bar,
+      external_image: :display_external_image,
+      boolean_group: :display_boolean_group,
+      key_value: :display_key_value,
     }.freeze
 
     # Displays a field value with appropriate formatting.
@@ -61,15 +71,9 @@ module IronAdmin
     # @return [String, nil] Formatted value (truncated for text fields)
     def display_index_field_value(record, field)
       if TRUNCATABLE_TYPES.include?(field.type)
-        value = record.public_send(field.name)
-        return if value.blank?
-
-        truncated = truncate(value.to_s, length: INDEX_TRUNCATION_LENGTH)
-        if value.to_s.length > INDEX_TRUNCATION_LENGTH
-          content_tag(:span, truncated, title: value.to_s)
-        else
-          truncated
-        end
+        display_truncated_index_value(record, field)
+      elsif INDEX_COMPACT_TYPES.include?(field.type)
+        display_compact_field_value(record, field)
       elsif (custom = IronAdmin::FieldTypeRegistry.find(field.type))
         custom.render_index_display(record, field)
       else
@@ -100,17 +104,18 @@ module IronAdmin
     # @param filter [Hash] Filter configuration
     # @return [Array<Array(String, String)>] Options for select tag
     def filter_options_for(resource_class, filter)
-      model = resource_class.model
+      resource_adapter = resource_class.adapter
       column_name = filter[:name].to_s
 
       case filter[:type]
       when :select
-        if model.defined_enums.key?(column_name)
-          model.defined_enums[column_name].keys.map { |k| [k.humanize, k] }
+        enums = resource_adapter.enums
+        if enums.key?(column_name)
+          enums[column_name].keys.map { |k| [k.humanize, k] }
         elsif filter[:options]
-          filter[:options]
+          normalize_filter_options(filter[:options])
         else
-          model.distinct.pluck(column_name).compact.sort.map { |v| [v.to_s.humanize, v] }
+          resource_adapter.distinct_values(column_name).map { |v| [v.to_s.humanize, v] }
         end
       when :boolean
         [[I18n.t("iron_admin.filters.true"), "true"], [I18n.t("iron_admin.filters.false"), "false"]]
@@ -118,5 +123,19 @@ module IronAdmin
         []
       end
     end
+
+    def normalize_filter_options(options)
+      options.map do |option|
+        option.is_a?(Array) ? option : [option.to_s.humanize, option]
+      end
+    end
+
+    def association_resource_for(field, association_class)
+      resource = field.options[:resource]
+      return resource.constantize if resource.is_a?(String)
+      return resource if resource
+
+      IronAdmin::ResourceRegistry.find(association_class.model_name.plural)
+    end
   end
 end