super_admin 0.2.0

data/app/services/super_admin/dashboard_registry.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module SuperAdmin
+  # Discovers and caches dashboard classes for SuperAdmin resources.
+  class DashboardRegistry
+    include Singleton
+
+    def initialize
+      @dashboards = {}
+      @resource_classes = {}
+      @loaded = false
+      setup_reloader
+    end
+
+    # Returns the dashboard class for a given model or resource name.
+    # @param model [Class, String, Symbol]
+    # @return [Class, nil]
+    def dashboard_for(model)
+      load_dashboards unless @loaded
+
+      @dashboards[normalize_model_name(model)]
+    end
+
+    # Returns the list of resource classes that have an associated dashboard.
+    # @return [Array<Class>]
+    def resource_classes
+      load_dashboards unless @loaded
+
+      @resource_classes.values.sort_by(&:name)
+    end
+
+    # Reloads dashboard definitions (used in development).
+    def reload!
+      @dashboards.clear
+      @resource_classes.clear
+      @loaded = false
+      load_dashboards
+    end
+
+    private
+
+    def setup_reloader
+      return unless defined?(ActiveSupport::Reloader)
+
+      ActiveSupport::Reloader.to_prepare do
+        @dashboards ||= {}
+        @dashboards.clear
+        @resource_classes ||= {}
+        @resource_classes.clear
+        @loaded = false
+      end
+    end
+
+    def load_dashboards
+      eager_load_dashboard_files
+      register_dashboard_classes
+      @loaded = true
+    end
+
+    def eager_load_dashboard_files
+      pattern = Rails.root.join("app/dashboards/**/*_dashboard.rb")
+      Dir[pattern].each { |file| require_dependency(file) }
+    end
+
+    def register_dashboard_classes
+      ObjectSpace.each_object(Class) do |klass|
+        next unless klass < SuperAdmin::BaseDashboard
+
+        resource_class = klass.resource_class
+        next unless resource_class
+
+        @dashboards[resource_class.name] = klass
+        @resource_classes[resource_class.name] = resource_class
+      end
+    end
+
+    def normalize_model_name(model)
+      case model
+      when Class
+        model.name
+      when String, Symbol
+        model.to_s.underscore.singularize.camelize
+      else
+        model.class.name
+      end
+    end
+  end
+end

data/app/services/super_admin/dashboard_resolver.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  # Provides accessors and fallbacks for dashboard-driven configuration.
+  class DashboardResolver
+    VIEWS = {
+      index: :collection,
+      collection: :collection,
+      list: :collection,
+      show: :show,
+      detail: :show,
+      form: :form,
+      new: :form,
+      edit: :form
+    }.freeze
+
+    class << self
+      def dashboard_for(model_class)
+        DashboardRegistry.instance.dashboard_for(model_class)
+      end
+
+      def collection_attributes_for(model_class)
+        attributes_for(model_class, :collection)
+      end
+
+      def show_attributes_for(model_class)
+        attributes_for(model_class, :show)
+      end
+
+      def form_attributes_for(model_class)
+        attributes_for(model_class, :form)
+      end
+
+      def collection_includes_for(model_class)
+        includes_for(model_class, :collection)
+      end
+
+      def show_includes_for(model_class)
+        includes_for(model_class, :show)
+      end
+
+      def includes_for(model_class, view)
+        dashboard = dashboard_for(model_class)
+        return [] unless dashboard
+
+        case view
+        when :collection, :index, :list
+          Array.wrap(dashboard.collection_includes_list)
+        when :show, :detail
+          Array.wrap(dashboard.show_includes_list)
+        else
+          []
+        end
+      end
+
+      def attributes_for(model_class, view)
+        normalized_view = VIEWS.fetch(view.to_sym, view.to_sym)
+        dashboard = dashboard_for(model_class)
+
+        if dashboard
+          Array.wrap(dashboard.attributes_for(normalized_view)).map { |attr| normalize_attribute(attr) }
+        else
+          fallback_attributes(model_class, normalized_view)
+        end
+      end
+
+      private
+
+      def normalize_attribute(attribute)
+        case attribute
+        when Hash
+          attribute.each_with_object({}) do |(key, value), hash|
+            hash[key.to_sym] = Array(value).map { |entry| normalize_attribute(entry) }
+          end
+        else
+          attribute.to_sym
+        end
+      end
+
+      def fallback_attributes(model_class, view)
+        case view
+        when :collection
+          SuperAdmin::ResourceConfiguration
+            .displayable_attributes(model_class)
+            .map { |attr| attr.to_sym }
+        when :show
+          SuperAdmin::ResourceConfiguration
+            .displayable_attributes(model_class)
+            .map { |attr| attr.to_sym }
+        when :form
+          SuperAdmin::ResourceConfiguration
+            .editable_attributes(model_class)
+            .map { |attr| attr.is_a?(String) ? attr.to_sym : attr }
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/app/services/super_admin/filter_builder.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "digest"
+
+module SuperAdmin
+  # Dynamically builds available filters for a SuperAdmin resource
+  # and applies associated conditions on an ActiveRecord relation.
+  class FilterBuilder
+    FilterDefinition = Struct.new(:attribute, :type, :param_keys, :label, :options, keyword_init: true)
+
+    CACHE_NAMESPACE = "super_admin/filter_definitions".freeze
+    CACHE_EXPIRATION = 1.hour
+
+    STRING_TYPES = %i[string text].freeze
+    NUMERIC_TYPES = %i[integer float decimal].freeze
+    DATE_TYPES = %i[date datetime].freeze
+    BOOLEAN_TYPES = %i[boolean].freeze
+
+    class << self
+      # Returns filter definitions for a given model class.
+      # @param model_class [Class]
+      # @return [Array<FilterDefinition>]
+      def definitions_for(model_class)
+        Rails.cache.fetch(cache_key_for(model_class), expires_in: CACHE_EXPIRATION) do
+          new(model_class).definitions
+        end
+      end
+
+      # Returns list of permitted parameter keys for filters.
+      # @param model_class [Class]
+      # @return [Array<Symbol>]
+      def permitted_param_keys(model_class)
+        definitions_for(model_class).flat_map(&:param_keys).uniq
+      end
+
+      # Applies filters on an ActiveRecord relation.
+      # @param scope [ActiveRecord::Relation]
+      # @param model_class [Class]
+      # @param params [Hash]
+      # @return [ActiveRecord::Relation]
+      def apply(scope, model_class, params)
+        return scope if params.blank?
+
+        SuperAdmin::Queries::FilterQuery.new(
+          scope,
+          model_class,
+          filters: params,
+          filter_definitions: definitions_for(model_class)
+        ).call
+      end
+
+      private
+
+      def cache_key_for(model_class)
+        columns_signature = model_class.columns_hash.values.map do |column|
+          [ column.name, column.sql_type, column.default, column.null ]
+        end
+        enums_signature = model_class.respond_to?(:defined_enums) ? model_class.defined_enums : {}
+        digest_source = [ model_class.name, columns_signature, enums_signature ].to_s
+        digest = Digest::SHA256.hexdigest(digest_source)
+        "#{CACHE_NAMESPACE}/#{model_class.name}/#{digest}"
+      end
+
+      # DEPRECATED: These methods are kept for compatibility but no longer used.
+      # Logic has been moved to SuperAdmin::Queries::FilterQuery
+
+      def apply_string_filter(scope, arel_table, attribute, value)
+        SuperAdmin::Queries::FilterQuery.new(scope, scope.model, filters: { "#{attribute}_contains" => value }).call
+      end
+
+      def apply_numeric_filter(scope, arel_table, attribute, type, params)
+        SuperAdmin::Queries::FilterQuery.new(scope, scope.model, filters: params).call
+      end
+
+      def apply_date_filter(scope, arel_table, attribute, type, params)
+        SuperAdmin::Queries::FilterQuery.new(scope, scope.model, filters: params).call
+      end
+
+      def apply_boolean_filter(scope, attribute, value)
+        SuperAdmin::Queries::FilterQuery.new(scope, scope.model, filters: { "#{attribute}_equals" => value }).call
+      end
+
+      def parse_numeric(value, type)
+        case type
+        when :integer
+          Integer(value)
+        when :float
+          Float(value)
+        when :decimal
+          BigDecimal(value)
+        end
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def parse_temporal(value, type)
+        case type
+        when :date
+          Date.parse(value)
+        when :datetime
+          Time.zone.parse(value)
+        end
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def parse_boolean(value)
+        return true if %w[true 1 yes oui].include?(value.to_s.downcase)
+        return false if %w[false 0 no non].include?(value.to_s.downcase)
+
+        nil
+      end
+    end
+
+    attr_reader :model_class
+
+    def initialize(model_class)
+      @model_class = model_class
+    end
+
+    # Returns computed definitions (memoized)
+    # @return [Array<FilterDefinition>]
+    def definitions
+      @definitions ||= build_definitions
+    end
+
+    private
+
+    def build_definitions
+      enums = enum_attributes
+
+      model_class.columns.filter_map do |column|
+        next if %w[id created_at updated_at].include?(column.name)
+
+        attribute = column.name
+        label = model_class.human_attribute_name(attribute)
+
+        if enums.key?(attribute)
+          FilterDefinition.new(
+            attribute: attribute,
+            type: :enum,
+            param_keys: [ "#{attribute}_equals".to_sym ],
+            label: label,
+            options: enums[attribute].keys
+          )
+        elsif STRING_TYPES.include?(column.type)
+          FilterDefinition.new(
+            attribute: attribute,
+            type: column.type,
+            param_keys: [ "#{attribute}_contains".to_sym ],
+            label: label
+          )
+        elsif NUMERIC_TYPES.include?(column.type)
+          FilterDefinition.new(
+            attribute: attribute,
+            type: column.type,
+            param_keys: [ "#{attribute}_min".to_sym, "#{attribute}_max".to_sym ],
+            label: label
+          )
+        elsif DATE_TYPES.include?(column.type)
+          FilterDefinition.new(
+            attribute: attribute,
+            type: column.type,
+            param_keys: [ "#{attribute}_from".to_sym, "#{attribute}_to".to_sym ],
+            label: label
+          )
+        elsif BOOLEAN_TYPES.include?(column.type)
+          FilterDefinition.new(
+            attribute: attribute,
+            type: :boolean,
+            param_keys: [ "#{attribute}_equals".to_sym ],
+            label: label
+          )
+        end
+      end
+    end
+
+    def enum_attributes
+      return {} unless model_class.respond_to?(:defined_enums)
+
+      model_class.defined_enums
+    end
+  end
+end

data/app/services/super_admin/form_builder.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  # Service responsible for generating form fields
+  # based on attribute type and model associations.
+  class FormBuilder
+    attr_reader :model_class, :form, :attribute_name, :column, :view_context
+
+    def initialize(model_class:, form:, attribute_name:)
+      @model_class = model_class
+      @form = form
+      @attribute_name = attribute_name.to_s
+      @column = model_class.columns_hash[@attribute_name]
+      @view_context = resolve_view_context
+    end
+
+    # Generates the appropriate form field
+    # @return [String] HTML of the form field
+    def build_field
+      field.render
+    end
+
+    # Returns the field type
+    # @return [Symbol]
+    def field_type
+      field.type
+    end
+
+    # Returns options for the field
+    # @return [Hash]
+    def field_options
+      field.options
+    end
+
+    # Returns the label for the field
+    # @return [String]
+    def field_label
+      field.label
+    end
+
+    protected
+
+    def field
+      @field ||= SuperAdmin::FormFields::Factory.build(self)
+    end
+
+    private
+
+    def resolve_view_context
+      template = form.instance_variable_get(:@template)
+      return template if template
+
+      context = form.instance_variable_get(:@view_context)
+      return context if context
+
+      raise ArgumentError, "SuperAdmin::FormBuilder requires an ActionView context"
+    end
+  end
+end

data/app/services/super_admin/form_fields/array_field.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  module FormFields
+    # Renders a textarea optimized for array-backed attributes.
+    class ArrayField < TextAreaField
+      def render
+        form.text_area(attribute_name, options.merge(value: formatted_value))
+      end
+
+      def type
+        :array
+      end
+
+      private
+
+      def formatted_value
+        value = form.object.public_send(attribute_name)
+        return "" if value.blank?
+
+        Array(value).map(&:to_s).join("\n")
+      rescue NoMethodError
+        ""
+      end
+
+      def options
+        base_options.merge(rows: 4, placeholder: placeholder_text)
+      end
+
+      def placeholder_text
+        I18n.t("super_admin.resources.form.array_placeholder", default: "Enter one value per line or separate with commas")
+      end
+    end
+  end
+end

data/app/services/super_admin/form_fields/association_field.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  module FormFields
+    class AssociationField < BaseField
+      def render
+        return safe_text_field(attribute_name) unless association
+
+        total_count = associated_class.count
+        records = limited_records
+
+        if total_count > SuperAdmin.association_select_limit
+          searchable_select(records, total_count)
+        else
+          standard_select(records)
+        end
+      rescue StandardError => e
+        Rails.logger.error("SuperAdmin::FormBuilder - Association field error: #{e.message}")
+        form.text_field(attribute_name, base_options)
+      end
+
+      def type
+        :association
+      end
+
+      def options
+        base_options.except(:required)
+      end
+
+      private
+
+      def association
+        @association ||= model_class.reflect_on_association(association_name)
+      end
+
+      def association_name
+        attribute_name.to_s.delete_suffix("_id").to_sym
+      end
+
+      def associated_class
+        association.klass
+      end
+
+      def limited_records
+        fetch_records
+      end
+
+      def fetch_records
+        limit = SuperAdmin.association_select_limit
+
+        if associated_class.column_names.include?("name")
+          associated_class.order(:name).limit(limit)
+        elsif associated_class.column_names.include?("title")
+          associated_class.order(:title).limit(limit)
+        elsif associated_class.column_names.include?("created_at")
+          associated_class.order(created_at: :desc).limit(limit)
+        else
+          associated_class.limit(limit)
+        end
+      end
+
+      def standard_select(records)
+        render_select(records, options)
+      end
+
+      def searchable_select(records, total_count)
+        limited_count = records.size
+        selected_record = selected_record_for(records)
+
+        records_for_select = records.to_a
+        records_for_select.unshift(selected_record) if selected_record && !records_for_select.include?(selected_record)
+
+        select = render_select(
+          records_for_select,
+          options.merge(
+            class: "#{options[:class]} pr-10",
+            data: {
+              controller: "super-admin--association-select",
+              super_admin__association_select_target: "select",
+              association: association_name,
+              searchable: "true",
+              total_count: total_count
+            }
+          )
+        )
+
+        hint = view_context.content_tag(
+          :p,
+          view_context.t("super_admin.resources.form.association_limited", count: limited_count, total: total_count),
+          class: "mt-1 text-xs text-gray-500"
+        )
+
+        view_context.safe_join([ select, hint ])
+      end
+
+      def skip_required?
+        true
+      end
+
+      def safe_text_field(attr)
+        if form.object && form.object.respond_to?(attr)
+          form.text_field(attr, base_options)
+        else
+          view_context.text_field_tag(attr, nil, base_options)
+        end
+      end
+
+      def render_select(records, html_options)
+        include_blank = column&.null
+        selected_value = current_attribute_value
+
+        if form.object && form.object.respond_to?(attribute_name)
+          form.collection_select(
+            attribute_name,
+            records,
+            :id,
+            :to_s,
+            { include_blank: include_blank, selected: selected_value },
+            html_options
+          )
+        else
+          option_tags = view_context.options_from_collection_for_select(records, :id, :to_s, selected_value)
+          option_tags = view_context.tag.option("", value: "") + option_tags if include_blank
+          view_context.select_tag(attribute_name, option_tags, html_options)
+        end
+      end
+
+      def current_attribute_value
+        if form.object && form.object.respond_to?(attribute_name)
+          form.object.public_send(attribute_name)
+        end
+      end
+
+      def selected_record_for(records)
+        value = current_attribute_value
+        return unless value
+
+        if records.respond_to?(:find) && records.respond_to?(:detect)
+          records.detect { |record| record.id == value } || associated_class.find_by(id: value)
+        else
+          associated_class.find_by(id: value)
+        end
+      end
+    end
+  end
+end

data/app/services/super_admin/form_fields/base_field.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  module FormFields
+    # Base class for SuperAdmin form fields.
+    class BaseField
+      attr_reader :builder
+
+      delegate :form, :model_class, :attribute_name, :column, :view_context, to: :builder
+
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def render
+        form.text_field(attribute_name, options)
+      end
+
+      def type
+        :text
+      end
+
+      def options
+        base_options
+      end
+
+      def label
+        model_class.human_attribute_name(attribute_name)
+      end
+
+      protected
+
+      def base_options
+        @base_options ||= begin
+          input_options = { class: input_css_class }
+          if column
+            input_options[:required] = !column.null unless skip_required?
+            input_options[:maxlength] = column.limit if column.limit
+          end
+          input_options
+        end
+      end
+
+      def input_css_class
+        "block w-full rounded-md border-2 border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500 sm:text-sm px-3 py-2"
+      end
+
+      def skip_required?
+        %w[created_at updated_at id].include?(attribute_name.to_s)
+      end
+    end
+  end
+end

data/app/services/super_admin/form_fields/boolean_field.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  module FormFields
+    class BooleanField < BaseField
+      def render
+        form.check_box(attribute_name, class: input_css_class)
+      end
+
+      def type
+        :boolean
+      end
+
+      def options
+        { class: input_css_class }
+      end
+
+      private
+
+      def input_css_class
+        "h-4 w-4 rounded border-gray-300 text-blue-600 focus:ring-blue-500"
+      end
+
+      def skip_required?
+        true
+      end
+    end
+  end
+end