forest_admin_rpc_agent 1.0.1

data/lib/forest_admin_rpc_agent/routes/sse.rb

@@ -0,0 +1,80 @@
+require 'jsonapi-serializers'
+
+module ForestAdminRpcAgent
+  module Routes
+    class Sse
+      def initialize(url = 'rpc/sse', method = 'get', name = 'rpc_sse')
+        @url = url
+        @method = method
+        @name = name
+      end
+
+      def registered(app)
+        if defined?(Sinatra) && (app == Sinatra::Base || app.ancestors.include?(Sinatra::Base))
+          register_sinatra(app)
+        elsif defined?(Rails) && app.is_a?(ActionDispatch::Routing::Mapper)
+          register_rails(app)
+        else
+          raise NotImplementedError,
+                "Unsupported application type: #{app.class}. #{self} works with Sinatra::Base or ActionDispatch::Routing::Mapper."
+        end
+      end
+
+      def register_sinatra(_app)
+        # TODO
+      end
+
+      def register_rails(router)
+        handler = proc do |hash|
+          request = ActionDispatch::Request.new(hash)
+          auth_middleware = ForestAdminRpcAgent::Middleware::Authentication.new(->(_env) { [200, {}, ['OK']] })
+          status, headers, response = auth_middleware.call(request.env)
+
+          if status == 200
+            headers = {
+              'Content-Type' => 'text/event-stream',
+              'Cache-Control' => 'no-cache',
+              'Connection' => 'keep-alive'
+            }
+
+            should_continue = true
+            # Intercept CTRL+C
+            stop_proc = proc { should_continue = false }
+            original_handler = trap('INT', stop_proc)
+
+            body = Enumerator.new do |yielder|
+              stream = SseStreamer.new(yielder)
+
+              begin
+                while should_continue
+                  # ForestAdminRpcAgent::Facades::Container.logger.log('Debug', '[SSE] heartbeat')
+                  stream.write('', event: 'heartbeat')
+                  sleep 1
+                end
+              rescue IOError
+                # Client disconnected
+                # ForestAdminRpcAgent::Facades::Container.logger.log('Debug', '[SSE] disconnected')
+              ensure
+                trap('INT', original_handler)
+                stream.write({ event: 'RpcServerStop' }, event: 'RpcServerStop')
+                # ForestAdminRpcAgent::Facades::Container.logger.log('Debug', '[SSE] stopped streaming')
+                yielder.close if yielder.respond_to?(:close)
+              end
+            end
+
+            [status, headers, body]
+          else
+            [status, headers, response]
+          end
+        end
+
+        router.match @url,
+                     defaults: { format: 'event-stream' },
+                     to: handler,
+                     via: @method,
+                     as: @name,
+                     route_alias: @name
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/routes/update.rb

@@ -0,0 +1,26 @@
+require 'jsonapi-serializers'
+
+module ForestAdminRpcAgent
+  module Routes
+    class Update < BaseRoute
+      include ForestAdminDatasourceToolkit::Components::Query
+
+      def initialize
+        super('rpc/:collection_name/update', 'post', 'rpc_update')
+      end
+
+      def handle_request(args)
+        return '{}' unless args[:params]['collection_name']
+
+        caller = ForestAdminDatasourceToolkit::Components::Caller.new(
+          **args[:params]['caller'].to_h.transform_keys(&:to_sym)
+        )
+        datasource = ForestAdminRpcAgent::Facades::Container.datasource
+        collection = datasource.get_collection(args[:params]['collection_name'])
+        filter = FilterFactory.from_plain_object(args[:params]['filter'])
+
+        collection.update(caller, filter, args[:params]['data']).to_json
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/sse_streamer.rb

@@ -0,0 +1,14 @@
+require 'json'
+
+module ForestAdminRpcAgent
+  class SseStreamer
+    def initialize(yielder)
+      @yielder = yielder
+    end
+
+    def write(object, event: nil)
+      @yielder << "event: #{event}\n" if event
+      @yielder << "data: #{JSON.dump(object)}\n\n"
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/thor/install.rb

@@ -0,0 +1,136 @@
+require 'thor'
+require 'fileutils'
+
+module ForestAdminRpcAgent
+  module Thor
+    class Install < ::Thor
+      include ::Thor::Actions
+      # Run the command:
+      # for a rails app : forest_admin_rpc_agent install AUTH_SECRET_FROM_YOUR_FOREST_APP
+      # for a sinatra app : forest_admin_rpc_agent install AUTH_SECRET_FROM_YOUR_FOREST_APP --app_file=app.rb
+
+      desc 'install AUTH_SECRET_FROM_YOUR_FOREST_APP',
+           'Install ForestAdmin RPC Agent by generating necessary configuration and files'
+      method_option :app_file, type: :string, required: false, desc: 'Main file of the Sinatra application (ex: app.rb)'
+
+      RAILS_CONFIG_PATH = 'config/initializers/forest_admin_rpc_agent.rb'.freeze
+      RAILS_AGENT_PATH  = 'app/lib/forest_admin_rpc_agent/create_rpc_agent.rb'.freeze
+
+      SINATRA_CONFIG_PATH = 'config/forest_admin_rpc_agent.rb'.freeze
+      SINATRA_AGENT_PATH  = 'config/create_rpc_agent.rb'.freeze
+
+      def install(auth_secret)
+        if rails_app?
+          say_status('info', 'Rails framework detected ✅', :green)
+          setup_rails(auth_secret)
+        elsif sinatra_app?
+          if options[:app_file].nil?
+            say_status('error', 'You must specify the main file of the Sinatra application with --app_file', :red)
+            raise ::Thor::Error, 'You must specify the main file of the Sinatra application with --app_file'
+          end
+          say_status('info', 'Sinatra framework detected ✅', :green)
+          setup_sinatra(auth_secret)
+        else
+          say_status('error', 'Unsupported framework', :red)
+          raise ::Thor::Error, 'Unsupported framework, only Rails and Sinatra are supported with ForestAdmin RPC Agent'
+        end
+      end
+
+      private
+
+      def setup_rails(auth_secret)
+        require 'rails/generators'
+        require 'rails/generators/actions'
+
+        create_config_files(auth_secret, RAILS_CONFIG_PATH, RAILS_AGENT_PATH)
+
+        klass = Class.new(Rails::Generators::Base) do
+          include Rails::Generators::Actions
+        end
+        klass.new.route("mount ForestAdminRpcAgent::Engine => '/forest'")
+
+        say_status('success', 'ForestAdmin RPC Agent installed on Rails ✅', :green)
+      end
+
+      def setup_sinatra(auth_secret)
+        create_config_files(auth_secret, SINATRA_CONFIG_PATH, SINATRA_AGENT_PATH)
+
+        app_file_content = File.read(options[:app_file])
+        if app_file_content.include?("require 'sinatra'")
+          insert_into_file options[:app_file], <<~RUBY, after: "require 'sinatra'\n"
+            require_relative 'config/forest_admin_rpc_agent'
+            require 'forest_admin_rpc_agent/extensions/sinatra_extension'
+          RUBY
+
+          say_status('success', 'ForestAdmin RPC Agent installed on Sinatra ✅', :green)
+        else
+          say_status('error', "Could not find `require 'sinatra'` in #{options[:app_file]}", :red)
+          raise ::Thor::Error, "Please add `require 'sinatra'` in #{options[:app_file]} before running this command."
+        end
+      end
+
+      def create_config_files(auth_secret, config_path, agent_path)
+        # Create necessary directories
+        FileUtils.mkdir_p(File.dirname(config_path))
+        FileUtils.mkdir_p(File.dirname(agent_path))
+
+        # Create configuration file
+        create_file config_path, <<~RUBY
+          ForestAdminRpcAgent.configure do |config|
+            config.auth_secret = '#{auth_secret}'
+          end
+        RUBY
+
+        # Create agent setup file
+        create_file agent_path, <<~RUBY
+          # This file contains code to create and configure your Forest Admin agent
+          # You can customize this file according to your needs
+
+          module ForestAdminRpcAgent
+            class CreateRpcAgent
+              def self.setup!
+                # Initialize your agent here
+              end
+            end
+          end
+        RUBY
+      end
+
+      def rails_app?
+        return true if Object.const_defined?(:Rails) && Rails.respond_to?(:root)
+
+        File.exist?('config/application.rb') && Dir.exist?('app/controllers')
+      end
+
+      def sinatra_app?
+        # 1. Check if Sinatra is already loaded in memory
+        return true if defined?(Sinatra::Base)
+
+        # 2. Check Gemfile.lock
+        return true if File.exist?('Gemfile.lock') && File.read('Gemfile.lock').include?('sinatra')
+
+        # 3. Check config.ru
+        return true if File.exist?('config.ru') && File.read('config.ru') =~ %r{require ['"]sinatra(/base)?['"]}
+
+        # 4. Look for a class that inherits from Sinatra in Ruby files
+        Dir.glob('*.rb').any? do |file|
+          content = File.read(file)
+          content.match?(%r{require ['"](sinatra|sinatra/base)['"]}) &&
+            (content.include?('< Sinatra::') || content.include?('Sinatra::Application'))
+        end
+      end
+
+      class << self
+        private
+
+        def exit_on_failure?
+          true
+        end
+
+        def source_root
+          File.dirname(__FILE__)
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/version.rb

@@ -0,0 +1,3 @@
+module ForestAdminRpcAgent
+  VERSION = "1.0.1"
+end

data/lib/forest_admin_rpc_agent.rb

@@ -0,0 +1,33 @@
+require 'dry-configurable'
+require 'forest_admin_rpc_agent/version'
+require 'forest_admin_rpc_agent/engine' if defined?(Rails)
+require 'forest_admin_agent'
+require 'forest_admin_datasource_customizer'
+require 'forest_admin_datasource_toolkit'
+require 'zeitwerk'
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+module ForestAdminRpcAgent
+  extend Dry::Configurable
+
+  setting :debug, default: true
+  setting :auth_secret
+  setting :env_secret
+  setting :forest_server_url, default: 'https://api.forestadmin.com'
+  setting :is_production, default: false
+  setting :prefix, default: nil
+  setting :cache_dir, default: :'tmp/cache/forest_admin'
+  setting :project_dir, default: Dir.pwd
+  setting :loggerLevel, default: 'info'
+  setting :logger, default: nil
+  setting :customize_error_message, default: nil
+
+  begin
+    require 'thor'
+    require 'forest_admin_rpc_agent/thor/install'
+  rescue LoadError
+    # Thor is not available, skip loading commands
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: forest_admin_rpc_agent
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Matthieu
+- Nicolas
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-09-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-configurable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: |-
+  Forest is a modern admin interface that works on all major web frameworks. This gem makes Forest
+  admin work on any Ruby application.
+email:
+- matthv@gmail.com
+- nicolasalexandre9@gmail.com
+executables:
+- forest_admin_rpc_agent
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- bin/console
+- bin/forest_admin_rpc_agent
+- bin/setup
+- forest_admin_rpc_agent.gemspec
+- lib/forest_admin_rpc_agent.rb
+- lib/forest_admin_rpc_agent/agent.rb
+- lib/forest_admin_rpc_agent/engine.rb
+- lib/forest_admin_rpc_agent/extensions/config_loader.rb
+- lib/forest_admin_rpc_agent/extensions/sinatra_extension.rb
+- lib/forest_admin_rpc_agent/facades/container.rb
+- lib/forest_admin_rpc_agent/middleware/authentication.rb
+- lib/forest_admin_rpc_agent/routes/action_execute.rb
+- lib/forest_admin_rpc_agent/routes/action_form.rb
+- lib/forest_admin_rpc_agent/routes/aggregate.rb
+- lib/forest_admin_rpc_agent/routes/base_route.rb
+- lib/forest_admin_rpc_agent/routes/chart.rb
+- lib/forest_admin_rpc_agent/routes/create.rb
+- lib/forest_admin_rpc_agent/routes/datasource_chart.rb
+- lib/forest_admin_rpc_agent/routes/delete.rb
+- lib/forest_admin_rpc_agent/routes/health_route.rb
+- lib/forest_admin_rpc_agent/routes/list.rb
+- lib/forest_admin_rpc_agent/routes/schema.rb
+- lib/forest_admin_rpc_agent/routes/sse.rb
+- lib/forest_admin_rpc_agent/routes/update.rb
+- lib/forest_admin_rpc_agent/sse_streamer.rb
+- lib/forest_admin_rpc_agent/thor/install.rb
+- lib/forest_admin_rpc_agent/version.rb
+homepage: https://www.forestadmin.com
+licenses:
+- GPL-3.0
+metadata:
+  homepage_uri: https://www.forestadmin.com
+  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:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: Ruby agent for Forest Admin.
+test_files: []