forest_admin_rpc_agent 1.18.1 → 1.18.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8d45ec5265696e44ad787fc32e88be62831f99e70cc75c54c57f3fbe8e64c1a
-  data.tar.gz: 0660b46970cf22c2f2dfce50cdf427e5c1f88b49d7d9275628f1b786afe5acda
+  metadata.gz: 85145674f5df7ae4706d7664df0afa3d9d6d175fdc4da0135076062f375c5520
+  data.tar.gz: 5bdcfb2db9533cb53a4502f1cd2665ef7cbcff47e28e693d6a5335d872b493b1
 SHA512:
-  metadata.gz: fa08ded49e9e62f6e5a67ec7f45727d6eda3be3057f993a19c3d713fc98bcbbb1ac2f7d761f4ecef2d5bdebe7160753a35afaf6d16448db358f7aac45f5333be
-  data.tar.gz: d8396e3df79b2ae0d1504ab3b8691448233c14a55da35b13cb6e086095f177eee00e8b539b773d03896394bc47ad7ec1f5e40de379069b164954dab95c6112e2
+  metadata.gz: a87cb0be55321842a0f6cb0ced398ac1a4c5a4942fc176d1fbbca17456aad5bc4de51498cbced0884fb57d80feda95f6c0485a6721683af9aeb34132fbdd613a
+  data.tar.gz: baa517eef52210a9389f8fc1842daf579326a64aa0982b7cc1cb976b355f51b9948eda5d068681d6c7685d890c4d30f4f85aeebc5a97cd38147f6c058e67448e

data/lib/forest_admin_rpc_agent/agent.rb

@@ -2,7 +2,7 @@ require 'digest'
 require 'fileutils'
 
 module ForestAdminRpcAgent
-  class Agent < ForestAdminAgent::Builder::AgentFactory # rubocop:disable Metrics/ClassLength
+  class Agent < ForestAdminAgent::Builder::AgentFactory
     include ForestAdminAgent::Http::Exceptions
 
     attr_reader :rpc_collections, :cached_schema, :cached_schema_hash
@@ -17,35 +17,23 @@ module ForestAdminRpcAgent
     def send_schema(force: false)
       if should_skip_schema_update? && !force
         log_schema_skip
-        load_and_cache_schema
         return
       end
 
-      schema_path = ForestAdminRpcAgent::Facades::Container.cache(:schema_path)
-
-      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
-
-        load_and_cache_schema_from_file(schema_path)
+      datasource = @container.resolve(:datasource)
 
-        ForestAdminRpcAgent::Facades::Container.logger.log(
-          'Info',
-          'RPC agent running in production mode, using existing schema file.'
-        )
-      else
-        generate_and_cache_schema(schema_path)
+      # Build and cache RPC schema from live datasource
+      @cached_schema = build_rpc_schema_from_datasource(datasource)
+      compute_and_cache_hash
 
-        ForestAdminRpcAgent::Facades::Container.logger.log(
-          'Info',
-          "RPC agent schema generated and saved to #{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)
 
+      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.'
@@ -62,7 +50,7 @@ module ForestAdminRpcAgent
     def rpc_schema
       return @cached_schema if @cached_schema
 
-      build_and_cache_schema_from_datasource
+      build_and_cache_rpc_schema_from_datasource
       @cached_schema
     end
 
@@ -82,50 +70,21 @@ 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 load_and_cache_schema
+    def write_schema_file_for_reference
       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))
-      File.write(schema_path, format_schema_json(schema))
+      # Use the same serialization as the /rpc-schema route (.to_json)
+      File.write(schema_path, JSON.pretty_generate(JSON.parse(@cached_schema.to_json)))
 
-      # Build RPC schema in internal format (used by master agent)
-      @cached_schema = build_rpc_schema_from_datasource(datasource)
-      compute_and_cache_hash
+      ForestAdminRpcAgent::Facades::Container.logger.log(
+        'Info',
+        "RPC agent schema file saved to #{schema_path}"
+      )
     end
 
-    def build_and_cache_schema_from_datasource
+    def build_and_cache_rpc_schema_from_datasource
       datasource = @container.resolve(:datasource)
 
       @cached_schema = build_rpc_schema_from_datasource(datasource)
@@ -135,114 +94,30 @@ module ForestAdminRpcAgent
     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[:collections] = datasource.collections
+                                       .map { |_name, collection| serialize_collection_schema(collection) }
+                                       .sort_by { |c| c[:name] }
 
-      connections = datasource.live_query_connections.keys.map { |connection_name| { name: connection_name } }
-      schema[:native_query_connections] = connections
+      schema[:native_query_connections] = datasource.live_query_connections.keys
+                                                    .map { |connection_name| { name: connection_name } }
 
       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
+    # Serialize collection schema, converting field objects to plain hashes
+    def serialize_collection_schema(collection)
+      schema = collection.schema.dup
+      schema[:name] = collection.name
+      schema[:fields] = schema[:fields].transform_values { |field| object_to_hash(field) }
+      schema
     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
+    # Convert any object to a hash using its instance variables
+    def object_to_hash(obj)
+      return obj if obj.is_a?(Hash) || obj.is_a?(Array) || obj.is_a?(String) || obj.is_a?(Numeric) || obj.nil?
 
-    def serialize_actions_for_rpc(actions)
-      actions.transform_values do |action|
-        action.respond_to?(:to_h) ? action.to_h : action
+      obj.instance_variables.to_h do |var|
+        [var.to_s.delete('@').to_sym, obj.instance_variable_get(var)]
       end
     end
 

data/lib/forest_admin_rpc_agent/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminRpcAgent
-  VERSION = "1.18.1"
+  VERSION = "1.18.2"
 end

data/lib/forest_admin_rpc_agent.rb

@@ -20,7 +20,7 @@ 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-schema.json')
+  setting :schema_path, default: File.join(Dir.pwd, '.forestadmin-rpc-schema.json')
   setting :skip_schema_update, default: false
   setting :logger_level, default: 'info'
   setting :logger, default: nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_rpc_agent
 version: !ruby/object:Gem::Version
-  version: 1.18.1
+  version: 1.18.2
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-11 00:00:00.000000000 Z
+date: 2025-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64