iron_admin 0.4.1 → 0.6.0

data/lib/iron_admin/adapters/mongoid/association_wrapper.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module IronAdmin
+  module Adapters
+    class Mongoid
+      # Wraps a Mongoid relation metadata object to present the interface
+      # expected by FieldInferrer and other IronAdmin consumers.
+      #
+      # Normalizes Mongoid's embedded association macros to their IronAdmin
+      # equivalents: embeds_many → :has_many, embeds_one → :has_one,
+      # embedded_in → :belongs_to.
+      class AssociationWrapper
+        # @return [Symbol] The association name
+        attr_reader :name
+
+        # @return [Symbol] The normalized macro (:belongs_to, :has_many, :has_one, :has_and_belongs_to_many)
+        attr_reader :macro
+
+        MACRO_MAP = {
+          embeds_many: :has_many,
+          embeds_one: :has_one,
+          embedded_in: :belongs_to,
+        }.freeze
+
+        def initialize(relation)
+          @relation = relation
+          @name = relation.name.to_sym
+          @macro = MACRO_MAP.fetch(raw_macro_for(relation), raw_macro_for(relation))
+        end
+
+        private
+
+        # Mongoid 9 dropped `Association#macro`. Derive the macro symbol
+        # from the association class name instead, e.g.
+        # `Mongoid::Association::Referenced::BelongsTo` → :belongs_to,
+        # `Mongoid::Association::Embedded::EmbedsMany` → :embeds_many.
+        # Falls back to `relation.macro` when defined (Mongoid <= 8).
+        #
+        # @param relation [Object] A Mongoid association metadata instance
+        # @return [Symbol] The macro symbol (e.g. :belongs_to, :has_many,
+        #   :embeds_many, :embedded_in)
+        def raw_macro_for(relation)
+          return relation.macro if relation.respond_to?(:macro)
+
+          relation.class.name.split("::").last.underscore.to_sym
+        end
+
+        public
+
+        def klass
+          @relation.class_name.constantize
+        rescue NameError
+          nil
+        end
+
+        def foreign_key
+          return "" unless @relation.respond_to?(:foreign_key)
+
+          @relation.foreign_key.to_s
+        end
+
+        def polymorphic?
+          return false unless @relation.respond_to?(:polymorphic?)
+
+          @relation.polymorphic?
+        end
+
+        def foreign_type
+          "#{@name}_type"
+        end
+      end
+    end
+  end
+end

data/lib/iron_admin/adapters/mongoid/column_descriptor.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module IronAdmin
+  module Adapters
+    class Mongoid
+      # Uses the shared ColumnDescriptor from Adapters::Base.
+      ColumnDescriptor = IronAdmin::Adapters::Base::ColumnDescriptor
+    end
+  end
+end

data/lib/iron_admin/adapters/mongoid.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+module IronAdmin
+  module Adapters
+    # Mongoid adapter — wraps Mongoid's APIs behind the standard adapter interface.
+    #
+    # This adapter enables IronAdmin to work with MongoDB-backed models.
+    # It implements all abstract methods from Adapters::Base using Mongoid's
+    # query interface, field introspection, and association reflection.
+    #
+    # @example Configuring a resource to use Mongoid
+    #   class ArticleResource < IronAdmin::Resource
+    #     self.adapter_class = :mongoid
+    #   end
+    class Mongoid < Base
+      # Maps Mongoid field types (Ruby classes) to IronAdmin symbol types.
+      MONGOID_TYPE_MAP = {
+        String => :string,
+        Integer => :integer,
+        Float => :float,
+        BigDecimal => :decimal,
+        Date => :date,
+        DateTime => :datetime,
+        Time => :datetime,
+        Hash => :json,
+        Array => :text,
+        Symbol => :string,
+      }.freeze
+
+      # --- Schema Introspection ---
+
+      def columns
+        model_class.fields.values.map do |field|
+          ColumnDescriptor.new(field.name, map_field_type(field))
+        end
+      end
+
+      def column_names
+        model_class.fields.keys
+      end
+
+      def has_column?(name) # rubocop:disable Naming/PredicatePrefix
+        model_class.fields.key?(name.to_s)
+      end
+
+      def enums
+        return model_class.defined_enums if model_class.respond_to?(:defined_enums)
+
+        {}
+      end
+
+      def associations(kind = nil)
+        wrappers = model_class.relations.values.map { |r| AssociationWrapper.new(r) }
+        kind ? wrappers.select { |w| w.macro == kind } : wrappers
+      end
+
+      def association(name)
+        relation = model_class.relations[name.to_s]
+        relation ? AssociationWrapper.new(relation) : nil
+      end
+
+      def attachments
+        {}
+      end
+
+      def rich_text_attributes
+        []
+      end
+
+      def polymorphic_inverse_classes(polymorphic_name)
+        return [] unless defined?(::Mongoid::Document)
+
+        classes = ObjectSpace.each_object(Class).filter_map do |klass|
+          next unless klass < ::Mongoid::Document
+          next unless mongoid_polymorphic_inverse?(klass, polymorphic_name)
+
+          klass
+        end
+
+        classes.sort_by { |klass| klass.name.to_s }
+      end
+
+      # --- Naming ---
+
+      def table_name
+        model_class.collection_name.to_s
+      end
+
+      # Mongoid documents use `_id`. Composite keys are not supported by Mongoid,
+      # so this always returns a String, never an Array.
+      def primary_key
+        "_id"
+      end
+
+      # --- Query Building ---
+
+      delegate :all, to: :model_class
+
+      def find(id)
+        model_class.find(id)
+      rescue StandardError => e
+        raise IronAdmin::RecordNotFound, e.message if not_found_error?(e)
+
+        raise
+      end
+
+      delegate :find_by, to: :model_class
+
+      def filter(scope, column, value)
+        case value
+        when Array
+          scope.in(column => value)
+        when Range
+          build_range_filter(scope, column, value)
+        else
+          scope.where(column => value)
+        end
+      end
+
+      def order_by(scope, column, direction)
+        scope.order_by(column => direction)
+      end
+
+      def limit(scope, max)
+        scope.limit(max)
+      end
+
+      def preload(scope, association_names)
+        scope.includes(*association_names)
+      end
+
+      def distinct_values(column)
+        model_class.distinct(column).compact.sort
+      end
+
+      def pluck(scope, column)
+        scope.pluck(column)
+      end
+
+      def count(scope = nil)
+        (scope || all).count
+      end
+
+      # --- Search ---
+
+      def search_column(scope, column, query)
+        pattern = /#{Regexp.escape(query)}/i
+        scope.where(column => pattern)
+      end
+
+      def search_columns(scope, columns, query)
+        pattern = /#{Regexp.escape(query)}/i
+        conditions = columns.map { |col| { col => pattern } }
+        scope.any_of(*conditions)
+      end
+
+      # --- CRUD ---
+
+      def build(attrs = {})
+        model_class.new(cast_array_attributes(attrs))
+      end
+
+      def save(record)
+        record.save
+      end
+
+      def update(record, attrs)
+        record.update(cast_array_attributes(attrs))
+      end
+
+      def destroy!(record)
+        record.destroy!
+      end
+
+      # --- Transactions ---
+
+      def transaction
+        yield
+      end
+
+      # --- Scope Manipulation ---
+
+      def unscope_column(scope, column)
+        key = column.to_s
+        new_selector = scope.selector.reject { |k, _| k == key }
+        new_scope = model_class.where(new_selector)
+        new_scope = new_scope.order_by(scope.options[:sort]) if scope.options[:sort]
+        new_scope
+      end
+
+      # --- Batch ---
+
+      def find_each(scope, &)
+        scope.batch_size(100).each(&)
+      end
+
+      # --- Adapter-Agnostic Interface ---
+
+      def record_changes(record)
+        record.previous_changes
+      end
+
+      def wrap_rollback
+        yield
+      rescue IronAdmin::Rollback
+        # Silently absorb rollback — Mongoid transactions (if used)
+        # are handled separately
+        nil
+      end
+
+      def query_builder_class
+        IronAdmin::Filters::MongoidQueryBuilder
+      end
+
+      def pagy_method
+        :pagy_mongoid
+      end
+
+      private
+
+      def map_field_type(field)
+        return :string if field.name == "_id"
+
+        MONGOID_TYPE_MAP.fetch(field.type) { boolean_or_text(field.type) }
+      end
+
+      def cast_array_attributes(attrs)
+        return attrs unless attrs.respond_to?(:each_pair)
+
+        attrs.each_pair.with_object(attrs.dup) do |(key, value), casted|
+          next unless array_field?(key) && value.is_a?(String)
+
+          casted[key] = value.split(",").map(&:strip).compact_blank
+        end
+      end
+
+      def array_field?(key)
+        model_class.fields[key.to_s]&.type == Array
+      end
+
+      def build_range_filter(scope, column, range)
+        conditions = {}
+        conditions["$gte"] = range.begin if range.begin
+        conditions["$lte"] = range.end if range.end
+        scope.where(column.to_s => conditions)
+      end
+
+      def not_found_error?(error)
+        error.class.name.include?("NotFound") ||
+          error.class.name.include?("DocumentNotFound") ||
+          error.message.include?("not found")
+      end
+
+      def boolean_or_text(type)
+        return :boolean if boolean_type?(type)
+
+        :text
+      end
+
+      def boolean_type?(type)
+        type_name = type.respond_to?(:name) ? type.name.to_s : type.to_s
+        type_name.include?("Boolean") || type == TrueClass || type == FalseClass
+      end
+
+      def mongoid_polymorphic_inverse?(klass, polymorphic_name)
+        return false unless klass.respond_to?(:relations)
+
+        klass.relations.values.any? do |relation|
+          next false unless %i[has_many has_one].include?(relation.macro)
+
+          relation_options(relation)[:as]&.to_sym == polymorphic_name.to_sym
+        end
+      end
+
+      def relation_options(relation)
+        relation.respond_to?(:options) ? relation.options : {}
+      end
+    end
+  end
+end
+
+require_relative "mongoid/column_descriptor"
+require_relative "mongoid/association_wrapper"
+require_relative "../filters/mongoid_query_builder"

data/lib/iron_admin/adapters/registry.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module IronAdmin
+  module Adapters
+    # Lazily loads and resolves adapter classes by identifier.
+    #
+    # Adapters are loaded on demand to avoid requiring unnecessary ORM
+    # dependencies. ActiveRecord apps never load Mongoid code and vice versa.
+    #
+    # @example Resolving an adapter
+    #   IronAdmin::Adapters::Registry.resolve(:active_record)
+    #   #=> IronAdmin::Adapters::ActiveRecord
+    #
+    # @example Using a custom adapter (pass the class directly to adapter_class)
+    #   self.adapter_class = MyGem::IronAdminAdapter
+    module Registry
+      ADAPTERS = {
+        active_record: {
+          require_path: "iron_admin/adapters/active_record",
+          class_name: "IronAdmin::Adapters::ActiveRecord",
+        },
+        mongoid: {
+          require_path: "iron_admin/adapters/mongoid",
+          class_name: "IronAdmin::Adapters::Mongoid",
+        },
+        http: {
+          require_path: "iron_admin/adapters/http",
+          class_name: "IronAdmin::Adapters::Http",
+        },
+      }.freeze
+
+      # Resolves an adapter identifier to its class.
+      #
+      # @param identifier [Symbol] The adapter identifier (e.g., :active_record, :mongoid)
+      # @return [Class] The adapter class
+      # @raise [ArgumentError] If the identifier is not registered
+      def self.resolve(identifier)
+        entry = ADAPTERS.fetch(identifier) { raise ArgumentError, "Unknown adapter: #{identifier}" }
+        require entry[:require_path]
+        entry[:class_name].constantize
+      end
+    end
+  end
+end

data/lib/iron_admin/concerns/importable.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module IronAdmin
+  module Concerns
+    module Importable
+      extend ActiveSupport::Concern
+
+      module ImportDsl
+        def imports(*formats)
+          self.import_formats = formats.flatten.map(&:to_sym)
+        end
+
+        def import_enabled?
+          import_formats.any?
+        end
+
+        def import_fields(*fields)
+          self.import_field_names = fields.map(&:to_sym)
+        end
+
+        def import_upsert_key(*fields)
+          self.import_upsert_key_names = fields.map(&:to_sym)
+        end
+
+        def import_transform(&block)
+          self.import_transform_block = block
+        end
+
+        def import_validate(&block)
+          self.import_validate_block = block
+        end
+
+        def import_options(**options)
+          self.import_options_hash = import_options_hash.merge(options)
+        end
+
+        def importable_fields(current_user = nil)
+          import_base_fields
+            .select { |field| field.visible?(current_user) && !field.readonly?(current_user) }
+            .reject { |field| import_excluded_field_type?(field.type) }
+        end
+
+        private
+
+        def import_base_fields
+          return resolved_fields.select { |field| field.name.in?(import_field_names) } if import_field_names
+
+          resolved_fields.reject { |field| field.name.in?(%i[id created_at updated_at]) }
+        end
+
+        def import_excluded_field_type?(field_type)
+          field_type.in?(
+            %i[
+              belongs_to
+              polymorphic_belongs_to
+              has_many
+              has_one
+              has_and_belongs_to_many
+              file
+              files
+              rich_text
+            ]
+          )
+        end
+      end
+
+      included do
+        class_attribute :import_formats, default: []
+        class_attribute :import_field_names, default: nil
+        class_attribute :import_upsert_key_names, default: []
+        class_attribute :import_transform_block, default: nil
+        class_attribute :import_validate_block, default: nil
+        class_attribute :import_options_hash, default: { max_rows: 5_000, preview_rows: 20 }
+      end
+
+      class_methods do
+        include ImportDsl
+      end
+    end
+  end
+end

data/lib/iron_admin/concerns/live_updatable.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module IronAdmin
+  module Concerns
+    module LiveUpdatable
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :live_index_enabled, default: false
+        class_attribute :live_show_enabled, default: false
+      end
+
+      class_methods do
+        def live_index(value = nil, enabled: true)
+          self.live_index_enabled = value.nil? ? enabled : value
+        end
+
+        def live_show(value = nil, enabled: true)
+          self.live_show_enabled = value.nil? ? enabled : value
+        end
+
+        def live_index_enabled?
+          !!live_index_enabled
+        end
+
+        def live_show_enabled?
+          !!live_show_enabled
+        end
+
+        def live_stream_name(scope, record_id = nil)
+          parts = ["resources", resource_name, scope]
+          parts << record_id if record_id
+          parts.join(":")
+        end
+      end
+    end
+  end
+end

data/lib/iron_admin/concerns/nestable.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module IronAdmin
+  module Concerns
+    # Provides nested association support for Resource classes.
+    #
+    # Extends has_many/has_one with nested: kwargs, adds nested_associations
+    # reader, and field resolution.
+    module Nestable
+      extend ActiveSupport::Concern
+
+      # DSL methods for declaring has_many/has_one with nested options.
+      module AssociationDsl
+        def has_many(name, nested: false, allow_destroy: true, position_field: nil, fields: nil, **options)
+          self.defined_associations = defined_associations.merge(
+            name => {
+              kind: :has_many, nested: nested, allow_destroy: allow_destroy,
+              position_field: position_field&.to_sym, fields: fields&.map(&:to_sym), **options,
+            }
+          )
+        end
+
+        def has_one(name, nested: false, allow_destroy: true, fields: nil, **options)
+          self.defined_associations = defined_associations.merge(
+            name => {
+              kind: :has_one, nested: nested, allow_destroy: allow_destroy,
+              fields: fields&.map(&:to_sym), **options,
+            }
+          )
+        end
+      end
+
+      # Reader and resolver for nested associations.
+      module NestedReader
+        def nested_associations
+          defined_associations.select { |_, v| v[:nested] }.map do |assoc_name, config|
+            reflection = adapter.association(assoc_name)
+            raise ArgumentError, "Unknown association #{assoc_name} for #{model.name}" unless reflection
+
+            NestedAttributesValidator.validate!(model, assoc_name)
+            fields = resolve_nested_fields(config, reflection.klass, reflection.foreign_key)
+
+            NestedAssociation.new(
+              name: assoc_name, kind: config[:kind], reflection: reflection,
+              fields: fields, allow_destroy: config.fetch(:allow_destroy, true),
+              position_field: config[:position_field]
+            )
+          end
+        end
+
+        private
+
+        def resolve_nested_fields(config, assoc_model, foreign_key)
+          if config[:fields]
+            FieldInferrer.call(assoc_model).select { |f| config[:fields].include?(f.name) }
+          else
+            skip = %i[id created_at updated_at] + [foreign_key.to_sym]
+            FieldInferrer.call(assoc_model).reject { |f| skip.include?(f.name) }
+          end
+        end
+      end
+
+      class_methods do
+        include AssociationDsl
+        include NestedReader
+      end
+    end
+  end
+end

data/lib/iron_admin/concerns/soft_deletable.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module IronAdmin
+  module Concerns
+    # Adds the auto-registered soft-delete features (`with_deleted` /
+    # `only_deleted` scopes and the `:restore` action) when the underlying
+    # model has a `deleted_at` column.
+    #
+    # Extracted from `IronAdmin::Resource` so the registration logic can
+    # evolve independently — and so the parent class stays under the
+    # configured `Metrics/ClassLength` budget.
+    module SoftDeletable
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # @return [Boolean] True if the model has a `deleted_at` column.
+        def soft_delete?
+          adapter.has_column?(soft_delete_column)
+        end
+
+        # @return [String] Column name used for soft-delete tracking.
+        def soft_delete_column
+          "deleted_at"
+        end
+
+        # Idempotently registers soft-delete scopes and the `:restore`
+        # action on this resource. Tolerates a missing/unreachable DB at
+        # boot time so `bin/rails db:create` and short outages during
+        # deploy don't crash boot — the skip is logged. Safe to call
+        # multiple times: the negative result is cached too so we don't
+        # re-introspect the schema on every register / finalize! cycle.
+        #
+        # @return [void]
+        def register_soft_delete_features
+          return if @soft_delete_features_registered
+          return @soft_delete_features_registered = true unless soft_delete?
+
+          column = soft_delete_column
+          column_sym = column.to_sym
+
+          self._soft_delete_scopes = [
+            { name: :with_deleted, scope: -> { unscope(where: column_sym) }, default: false },
+            { name: :only_deleted, scope: -> { unscope(where: column_sym).where.not(column => nil) }, default: false },
+          ]
+
+          action :restore, icon: "arrow-path", condition: ->(record) { record.public_send(column).present? } do |record|
+            record.update(column => nil)
+          end
+
+          @soft_delete_features_registered = true
+        rescue *IronAdmin.db_unreachable_exceptions => e
+          msg = "[IronAdmin] Skipping soft-delete features for #{name}: #{e.class} (#{e.message})"
+          (defined?(Rails) ? Rails.logger : nil)&.warn(msg)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/iron_admin/configuration.rb

@@ -81,6 +81,21 @@ module IronAdmin
     # @return [Boolean] Whether the actions column stays fixed on horizontal scroll (default: true)
     attr_accessor :sticky_actions_column
 
+    # @return [String, nil] Base URL for HTTP adapter (e.g., "https://api.example.com/v1")
+    attr_accessor :http_base_url
+
+    # @return [Hash] Default headers for HTTP adapter (e.g., auth tokens)
+    attr_accessor :http_headers
+
+    # @return [Symbol] Live update strategy (:disabled or :polling)
+    attr_accessor :live_updates
+
+    # @return [ActiveSupport::Duration] Client polling interval for live updates
+    attr_accessor :live_poll_interval
+
+    # @return [ActiveSupport::Duration] Minimum interval between live broadcasts
+    attr_accessor :live_throttle
+
     # @return [Proc, nil] Authentication block
     # @see #authenticate
     attr_reader :authenticate_block
@@ -171,6 +186,11 @@ module IronAdmin
       @audit_enabled = false
       @audit_storage = :memory
       @sticky_actions_column = true
+      @http_base_url = nil
+      @http_headers = {}
+      @live_updates = :disabled
+      @live_poll_interval = 3.seconds
+      @live_throttle = 0.5.seconds
     end
 
     # Defines the authentication check for admin access.