super_admin 0.2.0

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  module FormFields
+    class DateField < BaseField
+      def render
+        form.date_field(attribute_name, options)
+      end
+
+      def type
+        :date
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  module FormFields
+    class DateTimeField < BaseField
+      def render
+        form.datetime_local_field(attribute_name, options)
+      end
+
+      def type
+        :datetime
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  module FormFields
+    class EnumField < BaseField
+      def render
+        form.select(attribute_name, enum_options, { include_blank: include_blank_option }, options.except(:required))
+      end
+
+      def type
+        :enum
+      end
+
+      private
+
+      def enum_options
+        SuperAdmin::ModelInspector.enum_values(model_class, attribute_name).keys.map do |key|
+          [ key.humanize, key ]
+        end
+      end
+
+      def include_blank_option
+        column&.null ? true : nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  module FormFields
+    # Responsible for selecting the correct form field class
+    # based on the attribute metadata exposed by the FormBuilder.
+    class Factory
+      ASSOCIATION_SUFFIX = "_id".freeze
+      NESTED_SUFFIX = "_attributes".freeze
+
+      class << self
+        def build(builder)
+          new(builder).build
+        end
+      end
+
+      def initialize(builder)
+        @builder = builder
+      end
+
+      def build
+        field_klass.new(builder)
+      rescue StandardError => e
+        Rails.logger.error("SuperAdmin::FormFields::Factory build error: #{e.message}")
+        BaseField.new(builder)
+      end
+
+      private
+
+      attr_reader :builder
+
+      delegate :model_class, :attribute_name, :column, to: :builder
+
+      def field_klass
+  return NestedField if nested_attribute?
+  return AssociationField if association_attribute?
+  return EnumField if enum_attribute?
+  return BooleanField if boolean_attribute?
+  return DateTimeField if datetime_attribute?
+  return DateField if date_attribute?
+  return NumberField if number_attribute?
+  return ArrayField if array_attribute?
+  return TextAreaField if text_area_attribute?
+
+        BaseField
+      end
+
+      def nested_attribute?
+        attribute_name.to_s.end_with?(NESTED_SUFFIX)
+      end
+
+      def association_attribute?
+        association_name && model_class.reflect_on_association(association_name)
+      end
+
+      def association_name
+        return @association_name if defined?(@association_name)
+
+        name = attribute_name.to_s
+        @association_name = name.end_with?(ASSOCIATION_SUFFIX) ? name.delete_suffix(ASSOCIATION_SUFFIX).to_sym : nil
+      end
+
+      def enum_attribute?
+        SuperAdmin::ModelInspector.enum_values(model_class, attribute_name).present?
+      rescue StandardError
+        false
+      end
+
+      def boolean_attribute?
+        column_type?(:boolean)
+      end
+
+      def datetime_attribute?
+        column_type?(:datetime, :timestamp)
+      end
+
+      def date_attribute?
+        column_type?(:date)
+      end
+
+      def number_attribute?
+        column_type?(:integer, :float, :decimal, :bigint)
+      end
+
+      def text_area_attribute?
+        column_type?(:text)
+      end
+
+      def column_type?(*types)
+        return false unless column
+
+        types.include?(column.type)
+      end
+
+      def array_attribute?
+        return false unless column
+
+        column.respond_to?(:array) && column.array
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  module FormFields
+    class NestedField < BaseField
+      MAX_DEPTH_SAFETY = 10
+
+      def render
+        return missing_association_warning unless reflection
+        return max_depth_message if max_depth_exceeded?
+
+        prepare_nested_records
+
+        view_context.render(
+          partial: "super_admin/shared/nested_fields",
+          locals: {
+            form: form,
+            parent_model_class: model_class,
+            association: reflection,
+            nested_model_class: reflection.klass,
+            nested_attributes: nested_editable_attributes,
+            nested_options: nested_options,
+            label: label,
+            current_depth: current_depth
+          }
+        )
+      end
+
+      def type
+        :nested
+      end
+
+      def label
+        return association_name.to_s.humanize unless reflection
+
+        count = reflection.collection? ? 2 : 1
+        reflection.klass.model_name.human(count: count)
+      end
+
+      def options
+        {}
+      end
+
+      private
+
+      def association_name
+        attribute_name.to_s.delete_suffix("_attributes")
+      end
+
+      def reflection
+        @reflection ||= model_class.reflect_on_association(association_name.to_sym)
+      end
+
+      def nested_options
+        return {} unless model_class.respond_to?(:nested_attributes_options)
+
+        model_class.nested_attributes_options[association_name.to_sym]
+      end
+
+      def nested_editable_attributes
+        attributes = SuperAdmin::DashboardResolver.form_attributes_for(reflection.klass)
+        attributes = SuperAdmin::ResourceConfiguration.editable_attributes(reflection.klass) if attributes.blank?
+
+        attributes = attributes.reject { |attr| attr.to_s.end_with?("_attributes") }
+        attributes = attributes.map { |attr| attr.to_sym }
+        attributes -= [ reflection.foreign_key.to_sym ] if reflection.respond_to?(:foreign_key)
+        attributes
+      end
+
+      def prepare_nested_records
+        parent = form.object
+        return unless parent
+        return if reflection.through_reflection
+
+        if parent.respond_to?(:association)
+          association_proxy = parent.association(reflection.name)
+          association_proxy.load_target if association_proxy.respond_to?(:load_target)
+        else
+          parent.public_send(reflection.name)
+        end
+      end
+
+      def current_depth
+        depth = 0
+        current_form = form
+
+        while current_form.respond_to?(:object) && current_form.respond_to?(:object_name) && current_form.object_name.to_s.include?("[")
+          depth += 1
+          parent = current_form.instance_variable_get(:@parent_builder)
+          break unless parent
+
+          current_form = parent
+          break if depth >= MAX_DEPTH_SAFETY
+        end
+
+        depth
+      end
+
+      def max_depth_exceeded?
+        current_depth >= SuperAdmin.max_nested_depth
+      end
+
+      def max_depth_message
+        view_context.content_tag(
+          :div,
+          view_context.content_tag(:p, view_context.t("super_admin.resources.nested.max_depth_exceeded", max: SuperAdmin.max_nested_depth), class: "text-sm text-amber-600"),
+          class: "mb-4 bg-amber-50 border border-amber-200 rounded-md p-3"
+        )
+      end
+
+      def missing_association_warning
+        view_context.content_tag(
+          :p,
+          view_context.t("super_admin.resources.nested.missing_association", name: association_name.humanize),
+          class: "text-sm text-red-600"
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  module FormFields
+    class NumberField < BaseField
+      def render
+        form.number_field(attribute_name, options)
+      end
+
+      def type
+        :number
+      end
+
+      def options
+        base_options.merge(step: step_value)
+      end
+
+      private
+
+      def step_value
+        column = builder.column
+        return "0.01" if column&.type == :decimal && column.scale && column.scale.positive?
+        return "0.01" if column&.type == :float
+
+        "1"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  module FormFields
+    class TextAreaField < BaseField
+      def render
+        form.text_area(attribute_name, options)
+      end
+
+      def type
+        :text_area
+      end
+
+      def options
+        base_options.merge(rows: 4)
+      end
+    end
+  end
+end

data/app/services/super_admin/model_inspector.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  # Service responsible for inspecting ActiveRecord models.
+  # Extracts information about attributes, types, and associations.
+  class ModelInspector
+    # System models to exclude from SuperAdmin interface
+    EXCLUDED_MODELS = %w[
+      ApplicationRecord
+      ActiveRecord::Base
+      ActiveRecord::SchemaMigration
+      ActiveRecord::InternalMetadata
+      ActionText::Record
+      ActionText::RichText
+      ActionText::EncryptedRichText
+      ActionMailbox::Record
+      ActionMailbox::InboundEmail
+      ActiveStorage::Record
+      ActiveStorage::Blob
+      ActiveStorage::Attachment
+      ActiveStorage::VariantRecord
+      SolidQueue::Job
+      SolidQueue::Process
+      SolidQueue::RecurringTask
+      SolidQueue::ScheduledExecution
+      SolidQueue::ReadyExecution
+      SolidQueue::ClaimedExecution
+      SolidQueue::FailedExecution
+      SolidQueue::BlockedExecution
+      SolidQueue::Semaphore
+      SolidQueue::Pause
+      SolidCable::Message
+      SolidCache::Entry
+    ].freeze
+
+    class << self
+      # Returns list of all administrable models
+      # @return [Array<Class>] List of model classes
+      def all_models
+        Rails.application.eager_load! unless Rails.application.config.eager_load
+
+        SuperAdmin::DashboardRegistry.instance.resource_classes
+      end
+
+      # Returns the list of models that could be managed by SuperAdmin, regardless of dashboard presence.
+      # @return [Array<Class>]
+      def discoverable_models
+        Rails.application.eager_load! unless Rails.application.config.eager_load
+
+        ActiveRecord::Base.descendants
+          .reject { |model| excluded_model?(model) }
+          .sort_by(&:name)
+      end
+
+      # Returns detailed information about a model
+      # @param model_class [Class] The model class
+      # @return [Hash] Model information
+      def inspect_model(model_class)
+        {
+          name: model_class.name,
+          table_name: model_class.table_name,
+          human_name: model_class.model_name.human,
+          attributes: inspect_attributes(model_class),
+          associations: inspect_associations(model_class),
+          validations: inspect_validations(model_class)
+        }
+      end
+
+      # Returns model attributes with their metadata
+      # @param model_class [Class] The model class
+      # @return [Hash] Attributes with type, null, default, etc.
+      def inspect_attributes(model_class)
+        model_class.columns.each_with_object({}) do |column, hash|
+          hash[column.name] = {
+            type: column.type,
+            sql_type: column.sql_type,
+            null: column.null,
+            default: column.default,
+            limit: column.limit,
+            precision: column.precision,
+            scale: column.scale
+          }
+        end
+      end
+
+      # Returns model associations
+      # @param model_class [Class] The model class
+      # @return [Hash] Associations grouped by type
+      def inspect_associations(model_class)
+        model_class.reflect_on_all_associations.each_with_object({}) do |assoc, hash|
+          hash[assoc.name] = {
+            type: assoc.macro,
+            class_name: assoc.class_name,
+            foreign_key: assoc.foreign_key,
+            primary_key: assoc.association_primary_key,
+            polymorphic: assoc.polymorphic?,
+            through: assoc.through_reflection&.name
+          }
+        end
+      end
+
+      # Returns model validations
+      # @param model_class [Class] The model class
+      # @return [Hash] Validations by attribute
+      def inspect_validations(model_class)
+        model_class.validators.each_with_object(Hash.new { |h, k| h[k] = [] }) do |validator, hash|
+          validator.attributes.each do |attribute|
+            hash[attribute] << {
+              kind: validator.kind,
+              options: validator.options.except(:class)
+            }
+          end
+        end
+      end
+
+      # Checks if an attribute is an enum
+      # @param model_class [Class] The model class
+      # @param attribute_name [String, Symbol] The attribute name
+      # @return [Boolean]
+      def enum?(model_class, attribute_name)
+        model_class.defined_enums.key?(attribute_name.to_s)
+      end
+
+      # Returns possible values for an enum
+      # @param model_class [Class] The model class
+      # @param attribute_name [String, Symbol] The attribute name
+      # @return [Hash, nil] Hash of enum values or nil
+      def enum_values(model_class, attribute_name)
+        model_class.defined_enums[attribute_name.to_s]
+      end
+
+      # Finds a model class by its name
+      # @param model_name [String] The model name (plural or singular)
+      # @return [Class, nil] The model class or nil
+      def find_model(model_name)
+        name = model_name.to_s
+
+        candidates = build_candidate_names(name)
+
+        candidates.each do |candidate|
+          klass = candidate.safe_constantize
+          return klass if valid_model_class?(klass)
+        end
+
+        # Fallback to registered dashboard models
+        normalized_name = name.singularize.camelize
+        all_models.find { |m| m.name == normalized_name }
+      end
+
+      private
+
+      def build_candidate_names(name)
+        variations = [ name, name.singularize, name.pluralize ].uniq
+
+        variations.flat_map do |variation|
+          [ variation, variation.camelize, variation.singularize.camelize ]
+        end.uniq
+      end
+
+      def valid_model_class?(klass)
+        klass.is_a?(Class) && klass < ActiveRecord::Base && !klass.abstract_class?
+      end
+
+      # Checks if a model should be excluded
+      # @param model [Class] The model class
+      # @return [Boolean]
+      def excluded_model?(model)
+        return true if model.abstract_class?
+        return true if EXCLUDED_MODELS.include?(model.name)
+        return true if model.name.start_with?("ActiveRecord::", "ActionText::", "ActionMailbox::", "ActiveStorage::", "SolidQueue::", "SolidCable::", "SolidCache::")
+        return true unless model.table_exists?
+
+        false
+      rescue StandardError => error
+        Rails.logger.warn(
+          "[SuperAdmin::ModelInspector] Failed to evaluate exclusion for #{model}: #{error.class} - #{error.message}"
+        )
+        true
+      end
+    end
+  end
+end

data/app/services/super_admin/queries/base_query.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module SuperAdmin
+  module Queries
+    # Abstract class for SuperAdmin query objects.
+    # Provides common interface and shared utilities.
+    class BaseQuery
+      attr_reader :scope, :model_class
+
+      # @param scope [ActiveRecord::Relation]
+      # @param model_class [Class]
+      def initialize(scope, model_class)
+        @scope = scope
+        @model_class = model_class
+      end
+
+      # Abstract method to implement in subclasses
+      # @return [ActiveRecord::Relation]
+      def call
+        raise NotImplementedError, "#{self.class}#call must be implemented"
+      end
+
+      private
+
+      # Returns the model's Arel table
+      # @return [Arel::Table]
+      def arel_table
+        @arel_table ||= model_class.arel_table
+      end
+
+      # Returns the model's columns
+      # @return [Array<ActiveRecord::ConnectionAdapters::Column>]
+      def columns
+        @columns ||= model_class.columns
+      end
+
+      # Returns columns of specified type
+      # @param types [Array<Symbol>] Column types (e.g., [:string, :text])
+      # @return [Array<ActiveRecord::ConnectionAdapters::Column>]
+      def columns_of_type(*types)
+        columns.select { |column| types.include?(column.type) }
+      end
+    end
+  end
+end