forest_admin_rpc_agent 1.0.1

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "forest_admin_rpc_agent"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "irb"
+IRB.start(__FILE__)

data/bin/forest_admin_rpc_agent

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'thor'
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+require 'forest_admin_rpc_agent/thor/install'
+
+ForestAdminRpcAgent::Thor::Install.start(ARGV)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/forest_admin_rpc_agent.gemspec

@@ -0,0 +1,36 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
+
+require_relative "lib/forest_admin_rpc_agent/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "forest_admin_rpc_agent"
+  spec.version = ForestAdminRpcAgent::VERSION
+  spec.authors      = ["Matthieu", "Nicolas"]
+  spec.email        = ["matthv@gmail.com", "nicolasalexandre9@gmail.com"]
+  spec.homepage     = "https://www.forestadmin.com"
+  spec.summary      = "Ruby agent for Forest Admin."
+  spec.description  = "Forest is a modern admin interface that works on all major web frameworks. This gem makes Forest
+admin work on any Ruby application."
+  spec.license = "GPL-3.0"
+  spec.required_ruby_version = ">= 3.0.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/ForestAdmin/agent-ruby"
+  spec.metadata["changelog_uri"] = "https://github.com/ForestAdmin/agent-ruby/blob/main/CHANGELOG.md"
+  spec.metadata["rubygems_mfa_required"] = "false"
+  spec.files = Dir[
+    "lib/**/*.rb",
+    "bin/*",
+    "*.gemspec",
+    "README.md",
+    "LICENSE"
+  ]
+  spec.bindir = "bin"
+  spec.executables = ["forest_admin_rpc_agent"]
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "dry-configurable", "~> 1.1"
+  spec.add_dependency "zeitwerk", "~> 2.3"
+  spec.add_dependency "thor", "~> 1.3"
+end

data/lib/forest_admin_rpc_agent/agent.rb

@@ -0,0 +1,19 @@
+module ForestAdminRpcAgent
+  class Agent < ForestAdminAgent::Builder::AgentFactory
+    attr_reader :rpc_collections
+
+    def setup(options)
+      super
+      @rpc_collections = []
+    end
+
+    def send_schema(_force: nil)
+      ForestAdminRpcAgent::Facades::Container.logger.log('Info', 'Started as RPC agent, schema not sent.')
+    end
+
+    def mark_collections_as_rpc(*names)
+      @rpc_collections.push(*names)
+      self
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/engine.rb

@@ -0,0 +1,17 @@
+module ForestAdminRpcAgent
+  class Engine < ::Rails::Engine
+    isolate_namespace ForestAdminRpcAgent
+
+    config.after_initialize do
+      Rails.error.handle(ForestAdminDatasourceToolkit::Exceptions::ForestException) do
+        agent = ForestAdminRpcAgent::Agent.instance
+        agent.setup(ForestAdminRpcAgent.config)
+
+        # force eager loading models
+        Rails.application.eager_load!
+
+        ForestAdminRpcAgent::Extensions::ConfigLoader.load_configuration
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/extensions/config_loader.rb

@@ -0,0 +1,12 @@
+module ForestAdminRpcAgent
+  module Extensions
+    module ConfigLoader
+      def self.load_configuration
+        config_file = File.join(Dir.pwd, 'app', 'lib', 'forest_admin_rpc_agent', 'create_rpc_agent.rb')
+        return unless File.exist?(config_file)
+
+        ForestAdminRpcAgent::CreateRpcAgent.setup!
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/extensions/sinatra_extension.rb

@@ -0,0 +1,32 @@
+require 'sinatra/base'
+
+module ForestAdminRpcAgent
+  module Extensions
+    module SinatraExtension
+      def self.registered(app)
+        app.before do
+          agent = ForestAdminRpcAgent::Agent.instance
+          agent.setup(ForestAdminRpcAgent.config)
+          ForestAdminRpcAgent::Extensions::ConfigLoader.load_configuration
+        end
+
+        app.use ForestAdminRpcAgent::Middleware::Authentication
+
+        route_classes = ForestAdminRpcAgent::Routes.constants.reject { |route| route.name == 'BaseRoute' }
+        route_classes.each do |route|
+          route_class = ForestAdminRpcAgent::Routes.const_get(route)
+
+          if route_class.respond_to?(:registered)
+            puts "Registering #{route_class}"
+            route_class.registered(app)
+          else
+            ForestAdminAgent::Facades::Container.logger.log('warn',
+                                                            "Skipping #{route_class} (does not respond to :registered)")
+          end
+        end
+      end
+    end
+  end
+end
+
+Sinatra::Base.register ForestAdminRpcAgent::Extensions::SinatraExtension

data/lib/forest_admin_rpc_agent/facades/container.rb

@@ -0,0 +1,29 @@
+module ForestAdminRpcAgent
+  module Facades
+    class Container
+      def self.instance
+        ForestAdminRpcAgent::Agent.instance.container
+      end
+
+      def self.datasource
+        instance.resolve(:datasource) do
+          ForestAdminDatasourceToolkit::Datasource.new
+        end
+      end
+
+      def self.logger
+        instance.resolve(:logger)
+      end
+
+      def self.config_from_cache
+        instance.resolve(:cache).get('config')
+      end
+
+      def self.cache(key)
+        raise "Key #{key} not found in container" unless config_from_cache.key?(key)
+
+        config_from_cache[key]
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/middleware/authentication.rb

@@ -0,0 +1,67 @@
+module ForestAdminRpcAgent
+  module Middleware
+    class Authentication
+      ALLOWED_TIME_DIFF = 300
+      SIGNATURE_REUSE_WINDOW = 5
+      @@used_signatures = {}
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        request = Rack::Request.new(env)
+        signature = request.get_header('HTTP_X_SIGNATURE')
+        timestamp = request.get_header('HTTP_X_TIMESTAMP')
+
+        unless valid_signature?(signature, timestamp)
+          return [401, { 'Content-Type' => 'application/json' }, [{ error: 'Unauthorized' }.to_json]]
+        end
+
+        @app.call(env)
+      end
+
+      private
+
+      def valid_signature?(signature, timestamp)
+        return false if signature.nil? || timestamp.nil?
+        return false unless valid_timestamp?(timestamp)
+
+        expected_signature = OpenSSL::HMAC.hexdigest('SHA256', auth_secret, timestamp)
+
+        return false unless Rack::Utils.secure_compare(signature, expected_signature)
+
+        # check if this signature has already been used (replay attack)
+        if @@used_signatures.key?(signature)
+          last_used = @@used_signatures[signature]
+          return false if Time.now.utc.to_i - last_used > SIGNATURE_REUSE_WINDOW
+        end
+        @@used_signatures[signature] = Time.now.utc.to_i
+
+        cleanup_old_signatures
+
+        true
+      end
+
+      def valid_timestamp?(timestamp)
+        time = begin
+          Time.iso8601(timestamp)
+        rescue StandardError
+          nil
+        end
+        return false if time.nil?
+
+        (Time.now.utc.to_i - time.to_i).abs <= ALLOWED_TIME_DIFF
+      end
+
+      def cleanup_old_signatures
+        now = Time.now.utc.to_i
+        @@used_signatures.delete_if { |_signature, last_used| now - last_used > ALLOWED_TIME_DIFF }
+      end
+
+      def auth_secret
+        ForestAdminRpcAgent.config.auth_secret
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/routes/action_execute.rb

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

data/lib/forest_admin_rpc_agent/routes/action_form.rb

@@ -0,0 +1,49 @@
+require 'jsonapi-serializers'
+
+module ForestAdminRpcAgent
+  module Routes
+    class ActionForm < BaseRoute
+      include ForestAdminDatasourceToolkit::Components::Query
+      include ForestAdminAgent::Utils
+      include ForestAdminAgent::Routes::QueryHandler
+
+      def initialize
+        super('rpc/:collection_name/action-form', 'post', 'rpc_action_form')
+      end
+
+      def handle_request(args)
+        return '{}' unless args[:params]['collection_name']
+
+        datasource = ForestAdminRpcAgent::Facades::Container.datasource
+        collection = datasource.get_collection(args[:params]['collection_name'])
+
+        caller = if args[:params].key?('caller')
+                   ForestAdminDatasourceToolkit::Components::Caller.new(
+                     **args[:params]['caller'].to_h.transform_keys(&:to_sym)
+                   )
+                 end
+        filter = FilterFactory.from_plain_object(args[:params]['filter'])
+        metas = args[:params]['metas'] || {}
+        data = args[:params]['data']
+        action = args[:params]['action']
+
+        form = collection.get_form(caller, action, data, filter, metas)
+        form = encode_file_element(form)
+        form.to_json
+      end
+
+      def encode_file_element(elements)
+        nested_elements = %w[Page Row]
+        elements.map do |element|
+          encode_file_element(element) if element.type == 'Layout' && nested_elements.include?(element.component)
+
+          if element.type == 'File' && element.value && element.value.is_a?(File)
+            element.value = ForestAdminAgent::Utils::Schema::ForestValueConverter.make_data_uri(element.value)
+          end
+
+          element
+        end
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/routes/aggregate.rb

@@ -0,0 +1,34 @@
+require 'jsonapi-serializers'
+
+module ForestAdminRpcAgent
+  module Routes
+    class Aggregate < BaseRoute
+      include ForestAdminDatasourceToolkit::Components::Query
+      include ForestAdminAgent::Utils
+      include ForestAdminAgent::Routes::QueryHandler
+
+      def initialize
+        super('rpc/:collection_name/aggregate', 'post', 'rpc_aggregate')
+      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'])
+
+        aggregation = Aggregation.new(
+          operation: args[:params]['aggregation']['operation'],
+          field: args[:params]['aggregation']['field'],
+          groups: args[:params]['aggregation']['groups']
+        )
+        filter = FilterFactory.from_plain_object(args[:params]['filter'])
+
+        collection.aggregate(caller, filter, aggregation, args[:params]['limit']).to_json
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/routes/base_route.rb

@@ -0,0 +1,52 @@
+module ForestAdminRpcAgent
+  module Routes
+    class BaseRoute
+      def initialize(url, method, name)
+        @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)
+        app.send(@method.to_sym, @url) do
+          handle_request(params)
+        end
+      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
+            params = request.query_parameters.merge(request.request_parameters)
+
+            [200, { 'Content-Type' => 'application/json' }, [handle_request({ params: params })]]
+          else
+            [status, headers, response]
+          end
+        end
+
+        router.match @url,
+                     defaults: { format: 'json' },
+                     to: handler,
+                     via: @method,
+                     as: @name,
+                     route_alias: @name
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/routes/chart.rb

@@ -0,0 +1,30 @@
+require 'jsonapi-serializers'
+
+module ForestAdminRpcAgent
+  module Routes
+    class Chart < BaseRoute
+      include ForestAdminDatasourceToolkit::Components::Query
+
+      def initialize
+        super('rpc/:collection_name/chart', 'post', 'rpc_chart_collection')
+      end
+
+      def handle_request(args)
+        return '{}' unless args[:params]['collection_name']
+
+        chart_name = args[:params]['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'])
+
+        collection.render_chart(
+          caller,
+          chart_name,
+          ForestAdminAgent::Utils::Id.unpack_id(collection, args[:params]['record_id'])
+        )
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/routes/create.rb

@@ -0,0 +1,23 @@
+require 'jsonapi-serializers'
+
+module ForestAdminRpcAgent
+  module Routes
+    class Create < BaseRoute
+      def initialize
+        super('rpc/:collection_name/create', 'post', 'rpc_create')
+      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'])
+
+        collection.create(caller, args[:params]['data']).to_json
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/routes/datasource_chart.rb

@@ -0,0 +1,23 @@
+require 'jsonapi-serializers'
+
+module ForestAdminRpcAgent
+  module Routes
+    class DatasourceChart < BaseRoute
+      def initialize
+        super('rpc/datasource-chart', 'post', 'rpc_chart_datasource')
+      end
+
+      def handle_request(args)
+        return '{}' unless args[:params]['chart']
+
+        chart_name = args[:params]['chart']
+        caller = ForestAdminDatasourceToolkit::Components::Caller.new(
+          **args[:params]['caller'].to_h.transform_keys(&:to_sym)
+        )
+        datasource = ForestAdminRpcAgent::Facades::Container.datasource
+
+        datasource.render_chart(caller, chart_name).to_json
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/routes/delete.rb

@@ -0,0 +1,28 @@
+require 'jsonapi-serializers'
+
+module ForestAdminRpcAgent
+  module Routes
+    class Delete < BaseRoute
+      include ForestAdminDatasourceToolkit::Components::Query
+      include ForestAdminAgent::Utils
+      include ForestAdminAgent::Routes::QueryHandler
+
+      def initialize
+        super('rpc/:collection_name/delete', 'post', 'rpc_delete')
+      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.delete(caller, filter).to_json
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/routes/health_route.rb

@@ -0,0 +1,13 @@
+module ForestAdminRpcAgent
+  module Routes
+    class HealthRoute < BaseRoute
+      def initialize
+        super('health', 'get', 'rpc_forest')
+      end
+
+      def handle_request(_params)
+        { status: 'ok', message: 'Forest Admin RPC Agent is running' }.to_json
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/routes/list.rb

@@ -0,0 +1,29 @@
+require 'jsonapi-serializers'
+
+module ForestAdminRpcAgent
+  module Routes
+    class List < BaseRoute
+      include ForestAdminDatasourceToolkit::Components::Query
+      include ForestAdminAgent::Utils
+      include ForestAdminAgent::Routes::QueryHandler
+
+      def initialize
+        super('rpc/:collection_name/list', 'post', 'rpc_list')
+      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'])
+        projection = Projection.new(args[:params]['projection'])
+        filter = FilterFactory.from_plain_object(args[:params]['filter'])
+
+        collection.list(caller, filter, projection).to_json
+      end
+    end
+  end
+end

data/lib/forest_admin_rpc_agent/routes/schema.rb

@@ -0,0 +1,24 @@
+module ForestAdminRpcAgent
+  module Routes
+    class Schema < BaseRoute
+      include ForestAdminDatasourceToolkit::Components::Query::ConditionTree
+      include ForestAdminAgent::Utils
+      include ForestAdminAgent::Routes::QueryHandler
+
+      def initialize
+        super('rpc-schema', 'get', 'rpc_schema')
+      end
+
+      def handle_request(_params)
+        agent = ForestAdminRpcAgent::Agent.instance
+        schema = agent.customizer.schema
+        schema[:collections] = agent.customizer.datasource(ForestAdminRpcAgent::Facades::Container.logger)
+                                    .collections
+                                    .map { |_name, collection| collection.schema.merge({ name: collection.name }) }
+                                    .sort_by { |collection| collection[:name] }
+
+        schema.to_json
+      end
+    end
+  end
+end