react_on_rails_pro 16.2.0.beta.8

data/lib/react_on_rails_pro/constants.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  # Status code 410 means to resend the request with the updated bundle.
+  STATUS_SEND_BUNDLE = 410
+  # Status code 412 means protocol versions are incompatible between the server and the renderer.
+  STATUS_INCOMPATIBLE = 412
+end

data/lib/react_on_rails_pro/engine.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module ReactOnRailsPro
+  class Engine < Rails::Engine
+    initializer "react_on_rails_pro.routes" do
+      ActionDispatch::Routing::Mapper.include ReactOnRailsPro::Routes
+    end
+
+    # Validate license on Rails startup
+    # This ensures the application fails fast if the license is invalid or missing
+    initializer "react_on_rails_pro.validate_license" do
+      # Use after_initialize to ensure Rails.logger is available
+      config.after_initialize do
+        Rails.logger.info "[React on Rails Pro] Validating license..."
+
+        ReactOnRailsPro::LicenseValidator.validated_license_data!
+
+        Rails.logger.info "[React on Rails Pro] License validation successful"
+      end
+    end
+  end
+end

data/lib/react_on_rails_pro/error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "react_on_rails/error"
+
+module ReactOnRailsPro
+  class Error < ::ReactOnRails::Error
+    def self.raise_duplicate_bundle_upload_error
+      raise ReactOnRailsPro::Error,
+            "The bundle has already been uploaded, " \
+            "but the server is still sending the send_bundle status code. " \
+            "This is unexpected behavior."
+    end
+  end
+end

data/lib/react_on_rails_pro/license_public_key.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  module LicensePublicKey
+    # ShakaCode's public key for React on Rails Pro license verification
+    # The private key corresponding to this public key is held by ShakaCode
+    # and is never committed to the repository
+    # Last updated: 2025-10-09 15:57:09 UTC
+    # Source: http://shakacode.com/api/public-key
+    #
+    # You can update this public key by running the rake task:
+    #   react_on_rails_pro:update_public_key
+    # This task fetches the latest key from the API endpoint:
+    #   http://shakacode.com/api/public-key
+    #
+    # TODO: Add a prepublish check to ensure this key matches the latest public key from the API.
+    #       This should be implemented after publishing the API endpoint on the ShakaCode website.
+    KEY = OpenSSL::PKey::RSA.new(<<~PEM.strip.strip_heredoc)
+            -----BEGIN PUBLIC KEY-----
+      MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAzcS/fpHz5CbnTQxb4Zot
+      khjzXu7xNS+Y9VKfapMaHOMzNoCMfy1++hxHJatRedr+YQfZRCjfiN168Cpe+dhe
+      yfNtOoLU9/+/5jTsxH+WQJWNRswyKms5HNajlIMN1GEYdZmZbvOPaZvh6ENsT+EV
+      HnhjJtsHl7qltBoL0ul7rONxaNHCzJcKk4lf3B2/1j1wpA91MKz4bbQVh4/6Th0E
+      /39f0PWvvBXzQS+yt1qaa1DIX5YL6Aug5uEpb1+6QWcN3hCzqSPBv1HahrG50rsD
+      gf8KORV3X2N9t6j6iqPmRqfRcTBKtmPhM9bORtKiSwBK8LsIUzp2/UUmkdHnkyzu
+      NQIDAQAB
+      -----END PUBLIC KEY-----
+    PEM
+  end
+end

data/lib/react_on_rails_pro/license_validator.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "jwt"
+
+module ReactOnRailsPro
+  class LicenseValidator
+    # Grace period: 1 month (in seconds)
+    GRACE_PERIOD_SECONDS = 30 * 24 * 60 * 60
+
+    class << self
+      # Validates the license and returns the license data
+      # Caches the result after first validation
+      # @return [Hash] The license data
+      # @raise [ReactOnRailsPro::Error] if license is invalid
+      def validated_license_data!
+        return @license_data if defined?(@license_data)
+
+        begin
+          # Load and decode license (but don't cache yet)
+          license_data = load_and_decode_license
+
+          # Validate the license (raises if invalid, returns grace_days)
+          grace_days = validate_license_data(license_data)
+
+          # Validation passed - now cache both data and grace days
+          @license_data = license_data
+          @grace_days_remaining = grace_days
+
+          @license_data
+        rescue JWT::DecodeError => e
+          error = "Invalid license signature: #{e.message}. " \
+                  "Your license file may be corrupted. " \
+                  "Get a FREE evaluation license at https://shakacode.com/react-on-rails-pro"
+          handle_invalid_license(error)
+        rescue StandardError => e
+          error = "License validation error: #{e.message}. " \
+                  "Get a FREE evaluation license at https://shakacode.com/react-on-rails-pro"
+          handle_invalid_license(error)
+        end
+      end
+
+      def reset!
+        remove_instance_variable(:@license_data) if defined?(@license_data)
+        remove_instance_variable(:@grace_days_remaining) if defined?(@grace_days_remaining)
+      end
+
+      # Checks if the current license is an evaluation/free license
+      # @return [Boolean] true if plan is not "paid"
+      def evaluation?
+        data = validated_license_data!
+        plan = data["plan"].to_s
+        plan != "paid" && !plan.start_with?("paid_")
+      end
+
+      # Returns remaining grace period days if license is expired but in grace period
+      # @return [Integer, nil] Number of days remaining, or nil if not in grace period
+      def grace_days_remaining
+        # Ensure license is validated and cached
+        validated_license_data!
+
+        # Return cached grace days (nil if not in grace period)
+        @grace_days_remaining
+      end
+
+      private
+
+      # Validates the license data and raises if invalid
+      # Logs info/errors and handles grace period logic
+      # @param license [Hash] The decoded license data
+      # @return [Integer, nil] Grace days remaining if in grace period, nil otherwise
+      # @raise [ReactOnRailsPro::Error] if license is invalid
+      def validate_license_data(license)
+        # Check that exp field exists
+        unless license["exp"]
+          error = "License is missing required expiration field. " \
+                  "Your license may be from an older version. " \
+                  "Get a FREE evaluation license at https://shakacode.com/react-on-rails-pro"
+          handle_invalid_license(error)
+        end
+
+        # Check expiry with grace period for production
+        current_time = Time.now.to_i
+        exp_time = license["exp"]
+        grace_days = nil
+
+        if current_time > exp_time
+          days_expired = ((current_time - exp_time) / (24 * 60 * 60)).to_i
+
+          error = "License has expired #{days_expired} day(s) ago. " \
+                  "Get a FREE evaluation license (3 months) at https://shakacode.com/react-on-rails-pro " \
+                  "or upgrade to a paid license for production use."
+
+          # In production, allow a grace period of 1 month with error logging
+          if production? && within_grace_period?(exp_time)
+            # Calculate grace days once here
+            grace_days = calculate_grace_days_remaining(exp_time)
+            Rails.logger.error(
+              "[React on Rails Pro] WARNING: #{error} " \
+              "Grace period: #{grace_days} day(s) remaining. " \
+              "Application will fail to start after grace period expires."
+            )
+          else
+            handle_invalid_license(error)
+          end
+        end
+
+        # Log license type if present (for analytics)
+        log_license_info(license)
+
+        # Return grace days (nil if not in grace period)
+        grace_days
+      end
+
+      def production?
+        Rails.env.production?
+      end
+
+      def within_grace_period?(exp_time)
+        Time.now.to_i <= exp_time + GRACE_PERIOD_SECONDS
+      end
+
+      # Calculates remaining grace period days
+      # @param exp_time [Integer] Expiration timestamp
+      # @return [Integer] Days remaining (0 or more)
+      def calculate_grace_days_remaining(exp_time)
+        grace_end = exp_time + GRACE_PERIOD_SECONDS
+        seconds_remaining = grace_end - Time.now.to_i
+        return 0 if seconds_remaining <= 0
+
+        (seconds_remaining / (24 * 60 * 60)).to_i
+      end
+
+      def load_and_decode_license
+        license_string = load_license_string
+
+        JWT.decode(
+          # The JWT token containing the license data
+          license_string,
+          # RSA public key used to verify the JWT signature
+          public_key,
+          # verify_signature: NEVER set to false! When false, signature verification is skipped,
+          # allowing anyone to forge licenses. Must always be true for security.
+          true,
+          # NOTE: Never remove the 'algorithm' parameter from JWT.decode to prevent algorithm bypassing vulnerabilities.
+          # Ensure to hardcode the expected algorithm.
+          # See: https://auth0.com/blog/critical-vulnerabilities-in-json-web-token-libraries/
+          algorithm: "RS256",
+          # Disable automatic expiration verification so we can handle it manually with custom logic
+          verify_expiration: false
+          # JWT.decode returns an array [data, header]; we use `.first` to get the data (payload).
+        ).first
+      end
+
+      def load_license_string
+        # First try environment variable
+        license = ENV.fetch("REACT_ON_RAILS_PRO_LICENSE", nil)
+        return license if license.present?
+
+        # Then try config file
+        config_path = Rails.root.join("config", "react_on_rails_pro_license.key")
+        return File.read(config_path).strip if config_path.exist?
+
+        error_msg = "No license found. Please set REACT_ON_RAILS_PRO_LICENSE environment variable " \
+                    "or create #{config_path} file. " \
+                    "Get a FREE evaluation license at https://shakacode.com/react-on-rails-pro"
+        handle_invalid_license(error_msg)
+      end
+
+      def public_key
+        ReactOnRailsPro::LicensePublicKey::KEY
+      end
+
+      def handle_invalid_license(message)
+        full_message = "[React on Rails Pro] #{message}"
+        Rails.logger.error(full_message)
+        raise ReactOnRailsPro::Error, full_message
+      end
+
+      def log_license_info(license)
+        plan = license["plan"]
+        iss = license["iss"]
+
+        Rails.logger.info("[React on Rails Pro] License plan: #{plan}") if plan
+        Rails.logger.info("[React on Rails Pro] Issued by: #{iss}") if iss
+      end
+    end
+  end
+end

data/lib/react_on_rails_pro/prepare_node_renderer_bundles.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module ReactOnRailsPro
+  class PrepareNodeRenderBundles
+    extend FileUtils
+
+    def self.make_relative_symlink(source, destination)
+      FileUtils.rm_f(destination)
+      relative_source_path = Pathname.new(source).relative_path_from(Pathname.new(destination).dirname)
+      File.symlink(relative_source_path, destination)
+      puts "[ReactOnRailsPro] Symlinked #{relative_source_path} to #{destination}"
+    end
+
+    def self.call
+      # TODO: temporarily hardcoding tmp/bundles directory. renderer and rails should read from a Yaml file
+      src_bundle_path = ReactOnRails::Utils.server_bundle_js_file_path
+      renderer_bundle_file_name = ReactOnRailsPro::ServerRenderingPool::NodeRenderingPool.renderer_bundle_file_name
+      dest_path = ENV["RENDERER_BUNDLE_PATH"].presence || Rails.root.join(".node-renderer-bundles").to_s
+      bundle_dest_path = File.join(dest_path, renderer_bundle_file_name.to_s).to_s
+      puts "[ReactOnRailsPro] Symlinking assets to local node-renderer, path #{dest_path}"
+      mkdir_p(dest_path)
+
+      make_relative_symlink(src_bundle_path, bundle_dest_path)
+
+      return unless ReactOnRailsPro.configuration.assets_to_copy.present?
+
+      ReactOnRailsPro.configuration.assets_to_copy.each do |asset_path|
+        unless File.exist?(asset_path)
+          warn "Asset not found #{asset_path}"
+          next
+        end
+
+        destination_full_path = File.join(dest_path, asset_path.basename.to_s)
+        make_relative_symlink(asset_path, destination_full_path)
+      end
+    end
+  end
+end

data/lib/react_on_rails_pro/rendering_error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  class RenderingError < RuntimeError; end
+end

data/lib/react_on_rails_pro/request.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+require "uri"
+require "httpx"
+require_relative "stream_request"
+
+module ReactOnRailsPro
+  class Request # rubocop:disable Metrics/ClassLength
+    class << self
+      def reset_connection
+        @connection&.close
+        @connection = create_connection
+      end
+
+      def render_code(path, js_code, send_bundle)
+        Rails.logger.info { "[ReactOnRailsPro] Perform rendering request #{path}" }
+        form = form_with_code(js_code, send_bundle)
+        perform_request(path, form: form)
+      end
+
+      def render_code_as_stream(path, js_code, is_rsc_payload:)
+        Rails.logger.info { "[ReactOnRailsPro] Perform rendering request as a stream #{path}" }
+        if is_rsc_payload && !ReactOnRailsPro.configuration.enable_rsc_support
+          raise ReactOnRailsPro::Error,
+                "RSC support is not enabled. Please set enable_rsc_support to true in your " \
+                "config/initializers/react_on_rails_pro.rb file before " \
+                "rendering any RSC payload."
+        end
+
+        ReactOnRailsPro::StreamRequest.create do |send_bundle|
+          form = form_with_code(js_code, send_bundle)
+          perform_request(path, form: form, stream: true)
+        end
+      end
+
+      def upload_assets
+        Rails.logger.info { "[ReactOnRailsPro] Uploading assets" }
+
+        # Check if server bundle exists before trying to upload assets
+        server_bundle_path = ReactOnRails::Utils.server_bundle_js_file_path
+        unless File.exist?(server_bundle_path)
+          raise ReactOnRailsPro::Error, "Server bundle not found at #{server_bundle_path}. " \
+                                        "Please build your bundles before uploading assets."
+        end
+
+        # Create a list of bundle timestamps to send to the node renderer
+        pool = ReactOnRailsPro::ServerRenderingPool::NodeRenderingPool
+        target_bundles = [pool.server_bundle_hash]
+
+        # Add RSC bundle if enabled
+        if ReactOnRailsPro.configuration.enable_rsc_support
+          rsc_bundle_path = ReactOnRailsPro::Utils.rsc_bundle_js_file_path
+          unless File.exist?(rsc_bundle_path)
+            raise ReactOnRailsPro::Error, "RSC bundle not found at #{rsc_bundle_path}. " \
+                                          "Please build your bundles before uploading assets."
+          end
+          target_bundles << pool.rsc_bundle_hash
+        end
+
+        form = form_with_assets_and_bundle
+        form["targetBundles"] = target_bundles
+
+        perform_request("/upload-assets", form: form)
+      end
+
+      def asset_exists_on_vm_renderer?(filename)
+        Rails.logger.info { "[ReactOnRailsPro] Sending request to check if file exist on node-renderer: #{filename}" }
+
+        form_data = common_form_data
+
+        # Add targetBundles from the current bundle hash and RSC bundle hash
+        pool = ReactOnRailsPro::ServerRenderingPool::NodeRenderingPool
+        target_bundles = [pool.server_bundle_hash]
+
+        target_bundles << pool.rsc_bundle_hash if ReactOnRailsPro.configuration.enable_rsc_support
+
+        form_data["targetBundles"] = target_bundles
+
+        response = perform_request("/asset-exists?filename=#{filename}", json: form_data)
+        JSON.parse(response.body)["exists"] == true
+      end
+
+      private
+
+      def connection
+        @connection ||= create_connection
+      end
+
+      def perform_request(path, **post_options) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+        available_retries = ReactOnRailsPro.configuration.renderer_request_retry_limit
+        retry_request = true
+        while retry_request
+          begin
+            start_time = Time.now
+            response = connection.post(path, **post_options)
+            raise response.error if response.is_a?(HTTPX::ErrorResponse)
+
+            request_time = Time.now - start_time
+            warn_timeout = ReactOnRailsPro.configuration.renderer_http_pool_warn_timeout
+            if request_time > warn_timeout
+              Rails.logger.warn "Request to #{path} took #{request_time} seconds, expected at most #{warn_timeout}."
+            end
+            retry_request = false
+          rescue HTTPX::TimeoutError => e
+            # Testing timeout catching:
+            # https://github.com/shakacode/react_on_rails_pro/pull/136#issue-463421204
+            if available_retries.zero?
+              raise ReactOnRailsPro::Error, "Time out error when getting the response on: #{path}.\n" \
+                                            "Original error:\n#{e}\n#{e.backtrace}"
+            end
+            Rails.logger.info do
+              "[ReactOnRailsPro] Timed out trying to make a request to the Node Renderer. " \
+                "Retrying #{available_retries} more times..."
+            end
+            available_retries -= 1
+            next
+          rescue HTTPX::Error => e # Connection errors or other unexpected errors
+            # Such errors are handled by ReactOnRailsPro::StreamRequest instead
+            raise if e.is_a?(HTTPX::HTTPError) && post_options[:stream]
+
+            raise ReactOnRailsPro::Error,
+                  "Node renderer request failed: #{path}.\nOriginal error:\n#{e}\n#{e.backtrace}"
+          end
+        end
+
+        Rails.logger.info { "[ReactOnRailsPro] Node Renderer responded" }
+
+        # +response+ can also be an +HTTPX::ErrorResponse+ or an +HTTPX::StreamResponse+, which don't have +#status+.
+        if response.is_a?(HTTPX::Response) && response.status == ReactOnRailsPro::STATUS_INCOMPATIBLE
+          raise ReactOnRailsPro::Error, response.body
+        end
+
+        response
+      end
+
+      def form_with_code(js_code, send_bundle)
+        form = common_form_data
+        form["renderingRequest"] = js_code
+        populate_form_with_bundle_and_assets(form, check_bundle: false) if send_bundle
+        form
+      end
+
+      def populate_form_with_bundle_and_assets(form, check_bundle:)
+        pool = ReactOnRailsPro::ServerRenderingPool::NodeRenderingPool
+
+        add_bundle_to_form(
+          form,
+          bundle_path: ReactOnRails::Utils.server_bundle_js_file_path,
+          bundle_file_name: pool.renderer_bundle_file_name,
+          bundle_hash: pool.server_bundle_hash,
+          check_bundle: check_bundle
+        )
+
+        if ReactOnRailsPro.configuration.enable_rsc_support
+          add_bundle_to_form(
+            form,
+            bundle_path: ReactOnRailsPro::Utils.rsc_bundle_js_file_path,
+            bundle_file_name: pool.rsc_renderer_bundle_file_name,
+            bundle_hash: pool.rsc_bundle_hash,
+            check_bundle: check_bundle
+          )
+        end
+
+        add_assets_to_form(form)
+      end
+
+      def add_bundle_to_form(form, bundle_path:, bundle_file_name:, bundle_hash:, check_bundle:)
+        raise ReactOnRailsPro::Error, "Bundle not found #{bundle_path}" if check_bundle && !File.exist?(bundle_path)
+
+        form["bundle_#{bundle_hash}"] = {
+          body: get_form_body_for_file(bundle_path),
+          content_type: "text/javascript",
+          filename: bundle_file_name
+        }
+      end
+
+      def add_assets_to_form(form)
+        assets_to_copy = (ReactOnRailsPro.configuration.assets_to_copy || []).dup
+        # react_client_manifest and react_server_manifest files are needed to generate react server components payload
+        if ReactOnRailsPro.configuration.enable_rsc_support
+          assets_to_copy << ReactOnRailsPro::Utils.react_client_manifest_file_path
+          assets_to_copy << ReactOnRailsPro::Utils.react_server_client_manifest_file_path
+        end
+
+        return form unless assets_to_copy.present?
+
+        assets_to_copy.each_with_index do |asset_path, idx|
+          Rails.logger.info { "[ReactOnRailsPro] Uploading asset #{asset_path}" }
+          unless http_url?(asset_path) || File.exist?(asset_path)
+            warn "Asset not found #{asset_path}"
+            next
+          end
+
+          content_type = ReactOnRailsPro::Utils.mine_type_from_file_name(asset_path)
+
+          begin
+            form["assetsToCopy#{idx}"] = {
+              body: get_form_body_for_file(asset_path),
+              content_type: content_type,
+              filename: File.basename(asset_path)
+            }
+          rescue StandardError => e
+            warn "[ReactOnRailsPro] Error uploading asset #{asset_path}: #{e}"
+          end
+        end
+
+        form
+      end
+
+      def form_with_assets_and_bundle
+        form = common_form_data
+        populate_form_with_bundle_and_assets(form, check_bundle: true)
+        form
+      end
+
+      def common_form_data
+        ReactOnRailsPro::Utils.common_form_data
+      end
+
+      def create_connection # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        url = ReactOnRailsPro.configuration.renderer_url
+        Rails.logger.info do
+          "[ReactOnRailsPro] Setting up Node Renderer connection to #{url}"
+        end
+
+        HTTPX
+          # For persistent connections we want retries,
+          # so the requests don't just fail if the other side closes the connection
+          # https://honeyryderchuck.gitlab.io/httpx/wiki/Persistent
+          .plugin(
+            :retries, max_retries: 1,
+                      retry_change_requests: true,
+                      # Official HTTPx docs says that we should use the retry_on option to decide if the
+                      # request should be retried or not
+                      # However, HTTPx assumes that connection errors such as timeout error should be retried
+                      # by default and it doesn't consider retry_on block at all at that case
+                      # So, we have to do the following trick to avoid retries when a Timeout error happens
+                      # while streaming a component
+                      # If the streamed component returned any chunks, it shouldn't retry on errors, as it
+                      # would cause page duplication
+                      # The SSR-generated html will be written to the page two times in this case
+                      retry_after: lambda do |request, response|
+                                     if request.stream.instance_variable_get(:@react_on_rails_received_first_chunk)
+                                       e = response.error
+                                       raise(
+                                         ReactOnRailsPro::Error,
+                                         "An error happened during server side render streaming " \
+                                         "of a component.\nOriginal error:\n#{e}\n#{e.backtrace}"
+                                       )
+                                     end
+
+                                     Rails.logger.info do
+                                       "[ReactOnRailsPro] An error occurred while making " \
+                                         "a request to the Node Renderer.\n" \
+                                         "Error: #{response.error}.\n" \
+                                         "Retrying by HTTPX \"retries\" plugin..."
+                                     end
+                                     # The retry_after block expects to return a delay to wait before
+                                     # retrying the request
+                                     # nil means no waiting delay
+                                     nil
+                                   end
+          )
+          .plugin(:stream)
+          # See https://www.rubydoc.info/gems/httpx/1.3.3/HTTPX%2FOptions:initialize for the available options
+          .with(
+            origin: url,
+            # Version of HTTP protocol to use by default in the absence of protocol negotiation
+            fallback_protocol: "h2",
+            persistent: true,
+            pool_options: {
+              max_connections_per_origin: ReactOnRailsPro.configuration.renderer_http_pool_size
+            },
+            # Other timeouts supported https://honeyryderchuck.gitlab.io/httpx/wiki/Timeouts:
+            # :write_timeout
+            # :request_timeout
+            # :operation_timeout
+            # :keep_alive_timeout
+            timeout: {
+              connect_timeout: ReactOnRailsPro.configuration.renderer_http_pool_timeout,
+              read_timeout: ReactOnRailsPro.configuration.ssr_timeout
+            }
+          )
+      rescue StandardError => e
+        message = <<~MSG
+          [ReactOnRailsPro] Error creating HTTPX connection.
+          renderer_http_pool_size = #{ReactOnRailsPro.configuration.renderer_http_pool_size}
+          renderer_http_pool_timeout = #{ReactOnRailsPro.configuration.renderer_http_pool_timeout}
+          renderer_http_pool_warn_timeout = #{ReactOnRailsPro.configuration.renderer_http_pool_warn_timeout}
+          renderer_url = #{url}
+          Be sure to use a url that contains the protocol of http or https.
+          Original error is
+          #{e}
+        MSG
+        raise ReactOnRailsPro::Error, message
+      end
+
+      def get_form_body_for_file(path)
+        # Handles the case when the file is served from the dev server
+        if http_url?(path)
+          unless Rails.env.development?
+            raise ReactOnRailsPro::Error,
+                  "Not expected to get HTTP url for bundle or assets in production mode"
+          end
+
+          response = HTTPX.get(path)
+          response.body
+        else
+          Pathname.new(path)
+        end
+      end
+
+      def http_url?(path)
+        path.to_s.match?(%r{https?://})
+      end
+    end
+  end
+end

data/lib/react_on_rails_pro/routes.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  module Routes
+    def rsc_payload_route(
+      path: ReactOnRailsPro.configuration.rsc_payload_generation_url_path,
+      controller: "react_on_rails_pro/rsc_payload",
+      **options
+    )
+      get "#{path}/:component_name", to: "#{controller}#rsc_payload", **options
+    end
+  end
+end