forest_admin_rpc_agent 1.16.10 → 1.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6408ab0ded814ec3a63a5053aa6ca40eb69e9cfa9ce86791e1aabda1f510326d
-  data.tar.gz: 96290792e468c9bbf1d47492297981b354ff3dc0a7dc7a177092b8b4cd8c9ce4
+  metadata.gz: 8ae3dd638af2e91737911aa2436d2b25c11d556863ed638b08ebfbb95ee61cdd
+  data.tar.gz: 1e6e61aa06ee5015b272364e9ce6f49c6e6ffb218a16ac6f981a7d1219d31767
 SHA512:
-  metadata.gz: a25d113f6e9c719f9ba52873ac718c437856be8fdf1d35358667033ee7e80103a82353886c0c5efbf458abba2ece3ce913e2e930c350c84e0e7f74055751f8ed
-  data.tar.gz: 25ab7a181d0f2a3b3b585d5c7ae0f078d7c02c25f1cbe64c4d6e9e0914b169c7e633f7576d299a958f67b6dcfac47e7d2f4826ea531be2b66fd757e8fb77ee9d
+  metadata.gz: 8589283a71fb4124c12c1efa1d30bdac436cd2bb595a2c309bea55b327e639bf25cddbb3775e353d6b528f7e167e56729a295ec49d8d5aa7967da86759e1dc2e
+  data.tar.gz: c3419b02182fec4b8ac8078df6efc4d56abbf5dea07120fe6770e50278ad1c00f41e486464c34d7115757988773562eff0b7d19502fb89650d77d8cc59976794

data/lib/forest_admin_rpc_agent/agent.rb

@@ -1,19 +1,260 @@
+require 'digest'
+require 'fileutils'
+
 module ForestAdminRpcAgent
-  class Agent < ForestAdminAgent::Builder::AgentFactory
-    attr_reader :rpc_collections
+  class Agent < ForestAdminAgent::Builder::AgentFactory # rubocop:disable Metrics/ClassLength
+    include ForestAdminAgent::Http::Exceptions
+
+    attr_reader :rpc_collections, :cached_schema, :cached_schema_hash
 
     def setup(options)
       super
       @rpc_collections = []
+      @cached_schema = nil
+      @cached_schema_hash = nil
     end
 
-    def send_schema(_force: nil)
-      ForestAdminRpcAgent::Facades::Container.logger.log('Info', 'Started as RPC agent, schema not sent.')
+    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)
+
+        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 does not send schema to Forest Admin servers.'
+      )
     end
 
     def mark_collections_as_rpc(*names)
       @rpc_collections.push(*names)
       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
+
+      @cached_schema_hash == provided_hash
+    end
+
+    private
+
+    def should_skip_schema_update?
+      ForestAdminRpcAgent::Facades::Container.cache(:skip_schema_update) == true
+    end
+
+    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
+      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))
+
+      # 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_and_cache_schema_from_datasource
+      datasource = @container.resolve(:datasource)
+
+      @cached_schema = build_rpc_schema_from_datasource(datasource)
+      compute_and_cache_hash
+    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] }
+
+      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
+
+      @cached_schema_hash = Digest::SHA1.hexdigest(@cached_schema.to_json)
+
+      ForestAdminRpcAgent::Facades::Container.logger.log(
+        'Debug',
+        "RPC agent schema hash computed: #{@cached_schema_hash}"
+      )
+    end
   end
 end

data/lib/forest_admin_rpc_agent/routes/base_route.rb

@@ -20,10 +20,12 @@ module ForestAdminRpcAgent
 
       def register_sinatra(app)
         app.send(@method.to_sym, @url) do
-          result = handle_request(params)
+          result = handle_request({ params: params, request: request })
 
           if result.is_a?(Hash) && result.key?(:status)
             status result[:status]
+            # Set custom headers if provided
+            result[:headers]&.each { |key, value| headers[key] = value }
             result[:content] ? serialize_response(result[:content]) : ''
           else
             serialize_response(result)
@@ -38,16 +40,16 @@ module ForestAdminRpcAgent
           # Skip authentication for health check (root path)
           if @url == '/'
             params = request.query_parameters.merge(request.request_parameters)
-            result = handle_request({ params: params, caller: nil })
-            [200, { 'Content-Type' => 'application/json' }, [serialize_response(result)]]
+            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 = request.query_parameters.merge(request.request_parameters)
-              result = handle_request({ params: params, caller: headers[:caller] })
-              [200, { 'Content-Type' => 'application/json' }, [serialize_response(result)]]
+              result = handle_request({ params: params, caller: headers[:caller], request: request })
+              build_rails_response(result)
             else
               [status, headers, response]
             end
@@ -62,6 +64,17 @@ module ForestAdminRpcAgent
                      route_alias: @name
       end
 
+      def build_rails_response(result)
+        if result.is_a?(Hash) && result.key?(:status)
+          response_headers = { 'Content-Type' => 'application/json' }
+          response_headers.merge!(result[:headers]) if result[:headers]
+          body = result[:content] ? serialize_response(result[:content]) : ''
+          [result[:status], response_headers, [body]]
+        else
+          [200, { 'Content-Type' => 'application/json' }, [serialize_response(result)]]
+        end
+      end
+
       protected
 
       def get_collection_safe(datasource, collection_name)

data/lib/forest_admin_rpc_agent/routes/schema.rb

@@ -5,23 +5,66 @@ module ForestAdminRpcAgent
       include ForestAdminAgent::Utils
       include ForestAdminAgent::Routes::QueryHandler
 
+      HTTP_OK = 200
+      HTTP_NOT_MODIFIED = 304
+
       def initialize
         super('rpc-schema', 'get', 'rpc_schema')
       end
 
-      def handle_request(_params)
+      def handle_request(args)
         agent = ForestAdminRpcAgent::Agent.instance
-        schema = agent.customizer.schema
-        datasource = agent.customizer.datasource(ForestAdminRpcAgent::Facades::Container.logger)
+        client_etag = extract_if_none_match(args)
+
+        # If client has cached schema and ETag matches, return 304 Not Modified
+        if client_etag && agent.schema_hash_matches?(client_etag)
+          ForestAdminRpcAgent::Facades::Container.logger.log(
+            'Debug',
+            'ETag matches, returning 304 Not Modified'
+          )
+          return { status: HTTP_NOT_MODIFIED, content: nil,
+                   headers: { 'ETag' => quote_etag(agent.cached_schema_hash) } }
+        end
+
+        # Get schema from cache (or build from datasource if not cached)
+        schema = agent.rpc_schema
+        etag = agent.cached_schema_hash
+
+        # Return schema with ETag header
+        {
+          status: HTTP_OK,
+          content: schema,
+          headers: { 'ETag' => quote_etag(etag) }
+        }
+      end
+
+      private
 
-        schema[:collections] = datasource.collections
-                                         .map { |_name, collection| collection.schema.merge({ name: collection.name }) }
-                                         .sort_by { |collection| collection[:name] }
+      def extract_if_none_match(args)
+        request = args[:request] if args.is_a?(Hash)
+        return nil unless request
+
+        # Get If-None-Match header (works for both Rails and Sinatra)
+        etag = if request.respond_to?(:get_header)
+                 request.get_header('HTTP_IF_NONE_MATCH')
+               elsif request.respond_to?(:env)
+                 request.env['HTTP_IF_NONE_MATCH']
+               end
+
+        # Strip quotes from ETag value if present
+        unquote_etag(etag)
+      end
+
+      def quote_etag(etag)
+        return nil unless etag
+
+        %("#{etag}")
+      end
 
-        connections = datasource.live_query_connections.keys.map { |connection_name| { name: connection_name } }
-        schema[:native_query_connections] = connections
+      def unquote_etag(etag)
+        return nil unless etag
 
-        schema
+        etag.gsub(/\A"?|"?\z/, '')
       end
     end
   end

data/lib/forest_admin_rpc_agent/version.rb

@@ -1,3 +1,3 @@
 module ForestAdminRpcAgent
-  VERSION = "1.16.10"
+  VERSION = "1.18.0"
 end

data/lib/forest_admin_rpc_agent.rb

@@ -20,6 +20,8 @@ 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 :skip_schema_update, default: false
   setting :logger_level, default: 'info'
   setting :logger, default: nil
   setting :customize_error_message, default: nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forest_admin_rpc_agent
 version: !ruby/object:Gem::Version
-  version: 1.16.10
+  version: 1.18.0
 platform: ruby
 authors:
 - Matthieu
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-12-09 00:00:00.000000000 Z
+date: 2025-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -176,10 +176,7 @@ files:
 - lib/forest_admin_rpc_agent/routes/list.rb
 - lib/forest_admin_rpc_agent/routes/native_query.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_connection_manager.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

data/lib/forest_admin_rpc_agent/routes/sse.rb

@@ -1,166 +0,0 @@
-require 'jsonapi-serializers'
-
-module ForestAdminRpcAgent
-  module Routes
-    class Sse
-      DEFAULT_HEARTBEAT_INTERVAL = 10
-
-      def initialize(url = 'sse', method = 'get', name = 'rpc_sse', heartbeat_interval: DEFAULT_HEARTBEAT_INTERVAL)
-        @url = url
-        @method = method
-        @name = name
-        @heartbeat_interval = heartbeat_interval
-      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)
-        route_instance = self
-        app.send(@method.to_sym, "/#{@url}") do
-          auth_middleware = ForestAdminRpcAgent::Middleware::Authentication.new(->(_env) { [200, {}, ['OK']] })
-          status, headers, response = auth_middleware.call(env)
-
-          halt status, headers, response if status != 200
-
-          content_type 'text/event-stream'
-          headers 'Cache-Control' => 'no-cache',
-                  'Connection' => 'keep-alive',
-                  'X-Accel-Buffering' => 'no'
-
-          stream(:keep_open) do |out|
-            # Register this connection; any previous connection will be terminated
-            connection = ForestAdminRpcAgent::SseConnectionManager.register_connection
-
-            server_stopped = false
-            received_signal = nil
-            stop_proc = proc do |sig|
-              connection.terminate
-              server_stopped = true
-              received_signal = sig
-            end
-            original_int_handler = trap('INT', stop_proc)
-            original_term_handler = trap('TERM', stop_proc)
-
-            begin
-              streamer = SseStreamer.new(out)
-
-              while connection.active?
-                streamer.write('', event: 'heartbeat')
-                sleep route_instance.instance_variable_get(:@heartbeat_interval)
-              end
-
-              # Send RpcServerStop only if server is stopping (not client disconnect)
-              if server_stopped
-                begin
-                  streamer.write({ event: 'RpcServerStop' }, event: 'RpcServerStop')
-                  ForestAdminRpcAgent::Facades::Container.logger&.log('Debug', '[SSE] RpcServerStop event sent')
-                rescue StandardError => e
-                  ForestAdminRpcAgent::Facades::Container.logger&.log('Debug', "[SSE] Error sending stop event: #{e.message}")
-                end
-              end
-            rescue IOError, Errno::EPIPE => e
-              # Client disconnected normally
-              ForestAdminRpcAgent::Facades::Container.logger&.log('Debug', "[SSE] Client disconnected: #{e.message}")
-            ensure
-              trap('INT', original_int_handler)
-              trap('TERM', original_term_handler)
-              ForestAdminRpcAgent::SseConnectionManager.unregister_connection(connection)
-              out.close if out.respond_to?(:close)
-
-              # Re-send the signal to allow proper server shutdown
-              Process.kill(received_signal, Process.pid) if received_signal
-            end
-          end
-        end
-      end
-
-      def register_rails(router)
-        route_instance = self
-        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',
-              'X-Accel-Buffering' => 'no'
-            }
-
-            # Register this connection; any previous connection will be terminated
-            connection = ForestAdminRpcAgent::SseConnectionManager.register_connection
-
-            server_stopped = false
-            received_signal = nil
-            stop_proc = proc do |sig|
-              connection.terminate
-              server_stopped = true
-              received_signal = sig
-            end
-            original_int_handler = trap('INT', stop_proc)
-            original_term_handler = trap('TERM', stop_proc)
-
-            body = Enumerator.new do |yielder|
-              stream = SseStreamer.new(yielder)
-
-              begin
-                ForestAdminRpcAgent::Facades::Container.logger&.log('Debug', '[SSE] Starting stream')
-
-                while connection.active?
-                  stream.write('', event: 'heartbeat')
-                  sleep route_instance.instance_variable_get(:@heartbeat_interval)
-                end
-
-                # Send RpcServerStop only if server is stopping (not client disconnect)
-                if server_stopped
-                  begin
-                    stream.write({ event: 'RpcServerStop' }, event: 'RpcServerStop')
-                    ForestAdminRpcAgent::Facades::Container.logger&.log('Debug', '[SSE] RpcServerStop event sent')
-                  rescue StandardError => e
-                    ForestAdminRpcAgent::Facades::Container.logger&.log('Debug', "[SSE] Error sending stop event: #{e.message}")
-                  end
-                end
-              rescue IOError, Errno::EPIPE => e
-                # Client disconnected normally
-                ForestAdminRpcAgent::Facades::Container.logger&.log('Debug', "[SSE] Client disconnected: #{e.message}")
-              rescue StandardError => e
-                ForestAdminRpcAgent::Facades::Container.logger&.log('Error', "[SSE] Unexpected error: #{e.message}")
-                ForestAdminRpcAgent::Facades::Container.logger&.log('Error', e.backtrace.join("\n"))
-              ensure
-                trap('INT', original_int_handler)
-                trap('TERM', original_term_handler)
-                ForestAdminRpcAgent::SseConnectionManager.unregister_connection(connection)
-                ForestAdminRpcAgent::Facades::Container.logger&.log('Debug', '[SSE] Stream stopped')
-
-                # Re-send the signal to allow proper server shutdown
-                Process.kill(received_signal, Process.pid) if received_signal
-              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/sse_connection_manager.rb

@@ -1,81 +0,0 @@
-module ForestAdminRpcAgent
-  # Manages SSE connections to ensure only one active connection at a time.
-  # When a new connection is established, the previous one is terminated.
-  # This prevents zombie loops when the master restarts and reconnects.
-  class SseConnectionManager
-    @mutex = Mutex.new
-    @current_connection = nil
-
-    class << self
-      # Registers a new SSE connection and terminates any existing one.
-      # Returns a connection object that can be used to check if the connection is still active.
-      def register_connection
-        connection = Connection.new
-
-        @mutex.synchronize do
-          # Terminate the previous connection if it exists
-          if @current_connection
-            ForestAdminRpcAgent::Facades::Container.logger&.log(
-              'Debug',
-              '[SSE ConnectionManager] Terminating previous connection'
-            )
-            @current_connection.terminate
-          end
-
-          @current_connection = connection
-          ForestAdminRpcAgent::Facades::Container.logger&.log(
-            'Debug',
-            "[SSE ConnectionManager] New connection registered (id: #{connection.id})"
-          )
-        end
-
-        connection
-      end
-
-      # Unregisters a connection when it's closed normally.
-      def unregister_connection(connection)
-        @mutex.synchronize do
-          if @current_connection&.id == connection.id
-            @current_connection = nil
-            ForestAdminRpcAgent::Facades::Container.logger&.log(
-              'Debug',
-              "[SSE ConnectionManager] Connection unregistered (id: #{connection.id})"
-            )
-          end
-        end
-      end
-
-      # Returns the current active connection (for testing purposes)
-      def current_connection
-        @mutex.synchronize { @current_connection }
-      end
-
-      # Resets the manager state (for testing purposes)
-      def reset!
-        @mutex.synchronize do
-          @current_connection&.terminate
-          @current_connection = nil
-        end
-      end
-    end
-
-    # Represents an individual SSE connection
-    class Connection
-      attr_reader :id
-
-      def initialize
-        @id = SecureRandom.uuid
-        @active = true
-        @mutex = Mutex.new
-      end
-
-      def active?
-        @mutex.synchronize { @active }
-      end
-
-      def terminate
-        @mutex.synchronize { @active = false }
-      end
-    end
-  end
-end

data/lib/forest_admin_rpc_agent/sse_streamer.rb

@@ -1,14 +0,0 @@
-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