forest_admin_rpc_agent 1.22.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f894b881efb3778128a19b44f96982d8e805e934ec83c269c78987b223e8bdc9
-  data.tar.gz: 30bfd791c848af51e3581d76414d098fb08d887cb8a71cfffdd5160841789096
+  metadata.gz: '06883f603b147464ddf1ad642f47af2c3230b41cd043cf663ad9214ad22f98ec'
+  data.tar.gz: 13cdf53f4abc7147fd38d73efa4ee74f7829abbf320ce363ac315f42e8f1e322
 SHA512:
-  metadata.gz: 26ba7b64d4f41b412fdb73bed05204cf273bee61fafc45c627d7b6c19ec8da6a7c1f608b4c9fd64a0bc150ad7bf382772b2cc77ff9916c58cfb222aa918eaa13
-  data.tar.gz: d386628ca181fd8952662ab920b90e7a1971f5a79e257d3e177ade0ba589c926d1488120471e7f7ad02ba9ee5d73724158e221e2d8e5c26cc162574188b66ef1
+  metadata.gz: 2e680dc41c11c375aafe885afee8870b78ee67c81b9853f33c8eb214f1ddd4a60e82c4fe11bbd78f30c894c7288ad66f211c1d354cc7c780fb4c22e5abe4cb48
+  data.tar.gz: 02e09ab9ba06a77619dcd42785c3965f578e799014517a85535234c6079e673d4d31b0491fced672764b82fa7186022394b8570415d63f7797a4cc7ee2d9e760

data/forest_admin_rpc_agent.gemspec

@@ -31,12 +31,9 @@ admin work on any Ruby application."
   spec.require_paths = ["lib"]
 
   spec.add_dependency "base64"
-  spec.add_dependency "benchmark"
   spec.add_dependency "bigdecimal"
-  spec.add_dependency "cgi"
   spec.add_dependency "csv"
   spec.add_dependency "dry-configurable", "~> 1.1"
-  spec.add_dependency "logger"
   spec.add_dependency "mutex_m"
   spec.add_dependency "ostruct"
   spec.add_dependency "thor", "~> 1.3"

data/lib/forest_admin_rpc_agent/agent.rb

@@ -2,7 +2,7 @@ require 'digest'
 require 'fileutils'
 
 module ForestAdminRpcAgent
-  class Agent < ForestAdminAgent::Builder::AgentFactory
+  class Agent < ForestAdminAgent::Builder::AgentFactory # rubocop:disable Metrics/ClassLength
     include ForestAdminAgent::Http::Exceptions
 
     attr_reader :rpc_collections, :cached_schema, :cached_schema_hash
@@ -17,23 +17,35 @@ module ForestAdminRpcAgent
     def send_schema(force: false)
       if should_skip_schema_update? && !force
         log_schema_skip
+        load_and_cache_schema
         return
       end
 
-      datasource = @container.resolve(:datasource)
+      schema_path = ForestAdminRpcAgent::Facades::Container.cache(:schema_path)
 
-      # Build and cache RPC schema from live datasource
-      @cached_schema = build_rpc_schema_from_datasource(datasource)
-      compute_and_cache_hash
+      if ForestAdminRpcAgent::Facades::Container.cache(:is_production)
+        unless schema_path && File.exist?(schema_path)
+          raise InternalServerError.new(
+            'Schema file not found in production',
+            details: { schema_path: schema_path }
+          )
+        end
 
-      # Write schema file for reference (only in development mode)
-      # Uses the same serialization as the /rpc-schema route
-      write_schema_file_for_reference unless ForestAdminRpcAgent::Facades::Container.cache(:is_production)
+        load_and_cache_schema_from_file(schema_path)
+
+        ForestAdminRpcAgent::Facades::Container.logger.log(
+          'Info',
+          'RPC agent running in production mode, using existing schema file.'
+        )
+      else
+        generate_and_cache_schema(schema_path)
+
+        ForestAdminRpcAgent::Facades::Container.logger.log(
+          'Info',
+          "RPC agent schema generated and saved to #{schema_path}"
+        )
+      end
 
-      ForestAdminRpcAgent::Facades::Container.logger.log(
-        'Info',
-        'RPC agent schema computed from datasource and cached.'
-      )
       ForestAdminRpcAgent::Facades::Container.logger.log(
         'Info',
         'RPC agent does not send schema to Forest Admin servers.'
@@ -45,6 +57,15 @@ module ForestAdminRpcAgent
       self
     end
 
+    # Returns the cached schema for the /rpc-schema route
+    # Falls back to building schema from datasource if not cached
+    def rpc_schema
+      return @cached_schema if @cached_schema
+
+      build_and_cache_schema_from_datasource
+      @cached_schema
+    end
+
     # Check if provided hash matches the cached schema hash
     def schema_hash_matches?(provided_hash)
       return false unless @cached_schema_hash && provided_hash
@@ -61,70 +82,170 @@ module ForestAdminRpcAgent
     def log_schema_skip
       logger = ForestAdminRpcAgent::Facades::Container.logger
       logger.log('Warn', '[ForestAdmin] Schema update skipped (skip_schema_update flag is true)')
+      environment = ForestAdminRpcAgent::Facades::Container.cache(:is_production) ? 'production' : 'development'
+      logger.log('Info', "[ForestAdmin] RPC agent running in #{environment} mode")
     end
 
-    def write_schema_file_for_reference
+    def load_and_cache_schema
       schema_path = ForestAdminRpcAgent::Facades::Container.cache(:schema_path)
+
+      if ForestAdminRpcAgent::Facades::Container.cache(:is_production) && schema_path && File.exist?(schema_path)
+        load_and_cache_schema_from_file(schema_path)
+      else
+        # In development with skip_schema_update, still build from datasource
+        build_and_cache_schema_from_datasource
+      end
+    end
+
+    def load_and_cache_schema_from_file(_schema_path)
+      # File exists but RPC schema needs internal format - build from datasource
+      # The file is kept for reference/frontend but RPC always uses internal format
+      datasource = @container.resolve(:datasource)
+      @cached_schema = build_rpc_schema_from_datasource(datasource)
+      compute_and_cache_hash
+    end
+
+    def generate_and_cache_schema(schema_path)
+      datasource = @container.resolve(:datasource)
+
+      # Generate frontend schema for file (used by Forest Admin)
+      generated = ForestAdminAgent::Utils::Schema::SchemaEmitter.generate(datasource)
+      meta = ForestAdminAgent::Utils::Schema::SchemaEmitter.meta
+
+      schema = {
+        meta: meta,
+        collections: generated
+      }
+
       FileUtils.mkdir_p(File.dirname(schema_path))
-      # Use the same serialization as the /rpc-schema route (.to_json)
-      File.write(schema_path, JSON.pretty_generate(JSON.parse(@cached_schema.to_json)))
+      File.write(schema_path, format_schema_json(schema))
 
-      ForestAdminRpcAgent::Facades::Container.logger.log(
-        'Info',
-        "RPC agent schema file saved to #{schema_path}"
-      )
+      # Build RPC schema in internal format (used by master agent)
+      @cached_schema = build_rpc_schema_from_datasource(datasource)
+      compute_and_cache_hash
     end
 
-    def build_rpc_schema_from_datasource(datasource)
-      schema = customizer.schema
+    def build_and_cache_schema_from_datasource
+      datasource = @container.resolve(:datasource)
 
-      rpc_relations = {}
-      collections = []
-
-      datasource.collections.each_value do |collection|
-        relations = {}
-
-        if @rpc_collections.include?(collection.name)
-          # RPC collection → extract relations to non-RPC collections
-          collection.schema[:fields].each do |field_name, field|
-            next if field.type == 'Column'
-            next if @rpc_collections.include?(field.foreign_collection)
-
-            relations[field_name] = field
-          end
-        else
-          fields = {}
-
-          collection.schema[:fields].each do |field_name, field|
-            if field.type != 'Column' && @rpc_collections.include?(field.foreign_collection)
-              relations[field_name] = field
-            else
-              if field.type == 'Column'
-                field.filter_operators = ForestAdminAgent::Utils::Schema::FrontendFilterable.sort_operators(
-                  field.filter_operators
-                )
-              end
-
-              fields[field_name] = field
-            end
-          end
-
-          # Normal collection → include in schema
-          collections << collection.schema.merge({ name: collection.name, fields: fields })
-        end
+      @cached_schema = build_rpc_schema_from_datasource(datasource)
+      compute_and_cache_hash
+    end
 
-        rpc_relations[collection.name] = relations unless relations.empty?
-      end
+    def build_rpc_schema_from_datasource(datasource)
+      schema = customizer.schema
 
+      # Serialize collections with internal schema format (fields as hash with :type keys)
+      collections = datasource.collections.map { |_name, collection| serialize_collection_for_rpc(collection) }
       schema[:collections] = collections.sort_by { |c| c[:name] }
-      schema[:rpc_relations] = rpc_relations
 
-      schema[:native_query_connections] = datasource.live_query_connections.keys
-                                                    .map { |connection_name| { name: connection_name } }
+      connections = datasource.live_query_connections.keys.map { |connection_name| { name: connection_name } }
+      schema[:native_query_connections] = connections
 
       schema
     end
 
+    def serialize_collection_for_rpc(collection)
+      {
+        name: collection.name,
+        countable: collection.schema[:countable],
+        searchable: collection.schema[:searchable],
+        segments: collection.schema[:segments] || [],
+        charts: collection.schema[:charts] || [],
+        actions: serialize_actions_for_rpc(collection.schema[:actions] || {}),
+        fields: serialize_fields_for_rpc(collection.schema[:fields] || {})
+      }
+    end
+
+    def serialize_fields_for_rpc(fields)
+      fields.transform_values do |field_schema|
+        serialize_field_schema(field_schema)
+      end
+    end
+
+    def serialize_field_schema(field_schema)
+      case field_schema
+      when ForestAdminDatasourceToolkit::Schema::ColumnSchema
+        {
+          type: 'Column',
+          column_type: field_schema.column_type,
+          filter_operators: field_schema.filter_operators,
+          is_primary_key: field_schema.is_primary_key,
+          is_read_only: field_schema.is_read_only,
+          is_sortable: field_schema.is_sortable,
+          default_value: field_schema.default_value,
+          enum_values: field_schema.enum_values,
+          validation: field_schema.validation
+        }
+      when ForestAdminDatasourceToolkit::Schema::Relations::ManyToOneSchema
+        {
+          type: 'ManyToOne',
+          foreign_collection: field_schema.foreign_collection,
+          foreign_key: field_schema.foreign_key,
+          foreign_key_target: field_schema.foreign_key_target
+        }
+      when ForestAdminDatasourceToolkit::Schema::Relations::OneToOneSchema
+        {
+          type: 'OneToOne',
+          foreign_collection: field_schema.foreign_collection,
+          origin_key: field_schema.origin_key,
+          origin_key_target: field_schema.origin_key_target
+        }
+      when ForestAdminDatasourceToolkit::Schema::Relations::OneToManySchema
+        {
+          type: 'OneToMany',
+          foreign_collection: field_schema.foreign_collection,
+          origin_key: field_schema.origin_key,
+          origin_key_target: field_schema.origin_key_target
+        }
+      when ForestAdminDatasourceToolkit::Schema::Relations::ManyToManySchema
+        {
+          type: 'ManyToMany',
+          foreign_collection: field_schema.foreign_collection,
+          foreign_key: field_schema.foreign_key,
+          foreign_key_target: field_schema.foreign_key_target,
+          origin_key: field_schema.origin_key,
+          origin_key_target: field_schema.origin_key_target,
+          through_collection: field_schema.through_collection
+        }
+      when ForestAdminDatasourceToolkit::Schema::Relations::PolymorphicManyToOneSchema
+        {
+          type: 'PolymorphicManyToOne',
+          foreign_collections: field_schema.foreign_collections,
+          foreign_key: field_schema.foreign_key,
+          foreign_key_type_field: field_schema.foreign_key_type_field,
+          foreign_key_targets: field_schema.foreign_key_targets
+        }
+      when ForestAdminDatasourceToolkit::Schema::Relations::PolymorphicOneToOneSchema
+        {
+          type: 'PolymorphicOneToOne',
+          foreign_collection: field_schema.foreign_collection,
+          origin_key: field_schema.origin_key,
+          origin_key_target: field_schema.origin_key_target,
+          origin_type_field: field_schema.origin_type_field,
+          origin_type_value: field_schema.origin_type_value
+        }
+      when ForestAdminDatasourceToolkit::Schema::Relations::PolymorphicOneToManySchema
+        {
+          type: 'PolymorphicOneToMany',
+          foreign_collection: field_schema.foreign_collection,
+          origin_key: field_schema.origin_key,
+          origin_key_target: field_schema.origin_key_target,
+          origin_type_field: field_schema.origin_type_field,
+          origin_type_value: field_schema.origin_type_value
+        }
+      else
+        # Fallback: try to convert to hash if possible
+        field_schema.respond_to?(:to_h) ? field_schema.to_h : field_schema
+      end
+    end
+
+    def serialize_actions_for_rpc(actions)
+      actions.transform_values do |action|
+        action.respond_to?(:to_h) ? action.to_h : action
+      end
+    end
+
     def compute_and_cache_hash
       return unless @cached_schema
 

data/lib/forest_admin_rpc_agent/routes/base_route.rb

@@ -39,16 +39,16 @@ module ForestAdminRpcAgent
 
           # Skip authentication for health check (root path)
           if @url == '/'
-            params = deep_symbolize_keys(request.query_parameters.merge(request.request_parameters))
-            result = handle_request({ params: params.with_indifferent_access, caller: nil, request: request })
+            params = request.query_parameters.merge(request.request_parameters)
+            result = handle_request({ params: params, caller: nil, request: request })
             build_rails_response(result)
           else
             auth_middleware = ForestAdminRpcAgent::Middleware::Authentication.new(->(_env) { [200, {}, ['OK']] })
             status, headers, response = auth_middleware.call(request.env)
 
             if status == 200
-              params = deep_symbolize_keys(request.query_parameters.merge(request.request_parameters))
-              result = handle_request({ params: params.with_indifferent_access, caller: headers[:caller], request: request })
+              params = request.query_parameters.merge(request.request_parameters)
+              result = handle_request({ params: params, caller: headers[:caller], request: request })
               build_rails_response(result)
             else
               [status, headers, response]
@@ -87,17 +87,6 @@ module ForestAdminRpcAgent
 
       private
 
-      def deep_symbolize_keys(obj)
-        case obj
-        when Hash
-          obj.transform_keys(&:to_sym).transform_values { |v| deep_symbolize_keys(v) }
-        when Array
-          obj.map { |v| deep_symbolize_keys(v) }
-        else
-          obj
-        end
-      end
-
       def serialize_response(result)
         return result if result.is_a?(String) && (result.start_with?('{', '['))
 

data/lib/forest_admin_rpc_agent/routes/schema.rb

@@ -27,7 +27,7 @@ module ForestAdminRpcAgent
         end
 
         # Get schema from cache (or build from datasource if not cached)
-        schema = agent.cached_schema
+        schema = agent.rpc_schema
         etag = agent.cached_schema_hash
 
         # Return schema with ETag header

data/lib/forest_admin_rpc_agent/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminRpcAgent
-  VERSION = "1.22.3"
+  VERSION = "2.0.0"
 end

data/lib/forest_admin_rpc_agent.rb

@@ -20,13 +20,12 @@ module ForestAdminRpcAgent
   setting :prefix, default: nil
   setting :cache_dir, default: :'tmp/cache/forest_admin'
   setting :project_dir, default: Dir.pwd
-  setting :schema_path, default: File.join(Dir.pwd, '.forestadmin-rpc-schema.json')
+  setting :schema_path, default: File.join(Dir.pwd, '.forestadmin-schema.json')
   setting :skip_schema_update, default: false
   setting :logger_level, default: 'info'
   setting :logger, default: nil
   setting :customize_error_message, default: nil
   setting :disable_route_cache, default: false
-  setting :rpc_max_polling_threads, default: nil
 
   begin
     require 'thor'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_rpc_agent
 version: !ruby/object:Gem::Version
-  version: 1.22.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-23 00:00:00.000000000 Z
+date: 2025-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -25,20 +25,6 @@ dependencies:
     - - ">="
       - !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
@@ -53,20 +39,6 @@ dependencies:
     - - ">="
       - !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
@@ -95,20 +67,6 @@ 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