forest_admin_rails 1.0.0.pre.beta.24 → 1.44.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9b5e4f2f320d600fafe2f81248d1cb9fe102af50b52d6b738eeeb4386a650ef
-  data.tar.gz: 8165afae5fb531f0f6f3dd24bd12d9de75f15dc027e16241e7311364df6d612e
+  metadata.gz: d50d0efa3697bb50f9245de346218cba23f20d4656d1b911e1288d8458f36fe7
+  data.tar.gz: 37cc1bb7b839d70a1a657b4a789c09c91c25f7e4d88301bfc93d00f1d63e4f63
 SHA512:
-  metadata.gz: 63b9074b36320f95439b315d2f71b3abb806e75aaa6e8289576a60d1c031cdcaaa7765e289e60fa926e6d3b20772bc51efc2eb6d9e8277109a266ea75ba0cc27
-  data.tar.gz: fa8017a8c2daa7ca4bd4c9d32675e04e273589962316bec2a4bcf819c4a5f1452d467ad278571a5fd84abbff533f66fc1480a8a876d6f3a651ba924cedb7d13f
+  metadata.gz: e9e9afe36b09214d3c7e7a2554ddc45bd57c5e2362ecfcdb91038b1cdc87387f2f06833ec2919faecfce28f24da563bbe521d7fa8497a982067ac9dda530bafd
+  data.tar.gz: 8e5bb1355764c22cb9d15873dfc2ece91a4efaf9d2b6271729863dea4b194706dbc44ba5dadfb228d79aecd51cfdc0b971d105068e09a5cbffb98c89a1b3c0cb

data/app/controllers/forest_admin_rails/forest_controller.rb

@@ -1,14 +1,29 @@
+require 'jsonapi-serializers'
+require 'openid_connect'
+
 module ForestAdminRails
   class ForestController < ActionController::Base
+    include ForestAdminAgent::Http
+
     skip_forgery_protection
 
     def index
-      if ForestAdminAgent::Http::Router.routes.key? params['route_alias']
-        route = ForestAdminAgent::Http::Router.routes[params['route_alias']]
+      if ForestAdminAgent::Http::Router.cached_routes.key? params['route_alias']
+        route = ForestAdminAgent::Http::Router.cached_routes[params['route_alias']]
 
         begin
-          forest_response route[:closure].call({ params: params.to_unsafe_h, headers: request.headers.to_h })
-        rescue StandardError => e
+          forest_response route[:closure].call(
+            {
+              params: params.to_unsafe_h,
+              headers: request.headers.to_h,
+              # Raw request context for verbatim-forwarding routes (workflow executor proxy);
+              # other routes ignore these keys.
+              method: request.request_method,
+              query_string: request.query_string,
+              body: request.raw_post
+            }
+          )
+        rescue StandardError, JSONAPI::Serializer::Error => e
           exception_handler e
         end
       else
@@ -17,35 +32,79 @@ module ForestAdminRails
     end
 
     def forest_response(data = {})
-      render json: data[:content], status: data[:status] || 200
+      if data[:content].is_a?(Hash)
+        # Handle streaming responses (NEW)
+        return handle_streaming_response(data) if data.dig(:content, :type) == 'Stream'
+
+        if data.dig(:content, :type) == 'File'
+          response.headers['Access-Control-Expose-Headers'] = 'Content-Disposition'
+          return send_data data[:content][:stream], filename: data[:content][:name], type: data[:content][:mime_type],
+                                                    disposition: 'attachment'
+        end
+
+        if data.dig(:content, :headers)
+          response.headers.merge!(data[:content][:headers] || {})
+          data[:content].delete(:headers)
+        end
+      end
+
+      # Proxy routes expose response headers at the root (their `content` is the rendered body,
+      # so headers can't nest under it like Stream/File do).
+      response.headers.merge!(data[:headers]) if data[:headers].is_a?(Hash)
+
+      respond_to do |format|
+        format.json { render json: data[:content], status: data[:status] || data[:content][:status] || 200 }
+        format.csv { render plain: data[:content][:export], status: 200, filename: data[:filename] }
+      end
+    end
+
+    private
+
+    # Handle streaming response (enumerator-based)
+    def handle_streaming_response(data)
+      enumerator = data[:content][:enumerator]
+      headers = data[:content][:headers] || {}
+
+      # Merge headers
+      response.headers.merge!(headers)
+
+      # Set response status
+      response.status = data[:status] || 200
+
+      # Stream the enumerator
+      # Rails will automatically use chunked transfer encoding
+      self.response_body = enumerator
     end
 
     def exception_handler(exception)
-      if exception.is_a? ForestAdminAgent::Http::Exceptions::AuthenticationOpenIdClient
-        data = {
-          error: exception.error,
-          error_description: exception.error_description,
-          state: exception.state
-        }
-      else
-        data = {
-          errors: [
-            {
-              name: exception.name,
-              detail: exception.message,
-              status: exception.try(:status)
-            }
-          ]
-        }
+      http_exception = ErrorTranslator.translate(exception)
 
-        data[:errors][0][:data] = exception.try(:data)
+      response.headers.merge!(http_exception.custom_headers || {})
 
-        # TODO: IMPLEMENT LOGGING
-        # if Facades::Container.cache(:is_production)
-        # end
-      end
+      data = case exception
+             when ForestAdminAgent::Http::Exceptions::AuthenticationOpenIdClient,
+               OpenIDConnect::Exception
+               {
+                 error: exception.message,
+                 error_description: exception.response,
+                 state: http_exception.status
+               }
+             else
+               {
+                 errors: [
+                   {
+                     name: http_exception.name,
+                     detail: http_exception.message,
+                     status: http_exception.status,
+                     data: http_exception.data
+                   }.compact
+                 ]
+               }
+             end
+
+      ForestAdminAgent::Facades::Container.logger.log('Error', exception.full_message) if http_exception.status >= 500
 
-      render json: data, status: exception.try(:status)
+      render json: data, status: http_exception.status
     end
   end
 end

data/config/initializers/forest_admin_error_subscriber.rb

@@ -0,0 +1,12 @@
+class ForestAdminErrorSubscriber
+  SEVERITY_TO_LEVEL = {
+    error: 'Error',
+    warning: 'Warn',
+    info: 'Info'
+  }.freeze
+
+  def report(error, handled:, severity:, context:, source: nil)
+    level = SEVERITY_TO_LEVEL.fetch(severity, 'Error')
+    ForestAdminAgent::Facades::Container.logger.log(level, "[ForestAdmin] #{error.full_message}")
+  end
+end

data/config/initializers/forest_admin_route_cache.rb

@@ -0,0 +1,11 @@
+# Route pre-caching has been moved to engine.rb after agent.build() completes
+#
+# This initializer is kept for informational purposes only
+if defined?(ForestAdminAgent::Http::Router)
+  cache_disabled = ForestAdminAgent::Http::Router.cache_disabled?
+
+  if cache_disabled
+    Rails.logger.warn('[ForestAdmin] Route caching is DISABLED - this will impact performance')
+    Rails.logger.warn('[ForestAdmin] To enable caching, remove disable_route_cache: true from configuration')
+  end
+end

data/config/routes.rb

@@ -1,5 +1,25 @@
 ForestAdminRails::Engine.routes.draw do
-  ForestAdminAgent::Http::Router.routes.each do |name, agent_route|
-    match agent_route[:uri], to: 'forest#index', via: agent_route[:method], as: name, route_alias: name
+  next if defined?(Rake) && Rake.respond_to?(:application) && Rake.application&.top_level_tasks&.any?
+
+  # Don't load routes if the agent hasn't been set up (e.g., during tests)
+  next unless ForestAdminAgent::Builder::AgentFactory.instance.container
+
+  scope '/forest' do
+    # Use cached_routes to avoid recomputing routes during Rails route initialization
+    ForestAdminAgent::Http::Router.cached_routes.each do |name, agent_route|
+      match agent_route[:uri],
+            defaults: { format: agent_route[:format] },
+            to: 'forest#index',
+            via: agent_route[:method],
+            as: name,
+            route_alias: name,
+            constraints: { id: /[a-zA-Z0-9.-]*+/ }
+    end
+  rescue StandardError => e
+    if defined?(Rails) && Rails.logger
+      Rails.logger.error("[ForestAdmin] CRITICAL: Failed to initialize routes: #{e.class} - #{e.message}")
+      Rails.logger.error(e.backtrace.join("\n"))
+    end
+    raise e
   end
 end

data/lib/forest_admin/types.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+# Ensure dependencies are fully loaded before referencing their constants
+require 'forest_admin_datasource_toolkit'
+require 'forest_admin_datasource_customizer'
+require 'forest_admin_agent'
+
+# ForestAdmin::Types provides a convenient way to access commonly-used classes
+# from ForestAdmin packages without requiring multiple includes.
+#
+# Usage:
+#   include ForestAdmin::Types
+#
+#   # Now you can use short class names:
+#   ConditionTreeLeaf.new('status', Operators::EQUAL, 'active')
+#   Filter.new(condition_tree: tree)
+#   Aggregation.new(operation: 'Count', field: 'id')
+#
+#   # In action blocks, result_builder is an ActionResultBuilder:
+#   result_builder.success(message: 'Done!')
+#   result_builder.file(content: data, name: 'export.csv')
+#
+#   # In chart blocks, result_builder is a ChartResultBuilder:
+#   result_builder.value(42)
+#   result_builder.distribution({ 'Active' => 10, 'Inactive' => 5 })
+#
+#   # Factory classes for building complex objects:
+#   tree = ConditionTreeFactory.from_plain_object({ field: 'status', operator: 'equal', value: 'active' })
+#   filter = ConditionTreeFactory.match_ids(collection, [1, 2, 3])
+#   combined = ConditionTreeFactory.intersect([tree1, tree2])
+#   projection = ProjectionFactory.all(collection)
+#   sort = SortFactory.by_primary_keys(collection)
+#
+#   # Exception handling in hooks and actions:
+#   raise ValidationError.new('Invalid input') if invalid?
+#   raise ForbiddenError.new('Access denied') unless authorized?
+#   raise UnprocessableError.new('Cannot process request')
+#
+#   # Context classes for different handlers:
+#   # - ChartContext: context.get_record(['field1', 'field2'])
+#   # - HookContext: context.raise_validation_error('Error message')
+#
+module ForestAdmin
+  module Types
+    # ============================================
+    # Query Components
+    # ============================================
+
+    # Filter - used to filter records in queries
+    Filter = ForestAdminDatasourceToolkit::Components::Query::Filter
+
+    # Aggregation - used for aggregate operations (Count, Sum, Avg, etc.)
+    Aggregation = ForestAdminDatasourceToolkit::Components::Query::Aggregation
+
+    # Projection - specifies which fields to retrieve
+    Projection = ForestAdminDatasourceToolkit::Components::Query::Projection
+
+    # Page - pagination parameters
+    Page = ForestAdminDatasourceToolkit::Components::Query::Page
+
+    # Sort - sorting parameters
+    Sort = ForestAdminDatasourceToolkit::Components::Query::Sort
+
+    # ============================================
+    # Condition Tree
+    # ============================================
+
+    # ConditionTreeLeaf - a single condition (field, operator, value)
+    ConditionTreeLeaf = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes::ConditionTreeLeaf
+
+    # ConditionTreeBranch - combines multiple conditions with And/Or
+    ConditionTreeBranch = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Nodes::ConditionTreeBranch
+
+    # Operators - all available operators (EQUAL, GREATER_THAN, CONTAINS, etc.)
+    Operators = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::Operators
+
+    # ============================================
+    # Action Types
+    # ============================================
+
+    # FieldType - field types for action forms (STRING, NUMBER, BOOLEAN, etc.)
+    FieldType = ForestAdminDatasourceCustomizer::Decorators::Action::Types::FieldType
+
+    # ActionScope - action scopes (SINGLE, BULK, GLOBAL)
+    ActionScope = ForestAdminDatasourceCustomizer::Decorators::Action::Types::ActionScope
+
+    # BaseAction - base class for defining actions
+    BaseAction = ForestAdminDatasourceCustomizer::Decorators::Action::BaseAction
+
+    # ============================================
+    # Action Contexts
+    # ============================================
+
+    # ActionContext - execution context for Bulk/Global actions
+    ActionContext = ForestAdminDatasourceCustomizer::Decorators::Action::Context::ActionContext
+
+    # ActionContextSingle - execution context for Single actions
+    ActionContextSingle = ForestAdminDatasourceCustomizer::Decorators::Action::Context::ActionContextSingle
+
+    # ActionResultBuilder - builder for action results (success, error, file, webhook)
+    ActionResultBuilder = ForestAdminDatasourceCustomizer::Decorators::Action::ResultBuilder
+
+    # ============================================
+    # Charts
+    # ============================================
+
+    # ChartResultBuilder - builder for chart results (value, distribution, time_based, etc.)
+    ChartResultBuilder = ForestAdminDatasourceCustomizer::Decorators::Chart::ResultBuilder
+
+    # ============================================
+    # Computed Fields
+    # ============================================
+
+    # ComputedDefinition - defines computed/virtual fields
+    ComputedDefinition = ForestAdminDatasourceCustomizer::Decorators::Computed::ComputedDefinition
+
+    # ============================================
+    # User/Caller Information
+    # ============================================
+
+    # Caller - represents the user making the request (email, timezone, team, etc.)
+    Caller = ForestAdminDatasourceToolkit::Components::Caller
+
+    # ============================================
+    # Plugins
+    # ============================================
+
+    # Plugin - base class for creating custom plugins
+    Plugin = ForestAdminDatasourceCustomizer::Plugins::Plugin
+
+    # ActiveStoragePlugin - plugin to expose Active Storage attachments as File fields
+    # Lazy-loaded because Zeitwerk may not have autoloaded it yet when types.rb is required
+    def self.const_missing(name)
+      if name == :ActiveStoragePlugin
+        require 'forest_admin_rails/plugins/active_storage'
+        const_set(:ActiveStoragePlugin, ForestAdminRails::Plugins::ActiveStorage)
+      else
+        super
+      end
+    end
+
+    # ============================================
+    # Additional Context Classes
+    # ============================================
+
+    # ChartContext - execution context for chart handlers
+    # Methods: get_record(fields), record_id, composite_record_id
+    ChartContext = ForestAdminDatasourceCustomizer::Decorators::Chart::ChartContext
+
+    # HookContext - execution context for hook handlers
+    # Methods: raise_validation_error, raise_forbidden_error, raise_error
+    HookContext = ForestAdminDatasourceCustomizer::Decorators::Hook::Context::HookContext
+
+    # ============================================
+    # Exception Classes
+    # ============================================
+
+    # BusinessError - base class for all business errors
+    BusinessError = ForestAdminAgent::Http::Exceptions::BusinessError
+
+    # Specific error types for better error handling
+    ValidationError = ForestAdminAgent::Http::Exceptions::ValidationError
+    ForbiddenError = ForestAdminAgent::Http::Exceptions::ForbiddenError
+    UnauthorizedError = ForestAdminAgent::Http::Exceptions::UnauthorizedError
+    NotFoundError = ForestAdminAgent::Http::Exceptions::NotFoundError
+    UnprocessableError = ForestAdminAgent::Http::Exceptions::UnprocessableError
+    BadRequestError = ForestAdminAgent::Http::Exceptions::BadRequestError
+
+    # ============================================
+    # Factory Classes
+    # ============================================
+
+    # ConditionTreeFactory - factory methods for creating condition trees
+    # Methods: from_plain_object, match_ids, match_records, intersect, union, match_none
+    ConditionTreeFactory = ForestAdminDatasourceToolkit::Components::Query::ConditionTree::ConditionTreeFactory
+
+    # FilterFactory - factory methods for creating filters
+    # Methods: from_plain_object, make_foreign_filter, make_through_filter
+    FilterFactory = ForestAdminDatasourceToolkit::Components::Query::FilterFactory
+
+    # ProjectionFactory - factory methods for creating projections
+    # Methods: all(collection)
+    ProjectionFactory = ForestAdminDatasourceToolkit::Components::Query::ProjectionFactory
+
+    # SortFactory - factory methods for creating sort clauses
+    # Methods: by_primary_keys(collection)
+    SortFactory = ForestAdminDatasourceToolkit::Components::Query::SortUtils::SortFactory
+
+    # ============================================
+    # Module inclusion support
+    # ============================================
+
+    def self.included(base)
+      # When included, define constants on the including class/module
+      # This allows using `include ForestAdmin::Types` and then referencing
+      # the types directly without the ForestAdmin::Types prefix
+      constants.each do |const_name|
+        base.const_set(const_name, const_get(const_name)) unless base.const_defined?(const_name)
+      end
+    end
+  end
+end

data/lib/forest_admin_rails/engine.rb

@@ -22,35 +22,109 @@ module ForestAdminRails
   class Engine < ::Rails::Engine
     isolate_namespace ForestAdminRails
 
+    extend ActiveSupport::Concern
+
+    initializer 'forest_admin_rails.error_subscribe' do
+      Rails.error.subscribe(ForestAdminErrorSubscriber.new)
+    end
+
     config.after_initialize do
-      agent_factory = ForestAdminAgent::Builder::AgentFactory.instance
-      agent_factory.setup(ForestAdminRails.config)
-      load_configuration
-      load_cors
+      Rails.error.handle(ForestAdminDatasourceToolkit::Exceptions::ForestException, severity: :error) do
+        agent_factory = ForestAdminAgent::Builder::AgentFactory.instance
+        agent_factory.setup(ForestAdminRails.config)
+        load_configuration
+        load_cors
+        load_correlation_id
+      end
+    end
+
+    # Echo the agent-generated correlation id on every response (mirrors the Node agent's
+    # router.use(correlationIdMiddleware)); CORS exposure of the header is handled in load_cors.
+    #
+    # Ahead of ShowExceptions rather than at the end of the stack: a Rack middleware can only add a header
+    # to a response it sees returned, so sitting under the exception handlers meant error responses they
+    # build on the way out never carried the id.
+    def load_correlation_id
+      middleware = ForestAdminAgent::Http::CorrelationIdMiddleware
+
+      begin
+        # The application's stack, not the engine's: ShowExceptions lives there, and an
+        # insert_before recorded on the engine's own (empty) proxy raises when it is applied.
+        Rails.application.config.middleware.insert_before ActionDispatch::ShowExceptions, middleware
+      rescue StandardError
+        # No ShowExceptions in this stack (or already gone): the id still reaches every response the app
+        # returns normally.
+        config.middleware.use middleware
+      end
     end
 
     def load_configuration
-      return unless File.exist?(Rails.root.join('lib', 'forest_admin_rails', 'create_agent.rb'))
+      return unless running_web_server?
+      return unless create_agent_file_exists?
 
       # force eager loading models
       Rails.application.eager_load!
 
-      # setup agent
-      require Rails.root.join('lib', 'forest_admin_rails', 'create_agent.rb')
-      ForestAdminRails::CreateAgent.setup!
+      require create_agent_path.to_s
+
+      setup_agent_and_cache_routes
 
       sse = ForestAdminAgent::Services::SSECacheInvalidation
       sse.run if ForestAdminRails.config[:instant_cache_refresh]
     end
 
+    def create_agent_path
+      Rails.root.join('lib', 'forest_admin_rails', 'create_agent.rb')
+    end
+
+    def create_agent_file_exists?
+      File.exist?(create_agent_path)
+    end
+
+    def setup_agent_and_cache_routes
+      ForestAdminRails::CreateAgent.setup!
+      precache_routes
+    rescue StandardError => e
+      logger = ActiveSupport::Logger.new($stdout)
+      logger.warn 'An error has occurred during setup of the Forest Admin agent.'
+      raise e.message
+    end
+
+    def precache_routes
+      return if ForestAdminAgent::Http::Router.cache_disabled?
+
+      start_time = Time.now
+      routes = ForestAdminAgent::Http::Router.cached_routes
+      elapsed = ((Time.now - start_time) * 1000).round(2)
+
+      logger = ActiveSupport::Logger.new($stdout)
+      logger.info("[ForestAdmin] Successfully pre-cached #{routes.size} routes in #{elapsed}ms")
+    end
+
+    def running_web_server?
+      return true if defined?(::Rails::Server)
+
+      # check if a web server is running with the given command line arguments
+      server_commands = %w[puma unicorn thin passenger rackup]
+      return true if server_commands.any? { |cmd| ARGV.any? { |arg| arg.include?(cmd) } }
+
+      # check if running via common server executables
+      return true if $PROGRAM_NAME.match?(/puma|unicorn|thin|passenger/)
+
+      false
+    end
+
     def load_cors
+      return if ENV['FOREST_CORS_DEACTIVATED']
+
       config.middleware.insert_before 0, Rack::Cors do
         allow do
           hostnames = [/\A.*\.forestadmin\.com\z/]
           hostnames += ENV['CORS_ORIGINS'].split(',') if ENV['CORS_ORIGINS']
 
           origins hostnames
-          resource '*', headers: :any, methods: :any, credentials: true, max_age: 86_400
+          resource '*', headers: :any, methods: :any, credentials: true, max_age: 86_400,
+                        expose: [ForestAdminAgent::Http::CorrelationId::HEADER]
         end
       end
     end

data/lib/forest_admin_rails/plugins/active_storage.rb

@@ -0,0 +1,130 @@
+require 'base64'
+require 'cgi'
+require 'rack/mime'
+
+module ForestAdminRails
+  module Plugins
+    class ActiveStorage < ForestAdminDatasourceCustomizer::Plugins::Plugin
+      ACTIVE_STORAGE_COLLECTIONS = %w[
+        ActiveStorage__Attachment
+        ActiveStorage__Blob
+        ActiveStorage__VariantRecord
+      ].freeze
+
+      def run(datasource_customizer, _collection_customizer = nil, options = {})
+        datasource_customizer.collections.each do |name, collection|
+          next if options[:only] && !options[:only].include?(name)
+          next if options[:except]&.include?(name)
+
+          add_attachment_fields(collection, options)
+        end
+
+        remove_active_storage_collections(datasource_customizer) if options.fetch(:hide_internal_collections, true)
+      end
+
+      private
+
+      def remove_active_storage_collections(datasource_customizer)
+        ACTIVE_STORAGE_COLLECTIONS.each do |collection_name|
+          next unless datasource_customizer.collections.key?(collection_name)
+
+          datasource_customizer.remove_collection(collection_name)
+        end
+      end
+
+      def add_attachment_fields(collection, options)
+        model_class = find_model_class(collection)
+        return unless model_class
+        return unless defined?(::ActiveStorage) && model_class.respond_to?(:reflect_on_all_attachments)
+
+        model_class.reflect_on_all_attachments
+                   .select { |a| a.macro == :has_one_attached }
+                   .each do |attachment|
+          name = attachment.name.to_s
+          hide_attachment_relations(collection, name)
+          add_file_field(collection, model_class, name, options.fetch(:download_images_on_list, false))
+        end
+      end
+
+      def hide_attachment_relations(collection, attachment_name)
+        %W[#{attachment_name}_attachment #{attachment_name}_blob].each do |relation_name|
+          next unless collection.schema[:fields].key?(relation_name)
+
+          collection.remove_field(relation_name)
+        end
+      end
+
+      def add_file_field(collection, model_class, attachment_name, download_images_on_list)
+        return if collection.schema[:fields][attachment_name]
+
+        collection.add_field(attachment_name,
+                             ForestAdminDatasourceCustomizer::Decorators::Computed::ComputedDefinition.new(
+                               column_type: 'File',
+                               dependencies: ['id'],
+                               values: lambda { |records, _ctx|
+                                 compute_values(records, model_class, attachment_name, download_images_on_list)
+                               }
+                             ))
+
+        collection.replace_field_writing(attachment_name) do |value, context|
+          handle_write(value, context, model_class, attachment_name)
+        end
+      end
+
+      def compute_values(records, model_class, attachment_name, download_images_on_list)
+        ids = records.map { |r| r['id'] }
+        models = model_class
+                 .where(id: ids)
+                 .includes(:"#{attachment_name}_attachment", :"#{attachment_name}_blob")
+                 .index_by(&:id)
+
+        records.map do |record|
+          model = models[record['id']]
+          next nil unless model&.public_send(attachment_name)&.attached?
+
+          blob = model.public_send(attachment_name).blob
+
+          if records.length == 1 || (download_images_on_list && blob.content_type&.start_with?('image/'))
+            content = blob.download
+            "data:#{blob.content_type};name=#{CGI.escape(blob.filename.to_s)};base64,#{Base64.strict_encode64(content)}"
+          else
+            "data:#{blob.content_type};name=#{CGI.escape(blob.filename.to_s)};base64,"
+          end
+        end
+      end
+
+      def handle_write(value, context, model_class, attachment_name)
+        record_id = context.filter&.condition_tree&.value
+        return {} unless record_id
+
+        record = model_class.find(record_id)
+
+        if value.nil? || value.to_s.strip.empty?
+          record.public_send(attachment_name).purge if record.public_send(attachment_name).attached?
+        else
+          parsed = ForestAdminAgent::Utils::Schema::ForestValueConverter.parse_data_uri(value)
+          if parsed
+            fallback_extension = Rack::Mime::MIME_TYPES.invert[parsed['mime_type']] || '.bin'
+            record.public_send(attachment_name).attach(
+              io: StringIO.new(parsed['buffer']),
+              filename: parsed['name'] || "#{attachment_name}#{fallback_extension}",
+              content_type: parsed['mime_type']
+            )
+          end
+        end
+        {}
+      end
+
+      def find_model_class(collection)
+        current = collection.respond_to?(:collection) ? collection.collection : collection
+        loop do
+          return current.model if current.respond_to?(:model) && current.model.is_a?(Class)
+          break unless current.respond_to?(:child_collection)
+
+          current = current.child_collection
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/forest_admin_rails/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminRails
-  VERSION = "1.0.0-beta.24"
+  VERSION = "1.44.4"
 end

data/lib/forest_admin_rails.rb

@@ -4,9 +4,11 @@ require 'forest_admin_rails/engine'
 require 'zeitwerk'
 require 'rails/railtie'
 require 'forest_admin_agent'
+require_relative 'forest_admin/types'
 
 loader = Zeitwerk::Loader.for_gem
 loader.ignore("#{__dir__}/generators")
+loader.ignore("#{__dir__}/forest_admin")
 loader.setup
 
 module ForestAdminRails
@@ -15,16 +17,29 @@ module ForestAdminRails
   setting :debug, default: true
   setting :auth_secret
   setting :env_secret
-  setting :forest_server_url, default: 'https://api.forestadmin.com'
+  setting :forest_server_url, default: ENV.fetch('FOREST_SERVER_URL', 'https://api.forestadmin.com')
   setting :is_production, default: Rails.env.production?
-  setting :prefix, default: 'forest'
+  setting :prefix, default: nil
   setting :permission_expiration, default: 900
   setting :cache_dir, default: :'tmp/cache/forest_admin'
   setting :schema_path, default: File.join(Dir.pwd, '.forestadmin-schema.json')
   setting :project_dir, default: Dir.pwd
-  setting :loggerLevel, default: 'info'
+  setting :logger_level, default: 'info'
   setting :logger, default: nil
+  setting :customize_error_message, default: nil
   setting :instant_cache_refresh, default: Rails.env.production?
+  setting :limit_export_size, default: nil
+  setting :append_schema_path, default: nil
+  setting :skip_schema_update, default: false
+  setting :skip_relation_read_permissions, default: false
+  setting :disable_route_cache, default: false
+  setting :rpc_max_polling_threads, default: nil
+  setting :workflow_executor_url, default: nil
+  # { database: <ActiveRecord config or URL>, schema:, table_name:, redact: } — setting `database`
+  # turns the audit trail on: every change is captured and the `/_audit-trail` routes are registered.
+  setting :audit_trail, default: nil
+  # Max records a "select all" approval may target; clamped to the Forest server's cap (500).
+  setting :max_records_for_approval, default: 500
 
   if defined?(Rails::Railtie)
     # logic for cors middleware,... here // or it might be into Engine

data/lib/generators/forest_admin_rails/install_generator.rb

@@ -9,7 +9,7 @@ module ForestAdminRails
         @env_secret = env_secret
         template 'initializers/config.rb', 'config/initializers/forest_admin_rails.rb'
         template 'create_agent.rb', 'lib/forest_admin_rails/create_agent.rb'
-        route "mount ForestAdminRails::Engine => '/#{ForestAdminRails.config[:prefix]}'"
+        route 'mount ForestAdminRails::Engine => "#{ForestAdminRails.config[:prefix]}"'
       end
     end
   end

data/lib/tasks/forest_admin_rails_tasks.rake

@@ -1,4 +1,43 @@
-# desc "Explaining what the task does"
-# task :forest_admin_rails do
-#   # Task goes here
-# end
+namespace :forest_admin do
+  namespace :schema do
+    desc 'Generate the Forest Admin schema file without starting the server or sending it to the API'
+    task generate: :environment do
+      require 'forest_admin_agent'
+
+      debug_mode = ENV['debug'] == 'true'
+
+      puts '[ForestAdmin] Starting schema generation...'
+
+      # Force eager loading of all models
+      Rails.application.eager_load!
+
+      # Check if create_agent.rb exists
+      create_agent_path = Rails.root.join('lib', 'forest_admin_rails', 'create_agent.rb')
+      unless File.exist?(create_agent_path)
+        puts '[ForestAdmin] Error: create_agent.rb not found at lib/forest_admin_rails/create_agent.rb'
+        puts '[ForestAdmin] Run `rails generate forest_admin_rails <ENV_SECRET>` to create it.'
+        exit 1
+      end
+
+      # Setup the agent factory
+      agent_factory = ForestAdminAgent::Builder::AgentFactory.instance
+      agent_factory.setup(ForestAdminRails.config)
+
+      # Enable schema-only mode (generates schema without sending to API)
+      agent_factory.schema_only_mode = true
+
+      # Load and execute the create_agent.rb file
+      require create_agent_path
+
+      # Call setup! which will generate the schema
+      begin
+        ForestAdminRails::CreateAgent.setup!
+        puts '[ForestAdmin] Schema generation completed!'
+      rescue StandardError => e
+        puts "[ForestAdmin] Error during schema generation: #{e.message}"
+        puts e.backtrace.first(10).join("\n") if debug_mode
+        exit 1
+      end
+    end
+  end
+end

metadata

@@ -1,16 +1,86 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_rails
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.beta.24
+  version: 1.44.4
 platform: ruby
 authors:
 - Matthieu
 - Nicolas
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-18 00:00:00.000000000 Z
+date: 2026-10-01 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cgi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: dry-configurable
   requirement: !ruby/object:Gem::Requirement
@@ -25,6 +95,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mutex_m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -64,13 +176,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
-- README.md
 - Rakefile
 - app/controllers/forest_admin_rails/forest_controller.rb
 - app/helpers/forest_admin_rails/application_helper.rb
+- config/initializers/forest_admin_error_subscriber.rb
+- config/initializers/forest_admin_route_cache.rb
 - config/routes.rb
+- lib/forest_admin/types.rb
 - lib/forest_admin_rails.rb
 - lib/forest_admin_rails/engine.rb
+- lib/forest_admin_rails/plugins/active_storage.rb
 - lib/forest_admin_rails/version.rb
 - lib/generators/forest_admin_rails/install_generator.rb
 - lib/generators/forest_admin_rails/templates/create_agent.rb
@@ -78,13 +193,13 @@ files:
 - lib/tasks/forest_admin_rails_tasks.rake
 homepage: https://www.forestadmin.com
 licenses:
-- MIT
+- GPL-3.0
 metadata:
   homepage_uri: https://www.forestadmin.com
-  source_code_uri: https://github.com/ForestAdmin/rails-forest_admin
-  changelog_uri: https://github.com/ForestAdmin/rails-forest_admin/CHANGELOG.md
+  source_code_uri: https://github.com/ForestAdmin/agent-ruby
+  changelog_uri: https://github.com/ForestAdmin/agent-ruby/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'false'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -95,12 +210,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.3.5
-signing_key: 
+rubygems_version: 3.4.20
+signing_key:
 specification_version: 4
 summary: Official Rails Agent for Forest Admin.
 test_files: []

data/README.md

@@ -1,28 +0,0 @@
-# ForestAdmin
-Short description and motivation.
-
-## Usage
-How to use my plugin.
-
-## Installation
-Add this line to your application's Gemfile:
-
-```ruby
-gem "forest_admin"
-```
-
-And then execute:
-```bash
-$ bundle
-```
-
-Or install it yourself as:
-```bash
-$ gem install forest_admin
-```
-
-## Contributing
-Contribution directions go here.
-
-## License
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).