react_on_rails_pro 16.2.0.beta.8

data/lib/react_on_rails_pro/assets_precompile.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  class AssetsPrecompile # rubocop:disable Metrics/ClassLength
+    include Singleton
+
+    def remote_bundle_cache_adapter
+      unless ReactOnRailsPro.configuration.remote_bundle_cache_adapter.is_a?(Module)
+        raise ReactOnRailsPro::Error, "config.remote_bundle_cache_adapter must have a module assigned"
+      end
+
+      ReactOnRailsPro.configuration.remote_bundle_cache_adapter
+    end
+
+    def zipped_bundles_filename
+      "precompile-cache.#{bundles_cache_key}.production.gz"
+    end
+
+    def zipped_bundles_filepath
+      @zipped_bundles_filepath ||=
+        begin
+          FileUtils.mkdir_p(Rails.root.join("tmp", "bundle_cache"))
+          Rails.root.join("tmp", "bundle_cache", zipped_bundles_filename)
+        end
+    end
+
+    def bundles_cache_key
+      @bundles_cache_key ||=
+        begin
+          ReactOnRailsPro::Utils.rorp_puts "Calculating digest of bundle dependencies."
+          starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          cache_dependencies = [Shakapacker.config.source_path.join("**", "*")]
+                               .union(ReactOnRailsPro.configuration.dependency_globs)
+          # Note, digest_of_globs removes excluded globs
+          digest = ReactOnRailsPro::Utils.digest_of_globs(cache_dependencies)
+          # Include the NODE_ENV in the digest
+          env_cache_keys = [
+            ReactOnRailsPro::VERSION,
+            ENV.fetch("RAILS_ENV", nil),
+            ENV.fetch("NODE_ENV", nil)
+          ]
+
+          if remote_bundle_cache_adapter.respond_to?(:cache_keys)
+            env_cache_keys += remote_bundle_cache_adapter.cache_keys
+          end
+          env_cache_keys.compact.each { |value| digest.update(value) }
+
+          result = digest.hexdigest
+          ending = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          elapsed = (ending - starting).round(2)
+          ReactOnRailsPro::Utils.rorp_puts "Completed calculating digest of bundle dependencies in #{elapsed} seconds."
+          result
+        end
+    end
+
+    def build_bundles
+      remote_bundle_cache_adapter.build
+    rescue RuntimeError
+      ReactOnRailsPro::Utils.rorp_puts "The custom config.remote_bundle_cache_adapter 'build' method raised an error:"
+      raise
+    end
+
+    def self.call
+      instance.build_or_fetch_bundles
+
+      ReactOnRailsPro::PrepareNodeRenderBundles.call if ReactOnRailsPro.configuration.node_renderer?
+    end
+
+    def build_or_fetch_bundles
+      if disable_precompile_cache?
+        build_bundles
+        return
+      end
+
+      begin
+        bundles_fetched = fetch_and_unzip_cached_bundles
+      rescue RuntimeError => e
+        ReactOnRailsPro::Utils.rorp_puts "An error occurred while attempting to fetch cached bundles."
+        ReactOnRailsPro::Utils.rorp_puts "This will be evaluated as a bundle cache miss."
+        ReactOnRailsPro::Utils.rorp_puts e.message
+        puts e.backtrace.join('\n')
+        bundles_fetched = false
+      end
+
+      return if bundles_fetched
+
+      build_bundles
+
+      begin
+        cache_bundles
+      rescue RuntimeError => e
+        ReactOnRailsPro::Utils.rorp_puts "An error occurred while attempting to cache the built bundles."
+        ReactOnRailsPro::Utils.rorp_puts e.message
+        puts e.backtrace.join('\n')
+      end
+    end
+
+    def disable_precompile_cache?
+      ENV["DISABLE_PRECOMPILE_CACHE"] == "true"
+    end
+
+    def fetch_bundles
+      ReactOnRailsPro::Utils.rorp_puts "Checking for a cached bundle: #{zipped_bundles_filename}"
+      begin
+        fetch_result = remote_bundle_cache_adapter.fetch(zipped_bundles_filename)
+      rescue RuntimeError
+        message = "An error was raised by the custom config.remote_bundle_cache_adapter 'fetch' " \
+                  "method when called with { zipped_bundles_filename: #{zipped_bundles_filename} }"
+        ReactOnRailsPro::Utils.rorp_puts message
+        raise
+      end
+
+      if fetch_result
+        ReactOnRailsPro::Utils.rorp_puts "Remote bundle cache detected. Bundles will be restored to local cache."
+        File.binwrite(zipped_bundles_filepath, fetch_result)
+        true
+      else
+        ReactOnRailsPro::Utils.rorp_puts "Remote bundle cache not found."
+        false
+      end
+    end
+
+    def fetch_and_unzip_cached_bundles
+      if File.exist?(zipped_bundles_filepath)
+        ReactOnRailsPro::Utils.rorp_puts "Found a local cache of bundles: #{zipped_bundles_filepath}"
+        result = true
+      else
+        result = fetch_bundles
+      end
+
+      if File.exist?(zipped_bundles_filepath)
+        ReactOnRailsPro::Utils.rorp_puts "gunzipping bundle cache: #{zipped_bundles_filepath}"
+        public_output_path = Shakapacker.config.public_output_path
+        FileUtils.mkdir_p(public_output_path)
+        Dir.chdir(public_output_path) do
+          Rake.sh "tar -xzf #{zipped_bundles_filepath}"
+        end
+
+        ReactOnRailsPro::Utils.rorp_puts "gunzipped bundle cache: #{zipped_bundles_filepath} to #{public_output_path}"
+
+        extract_extra_files_from_cache_dir
+      end
+      result
+    end
+
+    def extra_files_path
+      Rails.root.join(Shakapacker.config.public_output_path, "extra_files")
+    end
+
+    def copy_extra_files_to_cache_dir
+      return unless remote_bundle_cache_adapter.respond_to?(:extra_files_to_cache)
+
+      FileUtils.mkdir_p(extra_files_path)
+      copied_extra_files_paths = []
+
+      remote_bundle_cache_adapter.extra_files_to_cache.each do |file_path|
+        if file_path.file?
+          copy_file_to_extra_files_cache_dir(file_path)
+          copied_extra_files_paths.push(file_path.relative_path_from(Rails.root).to_s)
+        else
+          ReactOnRailsPro::Utils.rorp_puts "Extra file: #{file_path}, doesn't exist. Skipping"
+        end
+      end
+
+      ReactOnRailsPro::Utils.rorp_puts "Copied extra files: #{copied_extra_files_paths.join(', ')} " \
+                                       "to extra_files cache dir"
+    end
+
+    def copy_file_to_extra_files_cache_dir(source_path)
+      destination_file_path = convert_to_destination(source_path)
+      FileUtils.cp(source_path, destination_file_path)
+    end
+
+    def convert_to_destination(source)
+      new_file_name = source.relative_path_from(Rails.root).each_filename.to_a.join("---")
+      extra_files_path.join(new_file_name)
+    end
+
+    def extract_extra_files_from_cache_dir
+      return unless File.exist?(extra_files_path)
+
+      extracted_extra_files_paths = []
+      Dir.each_child(extra_files_path) do |file_name|
+        file_path_parts = file_name.split("---")
+        source_file_path = extra_files_path.join(file_name)
+        destination_file_path = Rails.root.join(*file_path_parts)
+        FileUtils.mv(source_file_path, destination_file_path)
+        extracted_extra_files_paths.push(destination_file_path.relative_path_from(Rails.root).to_s)
+      end
+
+      ReactOnRailsPro::Utils.rorp_puts "Extracted extra files: #{extracted_extra_files_paths.join(', ')} " \
+                                       "from extra_files cache dir"
+      remove_extra_files_cache_dir
+    end
+
+    def cache_bundles
+      begin
+        copy_extra_files_to_cache_dir
+        public_output_path = Shakapacker.config.public_output_path
+        ReactOnRailsPro::Utils.rorp_puts "Gzipping built bundles to #{zipped_bundles_filepath} with " \
+                                         "files in #{public_output_path}"
+        Dir.chdir(public_output_path) do
+          Rake.sh "tar -czf #{zipped_bundles_filepath} --auto-compress -C " \
+                  "#{Shakapacker.config.public_output_path} ."
+        end
+      rescue StandardError => e
+        ReactOnRailsPro::Utils.rorp_puts "An error occurred while attempting to zip the built bundles."
+        ReactOnRailsPro::Utils.rorp_puts e.message
+        puts e.backtrace.join('\n')
+      ensure
+        remove_extra_files_cache_dir
+      end
+
+      ReactOnRailsPro::Utils.rorp_puts "Bundles will be uploaded to remote bundle cache as #{zipped_bundles_filename}"
+
+      begin
+        remote_bundle_cache_adapter.upload(zipped_bundles_filepath)
+      rescue RuntimeError
+        message = "An error was raised by the custom config.remote_bundle_cache_adapter 'upload' " \
+                  "method when called with zipped_bundles_filepath: #{zipped_bundles_filepath}"
+        ReactOnRailsPro::Utils.rorp_puts message
+        raise
+      end
+    end
+
+    def remove_extra_files_cache_dir
+      FileUtils.rm_f(extra_files_path)
+    end
+  end
+end

data/lib/react_on_rails_pro/cache.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "react_on_rails/utils"
+
+module ReactOnRailsPro
+  class Cache
+    class << self
+      # options[:cache_options] can include :compress, :expires_in, :race_condition_ttl and
+      # other options
+      def fetch_react_component(component_name, options)
+        if use_cache?(options)
+          cache_key = react_component_cache_key(component_name, options)
+          Rails.logger.debug { "React on Rails Pro cache_key is #{cache_key.inspect}" }
+          cache_options = options[:cache_options]
+          cache_hit = true
+          result = Rails.cache.fetch(cache_key, cache_options) do
+            cache_hit = false
+            yield
+          end
+          # Pass back the cache key in the results only if the result is a Hash
+          if result.is_a?(Hash)
+            result[:RORP_CACHE_KEY] = cache_key
+            result[:RORP_CACHE_HIT] = cache_hit
+          end
+          result
+        else
+          yield
+        end
+      end
+
+      def use_cache?(options)
+        if options.key?(:if)
+          options[:if]
+        elsif options.key?(:unless)
+          !options[:unless]
+        else
+          true
+        end
+      end
+
+      # Cache keys by React on Rails Pro should build upon this base
+      # Provide prerender: true in order to include bundle hash in the list of keys.
+      # The bundle hash is necessary so that any changes to the bundle fault the cache.
+      def base_cache_key(type, prerender: nil)
+        keys = [
+          type,
+          ReactOnRails::VERSION,
+          ReactOnRailsPro::VERSION
+        ]
+
+        # TODO: Move comment over to test
+        # We only care about the bundle hash if prerendering because we're not caching anything
+        # that would be generated by the bundle.
+        keys.push(ReactOnRailsPro::Utils.bundle_hash) if prerender
+        keys
+      end
+
+      def dependencies_cache_key
+        # https://github.com/shakacode/react_on_rails_pro/issues/32
+        # https://github.com/shakacode/react_on_rails/issues/39#issuecomment-143472325
+        return @dependency_checksum if @dependency_checksum.present? && !Rails.env.development?
+        return nil unless ReactOnRailsPro.configuration.dependency_globs.present?
+
+        @dependency_checksum =
+          ReactOnRailsPro::Utils.digest_of_globs(
+            ReactOnRailsPro.configuration.dependency_globs
+          ).hexdigest
+      end
+
+      def react_component_cache_key(component_name, options)
+        cache_key_option = options[:cache_key]
+        cache_key_value = if cache_key_option.respond_to?(:call)
+                            cache_key_option.call
+                          else
+                            cache_key_option
+                          end
+
+        # NOTE: Rails seems to do this automatically: ActiveSupport::Cache.expand_cache_key(keys)
+        [
+          *base_cache_key("ror_component", prerender: options[:prerender]),
+          dependencies_cache_key,
+          component_name,
+          cache_key_value
+        ].compact
+      end
+    end
+  end
+end

data/lib/react_on_rails_pro/concerns/rsc_payload_renderer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  module RSCPayloadRenderer
+    extend ActiveSupport::Concern
+
+    included do
+      include ReactOnRails::Controller
+      include ReactOnRailsPro::Stream
+    end
+
+    def rsc_payload
+      @rsc_payload_component_name = rsc_payload_component_name
+      @rsc_payload_component_props = rsc_payload_component_props
+
+      stream_view_containing_react_components(
+        template: custom_rsc_payload_template,
+        layout: false
+      )
+    end
+
+    private
+
+    def rsc_payload_component_props
+      return {} if params[:props].blank?
+
+      JSON.parse(params[:props])
+    end
+
+    def rsc_payload_component_name
+      params[:component_name]
+    end
+
+    def custom_rsc_payload_template
+      "react_on_rails_pro/rsc_payload"
+    end
+  end
+end

data/lib/react_on_rails_pro/concerns/stream.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  module Stream
+    extend ActiveSupport::Concern
+
+    included do
+      include ActionController::Live
+    end
+
+    # Streams React components within a specified template to the client.
+    #
+    # @param template [String] The path to the template file to be streamed.
+    # @param close_stream_at_end [Boolean] Whether to automatically close the stream after rendering (default: true).
+    # @param render_options [Hash] Additional options to pass to `render_to_string`.
+    #
+    # components must be added to the view using the `stream_react_component` helper.
+    #
+    # @example
+    #   stream_view_containing_react_components(template: 'path/to/your/template')
+    #
+    # @example
+    #   stream_view_containing_react_components(
+    #     template: 'path/to/your/template',
+    #     close_stream_at_end: false,
+    #     layout: false
+    #   )
+    #
+    # @note The `stream_react_component` helper is defined in the react_on_rails gem.
+    #       For more details, refer to `lib/react_on_rails/helper.rb` in the react_on_rails repository.
+    #
+    # @see ReactOnRails::Helper#stream_react_component
+    def stream_view_containing_react_components(template:, close_stream_at_end: true, **render_options)
+      @rorp_rendering_fibers = []
+      template_string = render_to_string(template: template, **render_options)
+      # View may contain extra newlines, chunk already contains a newline
+      # Having multiple newlines between chunks causes hydration errors
+      # So we strip extra newlines from the template string and add a single newline
+      response.stream.write(template_string)
+
+      begin
+        drain_streams_concurrently
+      ensure
+        response.stream.close if close_stream_at_end
+      end
+    end
+
+    private
+
+    def drain_streams_concurrently
+      require "async"
+      require "async/limited_queue"
+
+      return if @rorp_rendering_fibers.empty?
+
+      Sync do |parent|
+        # To avoid memory bloat, we use a limited queue to buffer chunks in memory.
+        buffer_size = ReactOnRailsPro.configuration.concurrent_component_streaming_buffer_size
+        queue = Async::LimitedQueue.new(buffer_size)
+
+        writer = build_writer_task(parent: parent, queue: queue)
+        tasks = build_producer_tasks(parent: parent, queue: queue)
+
+        # This structure ensures that even if a producer task fails, we always
+        # signal the writer to stop and then wait for it to finish draining
+        # any remaining items from the queue before propagating the error.
+        begin
+          tasks.each(&:wait)
+        ensure
+          # `close` signals end-of-stream; when writer tries to dequeue, it will get nil, so it will exit.
+          queue.close
+          writer.wait
+        end
+      end
+    end
+
+    def build_producer_tasks(parent:, queue:)
+      @rorp_rendering_fibers.each_with_index.map do |fiber, idx|
+        parent.async do
+          loop do
+            chunk = fiber.resume
+            break unless chunk
+
+            # Will be blocked if the queue is full until a chunk is dequeued
+            queue.enqueue([idx, chunk])
+          end
+        end
+      end
+    end
+
+    def build_writer_task(parent:, queue:)
+      parent.async do
+        loop do
+          pair = queue.dequeue
+          break if pair.nil?
+
+          _idx_from_queue, item = pair
+          response.stream.write(item)
+        end
+      end
+    end
+  end
+end

data/lib/react_on_rails_pro/configuration.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  def self.configure
+    yield(configuration)
+    configuration.setup_config_values
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new(
+      prerender_caching: Configuration::DEFAULT_PRERENDER_CACHING,
+      server_renderer: Configuration::DEFAULT_RENDERER_METHOD,
+      renderer_url: Configuration::DEFAULT_RENDERER_URL,
+      renderer_use_fallback_exec_js: Configuration::DEFAULT_RENDERER_FALLBACK_EXEC_JS,
+      renderer_http_pool_size: Configuration::DEFAULT_RENDERER_HTTP_POOL_SIZE,
+      renderer_http_pool_timeout: Configuration::DEFAULT_RENDERER_HTTP_POOL_TIMEOUT,
+      renderer_http_pool_warn_timeout: Configuration::DEFAULT_RENDERER_HTTP_POOL_WARN_TIMEOUT,
+      renderer_password: nil,
+      tracing: Configuration::DEFAULT_TRACING,
+      dependency_globs: Configuration::DEFAULT_DEPENDENCY_GLOBS,
+      excluded_dependency_globs: Configuration::DEFAULT_EXCLUDED_DEPENDENCY_GLOBS,
+      remote_bundle_cache_adapter: Configuration::DEFAULT_REMOTE_BUNDLE_CACHE_ADAPTER,
+      ssr_timeout: Configuration::DEFAULT_SSR_TIMEOUT,
+      ssr_pre_hook_js: nil,
+      assets_to_copy: nil,
+      renderer_request_retry_limit: Configuration::DEFAULT_RENDERER_REQUEST_RETRY_LIMIT,
+      throw_js_errors: Configuration::DEFAULT_THROW_JS_ERRORS,
+      rendering_returns_promises: Configuration::DEFAULT_RENDERING_RETURNS_PROMISES,
+      profile_server_rendering_js_code: Configuration::DEFAULT_PROFILE_SERVER_RENDERING_JS_CODE,
+      raise_non_shell_server_rendering_errors: Configuration::DEFAULT_RAISE_NON_SHELL_SERVER_RENDERING_ERRORS,
+      enable_rsc_support: Configuration::DEFAULT_ENABLE_RSC_SUPPORT,
+      rsc_payload_generation_url_path: Configuration::DEFAULT_RSC_PAYLOAD_GENERATION_URL_PATH,
+      rsc_bundle_js_file: Configuration::DEFAULT_RSC_BUNDLE_JS_FILE,
+      react_client_manifest_file: Configuration::DEFAULT_REACT_CLIENT_MANIFEST_FILE,
+      react_server_client_manifest_file: Configuration::DEFAULT_REACT_SERVER_CLIENT_MANIFEST_FILE,
+      concurrent_component_streaming_buffer_size: Configuration::DEFAULT_CONCURRENT_COMPONENT_STREAMING_BUFFER_SIZE
+    )
+  end
+
+  class Configuration # rubocop:disable Metrics/ClassLength
+    DEFAULT_RENDERER_URL = "http://localhost:3800"
+    DEFAULT_RENDERER_METHOD = "ExecJS"
+    DEFAULT_RENDERER_FALLBACK_EXEC_JS = true
+    DEFAULT_RENDERER_HTTP_POOL_SIZE = 10
+    DEFAULT_RENDERER_HTTP_POOL_TIMEOUT = 5
+    DEFAULT_RENDERER_HTTP_POOL_WARN_TIMEOUT = 0.25
+    DEFAULT_SSR_TIMEOUT = 5
+    DEFAULT_PRERENDER_CACHING = false
+    DEFAULT_TRACING = false
+    DEFAULT_DEPENDENCY_GLOBS = [].freeze
+    DEFAULT_EXCLUDED_DEPENDENCY_GLOBS = [].freeze
+    DEFAULT_REMOTE_BUNDLE_CACHE_ADAPTER = nil
+    DEFAULT_RENDERER_REQUEST_RETRY_LIMIT = 5
+    DEFAULT_THROW_JS_ERRORS = true
+    DEFAULT_RENDERING_RETURNS_PROMISES = false
+    DEFAULT_PROFILE_SERVER_RENDERING_JS_CODE = false
+    DEFAULT_RAISE_NON_SHELL_SERVER_RENDERING_ERRORS = false
+    DEFAULT_ENABLE_RSC_SUPPORT = false
+    DEFAULT_RSC_PAYLOAD_GENERATION_URL_PATH = "rsc_payload/"
+    DEFAULT_RSC_BUNDLE_JS_FILE = "rsc-bundle.js"
+    DEFAULT_REACT_CLIENT_MANIFEST_FILE = "react-client-manifest.json"
+    DEFAULT_REACT_SERVER_CLIENT_MANIFEST_FILE = "react-server-client-manifest.json"
+    DEFAULT_CONCURRENT_COMPONENT_STREAMING_BUFFER_SIZE = 64
+
+    attr_accessor :renderer_url, :renderer_password, :tracing,
+                  :server_renderer, :renderer_use_fallback_exec_js, :prerender_caching,
+                  :renderer_http_pool_size, :renderer_http_pool_timeout, :renderer_http_pool_warn_timeout,
+                  :dependency_globs, :excluded_dependency_globs, :rendering_returns_promises,
+                  :remote_bundle_cache_adapter, :ssr_pre_hook_js, :assets_to_copy,
+                  :renderer_request_retry_limit, :throw_js_errors, :ssr_timeout,
+                  :profile_server_rendering_js_code, :raise_non_shell_server_rendering_errors, :enable_rsc_support,
+                  :rsc_payload_generation_url_path, :rsc_bundle_js_file, :react_client_manifest_file,
+                  :react_server_client_manifest_file, :concurrent_component_streaming_buffer_size
+
+    def initialize(renderer_url: nil, renderer_password: nil, server_renderer: nil, # rubocop:disable Metrics/AbcSize
+                   renderer_use_fallback_exec_js: nil, prerender_caching: nil,
+                   renderer_http_pool_size: nil, renderer_http_pool_timeout: nil,
+                   renderer_http_pool_warn_timeout: nil, tracing: nil,
+                   dependency_globs: nil, excluded_dependency_globs: nil, rendering_returns_promises: nil,
+                   remote_bundle_cache_adapter: nil, ssr_pre_hook_js: nil, assets_to_copy: nil,
+                   renderer_request_retry_limit: nil, throw_js_errors: nil, ssr_timeout: nil,
+                   profile_server_rendering_js_code: nil, raise_non_shell_server_rendering_errors: nil,
+                   enable_rsc_support: nil, rsc_payload_generation_url_path: nil,
+                   rsc_bundle_js_file: nil, react_client_manifest_file: nil,
+                   react_server_client_manifest_file: nil,
+                   concurrent_component_streaming_buffer_size: DEFAULT_CONCURRENT_COMPONENT_STREAMING_BUFFER_SIZE)
+      self.renderer_url = renderer_url
+      self.renderer_password = renderer_password
+      self.server_renderer = server_renderer
+      self.renderer_use_fallback_exec_js = renderer_use_fallback_exec_js
+      self.prerender_caching = prerender_caching
+      self.renderer_http_pool_size = renderer_http_pool_size
+      self.renderer_http_pool_timeout = renderer_http_pool_timeout
+      self.renderer_http_pool_warn_timeout = renderer_http_pool_warn_timeout
+      self.tracing = tracing
+      self.rendering_returns_promises = server_renderer == "NodeRenderer" ? rendering_returns_promises : false
+      self.dependency_globs = dependency_globs
+      self.excluded_dependency_globs = excluded_dependency_globs
+      self.remote_bundle_cache_adapter = remote_bundle_cache_adapter
+      self.ssr_pre_hook_js = ssr_pre_hook_js
+      self.assets_to_copy = assets_to_copy
+      self.renderer_request_retry_limit = renderer_request_retry_limit
+      self.throw_js_errors = throw_js_errors
+      self.ssr_timeout = ssr_timeout
+      self.profile_server_rendering_js_code = profile_server_rendering_js_code
+      self.raise_non_shell_server_rendering_errors = raise_non_shell_server_rendering_errors
+      self.enable_rsc_support = enable_rsc_support
+      self.rsc_payload_generation_url_path = rsc_payload_generation_url_path
+      self.rsc_bundle_js_file = rsc_bundle_js_file
+      self.react_client_manifest_file = react_client_manifest_file
+      self.react_server_client_manifest_file = react_server_client_manifest_file
+      self.concurrent_component_streaming_buffer_size = concurrent_component_streaming_buffer_size
+    end
+
+    def setup_config_values
+      configure_default_url_if_not_provided
+      validate_url
+      validate_remote_bundle_cache_adapter
+      setup_renderer_password
+      setup_assets_to_copy
+      validate_concurrent_component_streaming_buffer_size
+      setup_execjs_profiler_if_needed
+      check_react_on_rails_support_for_rsc
+    end
+
+    def check_react_on_rails_support_for_rsc
+      return unless enable_rsc_support
+
+      return if ReactOnRails::Utils.respond_to?(:rsc_support_enabled?)
+
+      raise ReactOnRailsPro::Error, <<~MSG
+        React Server Components (RSC) support requires react_on_rails version 15.0.0 or higher.
+        Please upgrade your react_on_rails gem to enable this feature.
+      MSG
+    end
+
+    def setup_execjs_profiler_if_needed
+      return unless profile_server_rendering_js_code && server_renderer == "ExecJS"
+
+      if ExecJS.runtime == ExecJS::Runtimes::Node
+        ExecJS.runtime = ExecJS::ExternalRuntime.new(
+          name: "Node.js (V8)",
+          command: ["node --prof"],
+          runner_path: "#{ExecJS.root}/support/node_runner.js",
+          encoding: "UTF-8"
+        )
+      elsif ExecJS.runtime == ExecJS::Runtimes::V8
+        ExecJS.runtime = ExecJS::ExternalRuntime.new(
+          name: "V8",
+          command: ["d8 --prof"],
+          runner_path: "#{ExecJS.root}/support/v8_runner.js",
+          encoding: "UTF-8"
+        )
+      else
+        current_runtime = ExecJS.runtime.name
+        message = <<~MSG
+          You have set `profile_server_rendering_js_code` to true, but the current execjs runtime is #{current_runtime}.
+          ExecJS profiler only supports Node.js (V8) or V8 runtimes.
+          You can set the runtime by setting the `EXECJS_RUNTIME` environment variable to either `Node` or `V8`.
+        MSG
+        raise ReactOnRailsPro::Error, message
+      end
+    end
+
+    def node_renderer?
+      ReactOnRailsPro.configuration.server_renderer == "NodeRenderer"
+    end
+
+    private
+
+    def setup_assets_to_copy
+      self.assets_to_copy = (Array(assets_to_copy) if assets_to_copy.present?)
+    end
+
+    def configure_default_url_if_not_provided
+      self.renderer_url = renderer_url.presence || DEFAULT_RENDERER_URL
+    end
+
+    def validate_url
+      URI(renderer_url)
+    rescue URI::InvalidURIError => e
+      message = "Unparseable ReactOnRailsPro.config.renderer_url #{renderer_url} provided.\n" \
+                "#{e.message}"
+      raise ReactOnRailsPro::Error, message
+    end
+
+    def validate_remote_bundle_cache_adapter
+      if !remote_bundle_cache_adapter.nil? && !remote_bundle_cache_adapter.is_a?(Module)
+        raise ReactOnRailsPro::Error, "config.remote_bundle_cache_adapter can only have a module or class assigned"
+      end
+
+      return unless remote_bundle_cache_adapter.is_a?(Module)
+
+      unless remote_bundle_cache_adapter.methods.include?(:build)
+        raise ReactOnRailsPro::Error,
+              "config.remote_bundle_cache_adapter must have a class method named 'build'"
+      end
+
+      unless remote_bundle_cache_adapter.methods.include?(:fetch)
+        raise ReactOnRailsPro::Error,
+              "config.remote_bundle_cache_adapter must have a class method named 'fetch'" \
+              "which takes a single named String parameter 'zipped_bundles_filename'" \
+              "and returns the zipped file as a string if fetch attempt is successful & nil if not"
+      end
+
+      unless remote_bundle_cache_adapter.methods.include?(:upload) # rubocop:disable Style/GuardClause
+        raise ReactOnRailsPro::Error,
+              "config.remote_bundle_cache_adapter must have a class method named 'upload'" \
+              "which takes a single named Pathname parameter 'zipped_bundles_filepath' & returns nil"
+      end
+    end
+
+    def validate_concurrent_component_streaming_buffer_size
+      return if concurrent_component_streaming_buffer_size.is_a?(Integer) &&
+                concurrent_component_streaming_buffer_size.positive?
+
+      raise ReactOnRailsPro::Error,
+            "config.concurrent_component_streaming_buffer_size must be a positive integer"
+    end
+
+    def setup_renderer_password
+      return if renderer_password.present?
+
+      uri = URI(renderer_url)
+      self.renderer_password = uri.password
+    end
+  end
+end