react_on_rails_pro 16.2.0.beta.11 → 16.2.0.test.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4b6739f19bed16cd9ee87ddefa25d330e2fdc02d93d9e9f509248a7cb015dc1c
-  data.tar.gz: 9de8c07648f2716cd207bdd0cff6f0c6e4f0e86bc0d21bd4ca7435544b179fae
+  metadata.gz: a0112c934965b40a6275bd05fe1309924b21f087f2ff0b8874ca4540dd40d4f7
+  data.tar.gz: ed5b0b8d9fc888529bacd29b900221b99e28544204dd016fe0d3449803f865b7
 SHA512:
-  metadata.gz: 302b9ee59324e7408f410d1e7a910bb590e50d5dd7bffa69d59c45223254091cbedbe5d8a4670bd7bc4365af352d387330a222ed6feef216cd03e80d3421a6e2
-  data.tar.gz: 2e64288aec2b1ea624ba056c066dddf540a89c27b1b5d8cc35a4b97a2d19eb665d3f6dea6624908987f4d2baddd71f1f5e472e0ba537713cf001ad8302604bd1
+  metadata.gz: 14688a5ec648396a4160bcf77a775df3a382ff8103cfed7f57e2b78a7f780e43c3c83bb3d0a5d4125005b39531845cd928fcfb255c032a9f2e5e53710ec15fe2
+  data.tar.gz: c675bd301c26d46d07d01f51750d4e4f6bc7c480e05f9ac1362a2730fbd30c857f1a51a714c68326c943d93135a4c90c9c5be53589ed1b1b1d75f9048eafaa32

data/.gitignore

@@ -48,7 +48,7 @@ junit.xml
 
 node_modules
 
-/packages/node-renderer/tests/tmp
+/../packages/react-on-rails-pro-node-renderer/tests/tmp
 
 yarn-debug.*
 spec/dummy/client/yarn-debug.log*

data/.prettierignore

@@ -1,6 +1,5 @@
 node_modules
 **/node_modules/**
-packages/node-renderer/tests/fixtures/projects
 **/tmp
 **/public
 **/package.json

data/CHANGELOG.md

@@ -20,13 +20,13 @@ You can find the **package** version numbers from this repo's tags and below in
 _Add changes in master not yet tagged._
 
 ### Improved
-- Significantly improved streaming performance by processing React components concurrently instead of sequentially. This reduces latency and improves responsiveness when using `stream_view_containing_react_components`.
 
-### Added
-- Added `config.concurrent_component_streaming_buffer_size` configuration option to control the memory buffer size for concurrent component streaming (defaults to 64). This allows fine-tuning of memory usage vs. performance for streaming applications.
+- **Concurrent Streaming Performance**: Implemented concurrent draining of streamed React components using the async gem. Instead of processing components sequentially, the system now uses a producer-consumer pattern with bounded buffering to allow multiple components to stream simultaneously while maintaining per-component chunk ordering. This significantly reduces latency and improves responsiveness when using `stream_view_containing_react_components`. [PR 2015](https://github.com/shakacode/react_on_rails/pull/2015) by [ihabadham](https://github.com/ihabadham).
 
 ### Added
 
+- **Async React Component Rendering**: Added `async_react_component` and `cached_async_react_component` helpers for concurrent component rendering. Multiple components now execute HTTP requests to the Node renderer in parallel instead of sequentially, significantly reducing latency when rendering multiple components in a view. Requires `ReactOnRailsPro::AsyncRendering` concern in controller. [PR 2139](https://github.com/shakacode/react_on_rails/pull/2139) by [AbanoubGhadban](https://github.com/AbanoubGhadban).
+- Added `config.concurrent_component_streaming_buffer_size` configuration option to control the memory buffer size for concurrent component streaming (defaults to 64). This allows fine-tuning of memory usage vs. performance for streaming applications.
 - Added `cached_stream_react_component` helper method, similar to `cached_react_component` but for streamed components.
 - **License Validation System**: Implemented comprehensive JWT-based license validation with offline verification using RSA-256 signatures. License validation occurs at startup in both Ruby and Node.js environments. Supports required fields (`sub`, `iat`, `exp`) and optional fields (`plan`, `organization`, `iss`). FREE evaluation licenses are available for 3 months at [shakacode.com/react-on-rails-pro](https://shakacode.com/react-on-rails-pro). [PR #1857](https://github.com/shakacode/react_on_rails/pull/1857) by [AbanoubGhadban](https://github.com/AbanoubGhadban).
 - **Pro-Specific Configurations Moved from Open-Source**: The following React Server Components (RSC) configurations are now exclusively in the Pro gem and should be configured in `ReactOnRailsPro.configure`:
@@ -46,9 +46,19 @@ _Add changes in master not yet tagged._
 
 - **Node Renderer Gem Version Validation**: The node renderer now validates that the Ruby gem version (`react_on_rails_pro`) matches the node renderer package version (`@shakacode-tools/react-on-rails-pro-node-renderer`) on every render request. Environment-aware: strict enforcement in development (returns 412 Precondition Failed on mismatch), permissive in production (allows with warning). Includes version normalization to handle Ruby gem vs NPM format differences (e.g., `4.0.0.rc.1` vs `4.0.0-rc.1`). [PR #1881](https://github.com/shakacode/react_on_rails/pull/1881) by [AbanoubGhadban](https://github.com/AbanoubGhadban).
 
+### Fixed
+
+- Fixed compatibility issue with httpx 1.6.x by explicitly requiring http-2 >= 1.1.1. [PR 2141](https://github.com/shakacode/react_on_rails/pull/2141) by [AbanoubGhadban](https://github.com/AbanoubGhadban).
+
+- **Node Renderer Worker Restart**: Fixed "descriptor closed" error that occurred when the node renderer restarts while handling an in-progress request (especially streaming requests). Workers now perform graceful shutdowns: they disconnect from the cluster to stop receiving new requests, wait for active requests to complete, then shut down cleanly. A configurable `gracefulWorkerRestartTimeout` ensures workers are forcibly killed if they don't shut down in time. [PR 1970](https://github.com/shakacode/react_on_rails/pull/1970) by [AbanoubGhadban](https://github.com/AbanoubGhadban).
+
+- **Body Duplication Bug On Streaming**: Fixed a bug that happens while streaming if the node renderer connection closed after streaming some chunks to the client. [PR 1995](https://github.com/shakacode/react_on_rails/pull/1995) by [AbanoubGhadban](https://github.com/AbanoubGhadban).
+
 ### Changed
 
-- Renamed Node Renderer configuration option `bundlePath` to `serverBundleCachePath` to better clarify its purpose as a cache directory for uploaded server bundles, distinct from Shakapacker's public asset directory. The old `bundlePath` property and `RENDERER_BUNDLE_PATH` environment variable continue to work with deprecation warnings. [PR 2008](https://github.com/shakacode/react_on_rails/pull/2008) by [justin808](https://github.com/justin808).
+### Deprecated
+
+- **Node Renderer Configuration**: Renamed `bundlePath` configuration option to `serverBundleCachePath` in the node renderer to better describe its purpose and avoid confusion with Shakapacker's public bundle path. The old `bundlePath` option continues to work with deprecation warnings. Both `RENDERER_SERVER_BUNDLE_CACHE_PATH` (new) and `RENDERER_BUNDLE_PATH` (deprecated) environment variables are supported. [PR 2008](https://github.com/shakacode/react_on_rails/pull/2008) by [justin808](https://github.com/justin808).
 
 ### Changed (Breaking)
 

data/Gemfile.lock

@@ -9,7 +9,7 @@ GIT
 PATH
   remote: ..
   specs:
-    react_on_rails (16.2.0.beta.11)
+    react_on_rails (16.2.0.test.3)
       addressable
       connection_pool
       execjs (~> 2.5)
@@ -20,15 +20,16 @@ PATH
 PATH
   remote: .
   specs:
-    react_on_rails_pro (16.2.0.beta.11)
+    react_on_rails_pro (16.2.0.test.3)
       addressable
       async (>= 2.6)
       connection_pool
       execjs (~> 2.9)
+      http-2 (>= 1.1.1)
       httpx (~> 1.5)
       jwt (~> 2.7)
       rainbow
-      react_on_rails (= 16.2.0.beta.11)
+      react_on_rails (= 16.2.0.test.3)
 
 GEM
   remote: https://rubygems.org/
@@ -182,7 +183,7 @@ GEM
     graphiql-rails (1.10.0)
       railties
     hashdiff (1.1.0)
-    http-2 (1.0.2)
+    http-2 (1.1.1)
     httpx (1.5.1)
       http-2 (>= 1.0.0)
     i18n (1.14.7)

data/app/helpers/react_on_rails_pro_helper.rb

@@ -128,7 +128,11 @@ module ReactOnRailsProHelper
     # Because setting prerender to false is equivalent to calling react_component with prerender: false
     options[:prerender] = true
     options = options.merge(immediate_hydration: true) unless options.key?(:immediate_hydration)
-    run_stream_inside_fiber do
+
+    # Extract streaming-specific callback
+    on_complete = options.delete(:on_complete)
+
+    consumer_stream_async(on_complete: on_complete) do
       internal_stream_react_component(component_name, options)
     end
   end
@@ -185,7 +189,11 @@ module ReactOnRailsProHelper
     # rsc_payload_react_component doesn't have the prerender option
     # Because setting prerender to false will not do anything
     options[:prerender] = true
-    run_stream_inside_fiber do
+
+    # Extract streaming-specific callback
+    on_complete = options.delete(:on_complete)
+
+    consumer_stream_async(on_complete: on_complete) do
       internal_rsc_payload_react_component(component_name, options)
     end
   end
@@ -209,6 +217,63 @@ module ReactOnRailsProHelper
     end
   end
 
+  # Renders a React component asynchronously, returning an AsyncValue immediately.
+  # Multiple async_react_component calls will execute their HTTP rendering requests
+  # concurrently instead of sequentially.
+  #
+  # Requires the controller to include ReactOnRailsPro::AsyncRendering and call
+  # enable_async_react_rendering.
+  #
+  # @param component_name [String] Name of your registered component
+  # @param options [Hash] Same options as react_component
+  # @return [ReactOnRailsPro::AsyncValue] Call .value to get the rendered HTML
+  #
+  # @example
+  #   <% header = async_react_component("Header", props: @header_props) %>
+  #   <% sidebar = async_react_component("Sidebar", props: @sidebar_props) %>
+  #   <%= header.value %>
+  #   <%= sidebar.value %>
+  #
+  def async_react_component(component_name, options = {})
+    unless defined?(@react_on_rails_async_barrier) && @react_on_rails_async_barrier
+      raise ReactOnRailsPro::Error,
+            "async_react_component requires AsyncRendering concern. " \
+            "Include ReactOnRailsPro::AsyncRendering in your controller and call enable_async_react_rendering."
+    end
+
+    task = @react_on_rails_async_barrier.async do
+      react_component(component_name, options)
+    end
+
+    ReactOnRailsPro::AsyncValue.new(task: task)
+  end
+
+  # Renders a React component asynchronously with caching support.
+  # Cache lookup is synchronous - cache hits return immediately without async.
+  # Cache misses trigger async render and cache the result on completion.
+  #
+  # All the same options as cached_react_component apply:
+  # 1. You must pass the props as a block (evaluated only on cache miss)
+  # 2. Provide the cache_key option
+  # 3. Optionally provide :cache_options for Rails.cache (expires_in, etc.)
+  # 4. Provide :if or :unless for conditional caching
+  #
+  # @param component_name [String] Name of your registered component
+  # @param options [Hash] Options including cache_key and cache_options
+  # @yield Block that returns props (evaluated only on cache miss)
+  # @return [ReactOnRailsPro::AsyncValue, ReactOnRailsPro::ImmediateAsyncValue]
+  #
+  # @example
+  #   <% card = cached_async_react_component("ProductCard", cache_key: @product) { @product.to_props } %>
+  #   <%= card.value %>
+  #
+  def cached_async_react_component(component_name, raw_options = {}, &block)
+    ReactOnRailsPro::Utils.with_trace(component_name) do
+      check_caching_options!(raw_options, block)
+      fetch_async_react_component(component_name, raw_options, &block)
+    end
+  end
+
   if defined?(ScoutApm)
     include ScoutApm::Tracer
     instrument_method :cached_react_component, type: "ReactOnRails", name: "cached_react_component"
@@ -246,30 +311,29 @@ module ReactOnRailsProHelper
     load_pack_for_generated_component(component_name, render_options)
 
     initial_result, *rest_chunks = cached_chunks
-    hit_fiber = Fiber.new do
-      rest_chunks.each { |chunk| Fiber.yield(chunk) }
-      nil
+
+    # Enqueue remaining chunks asynchronously
+    @async_barrier.async do
+      rest_chunks.each { |chunk| @main_output_queue.enqueue(chunk) }
     end
-    @rorp_rendering_fibers << hit_fiber
+
+    # Return first chunk directly
     initial_result
   end
 
   def handle_stream_cache_miss(component_name, raw_options, auto_load_bundle, view_cache_key, &block)
-    # Kick off the normal streaming helper to get the initial result and the original fiber
-    initial_result = render_stream_component_with_props(component_name, raw_options, auto_load_bundle, &block)
-    original_fiber = @rorp_rendering_fibers.pop
-
-    buffered_chunks = [initial_result]
-    wrapper_fiber = Fiber.new do
-      while (chunk = original_fiber.resume)
-        buffered_chunks << chunk
-        Fiber.yield(chunk)
-      end
-      Rails.cache.write(view_cache_key, buffered_chunks, raw_options[:cache_options] || {})
-      nil
-    end
-    @rorp_rendering_fibers << wrapper_fiber
-    initial_result
+    cache_aware_options = raw_options.merge(
+      on_complete: lambda { |chunks|
+        Rails.cache.write(view_cache_key, chunks, raw_options[:cache_options] || {})
+      }
+    )
+
+    render_stream_component_with_props(
+      component_name,
+      cache_aware_options,
+      auto_load_bundle,
+      &block
+    )
   end
 
   def render_stream_component_with_props(component_name, raw_options, auto_load_bundle)
@@ -291,25 +355,117 @@ module ReactOnRailsProHelper
     raise ReactOnRailsPro::Error, "Option 'cache_key' is required for React on Rails caching"
   end
 
-  def run_stream_inside_fiber
-    if @rorp_rendering_fibers.nil?
+  # Async version of fetch_react_component. Handles cache lookup synchronously,
+  # returns ImmediateAsyncValue on hit, AsyncValue on miss.
+  def fetch_async_react_component(component_name, raw_options, &block)
+    unless defined?(@react_on_rails_async_barrier) && @react_on_rails_async_barrier
+      raise ReactOnRailsPro::Error,
+            "cached_async_react_component requires AsyncRendering concern. " \
+            "Include ReactOnRailsPro::AsyncRendering in your controller and call enable_async_react_rendering."
+    end
+
+    # Check conditional caching (:if / :unless options)
+    unless ReactOnRailsPro::Cache.use_cache?(raw_options)
+      return render_async_react_component_uncached(component_name, raw_options, &block)
+    end
+
+    cache_key = ReactOnRailsPro::Cache.react_component_cache_key(component_name, raw_options)
+    cache_options = raw_options[:cache_options] || {}
+    Rails.logger.debug { "React on Rails Pro async cache_key is #{cache_key.inspect}" }
+
+    # Synchronous cache lookup
+    cached_result = Rails.cache.read(cache_key, cache_options)
+    if cached_result
+      Rails.logger.debug { "React on Rails Pro async cache HIT for #{cache_key.inspect}" }
+      render_options = ReactOnRails::ReactComponent::RenderOptions.new(
+        react_component_name: component_name,
+        options: raw_options
+      )
+      load_pack_for_generated_component(component_name, render_options)
+      return ReactOnRailsPro::ImmediateAsyncValue.new(cached_result)
+    end
+
+    Rails.logger.debug { "React on Rails Pro async cache MISS for #{cache_key.inspect}" }
+    render_async_react_component_with_cache(component_name, raw_options, cache_key, cache_options, &block)
+  end
+
+  # Renders async without caching (when :if/:unless conditions disable cache)
+  def render_async_react_component_uncached(component_name, raw_options, &block)
+    options = prepare_async_render_options(raw_options, &block)
+
+    task = @react_on_rails_async_barrier.async do
+      react_component(component_name, options)
+    end
+
+    ReactOnRailsPro::AsyncValue.new(task: task)
+  end
+
+  # Renders async and writes to cache on completion
+  def render_async_react_component_with_cache(component_name, raw_options, cache_key, cache_options, &block)
+    options = prepare_async_render_options(raw_options, &block)
+
+    task = @react_on_rails_async_barrier.async do
+      result = react_component(component_name, options)
+      Rails.cache.write(cache_key, result, cache_options)
+      result
+    end
+
+    ReactOnRailsPro::AsyncValue.new(task: task)
+  end
+
+  def prepare_async_render_options(raw_options)
+    raw_options.merge(
+      props: yield,
+      skip_prerender_cache: true,
+      auto_load_bundle: ReactOnRails.configuration.auto_load_bundle || raw_options[:auto_load_bundle]
+    )
+  end
+
+  def consumer_stream_async(on_complete:)
+    require "async/variable"
+
+    if @async_barrier.nil?
       raise ReactOnRails::Error,
             "You must call stream_view_containing_react_components to render the view containing the react component"
     end
 
-    rendering_fiber = Fiber.new do
+    # Create a variable to hold the first chunk for synchronous return
+    first_chunk_var = Async::Variable.new
+    all_chunks = [] if on_complete # Only collect if callback provided
+
+    # Start an async task on the barrier to stream all chunks
+    @async_barrier.async do
       stream = yield
-      stream.each_chunk do |chunk|
-        Fiber.yield chunk
-      end
+      process_stream_chunks(stream, first_chunk_var, all_chunks)
+      on_complete&.call(all_chunks)
     end
 
-    @rorp_rendering_fibers << rendering_fiber
+    # Wait for and return the first chunk (blocking)
+    first_chunk_var.wait
+    first_chunk_var.value
+  end
+
+  def process_stream_chunks(stream, first_chunk_var, all_chunks)
+    is_first = true
+
+    stream.each_chunk do |chunk|
+      # Check if client disconnected before processing chunk
+      break if response.stream.closed?
+
+      all_chunks&.push(chunk)
+
+      if is_first
+        # Store first chunk in variable for synchronous return
+        first_chunk_var.value = chunk
+        is_first = false
+      else
+        # Enqueue remaining chunks to main output queue
+        @main_output_queue.enqueue(chunk)
+      end
+    end
 
-    # return the first chunk of the fiber
-    # It contains the initial html of the component
-    # all updates will be appended to the stream sent to browser
-    rendering_fiber.resume
+    # Handle case where stream has no chunks
+    first_chunk_var.value = nil if is_first
   end
 
   def internal_stream_react_component(component_name, options = {})
@@ -347,7 +503,8 @@ module ReactOnRailsProHelper
           render_options: render_options
         )
       else
-        result_console_script = render_options.replay_console ? chunk_json_result["consoleReplayScript"] : ""
+        console_script = chunk_json_result["consoleReplayScript"]
+        result_console_script = render_options.replay_console ? wrap_console_script_with_nonce(console_script) : ""
         # No need to prepend component_specification_tag or add rails context again
         # as they're already included in the first chunk
         compose_react_component_html_with_spec_and_console(

data/eslint.config.mjs

@@ -3,7 +3,6 @@ import { includeIgnoreFile } from '@eslint/compat';
 import js from '@eslint/js';
 import { FlatCompat } from '@eslint/eslintrc';
 import { defineConfig, globalIgnores } from 'eslint/config';
-import importPlugin from 'eslint-plugin-import';
 import jest from 'eslint-plugin-jest';
 import prettierRecommended from 'eslint-plugin-prettier/recommended';
 import globals from 'globals';
@@ -22,8 +21,9 @@ export default defineConfig([
     'spec/react_on_rails/dummy-for-generators',
     // includes some generated code
     'spec/dummy/client/app/packs/server-bundle.js',
-    'packages/node-renderer/lib/',
-    'packages/node-renderer/tests/fixtures',
+    '../packages/react-on-rails/', // Ignore open-source package (has its own linting)
+    '../packages/react-on-rails-pro-node-renderer/lib/',
+    '../packages/react-on-rails-pro-node-renderer/tests/fixtures',
     '**/node_modules/',
     '**/assets/webpack/',
     '**/generated/',
@@ -129,7 +129,7 @@ export default defineConfig([
   },
   {
     files: ['**/*.ts{x,}'],
-    extends: [importPlugin.flatConfigs.typescript, typescriptEslint.configs.strictTypeChecked],
+    extends: [typescriptEslint.configs.strictTypeChecked],
 
     languageOptions: {
       parserOptions: {
@@ -166,7 +166,7 @@ export default defineConfig([
     },
   },
   {
-    files: ['packages/node-renderer/tests/**', '**/*.test.{js,jsx,ts,tsx}'],
+    files: ['../packages/react-on-rails-pro-node-renderer/tests/**', '**/*.test.{js,jsx,ts,tsx}'],
 
     extends: [jest.configs['flat/recommended'], jest.configs['flat/style']],
 
@@ -183,8 +183,8 @@ export default defineConfig([
     },
   },
   {
-    files: ['packages/node-renderer/src/integrations/**'],
-    ignores: ['packages/node-renderer/src/integrations/api.ts'],
+    files: ['../packages/react-on-rails-pro-node-renderer/src/integrations/**'],
+    ignores: ['../packages/react-on-rails-pro-node-renderer/src/integrations/api.ts'],
 
     rules: {
       // Integrations should only use the public integration API
@@ -214,6 +214,25 @@ export default defineConfig([
       'react-hooks/rules-of-hooks': ['off'],
     },
   },
+  {
+    // Dummy apps have dependencies managed separately and may not be installed
+    files: ['spec/dummy/**/*', 'spec/execjs-compatible-dummy/**/*'],
+    rules: {
+      'import/no-unresolved': 'off',
+      'import/named': 'off',
+    },
+  },
+  {
+    // Pro packages use monorepo workspace imports that ESLint can't resolve
+    // TypeScript compiler validates these imports
+    files: ['../packages/react-on-rails-pro/**/*', '../packages/react-on-rails-pro-node-renderer/**/*'],
+    rules: {
+      'import/named': 'off',
+      'import/no-unresolved': 'off',
+      'import/no-cycle': 'off',
+      'import/extensions': 'off',
+    },
+  },
   // must be the last config in the array
   // https://github.com/prettier/eslint-plugin-prettier?tab=readme-ov-file#configuration-new-eslintconfigjs
   prettierRecommended,

data/lib/react_on_rails_pro/async_value.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  # AsyncValue wraps an Async task to provide a simple interface for
+  # retrieving the result of an async react_component render.
+  #
+  # @example
+  #   async_value = async_react_component("MyComponent", props: { name: "World" })
+  #   # ... do other work ...
+  #   html = async_value.value  # blocks until result is ready
+  #
+  class AsyncValue
+    def initialize(task:)
+      @task = task
+    end
+
+    # Blocks until result is ready, returns HTML string.
+    # If the async task raised an exception, it will be re-raised here.
+    def value
+      @task.wait
+    end
+
+    def resolved?
+      @task.finished?
+    end
+
+    def to_s
+      value.to_s
+    end
+
+    def html_safe
+      value.html_safe
+    end
+  end
+end

data/lib/react_on_rails_pro/concerns/async_rendering.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ReactOnRailsPro
+  # AsyncRendering enables concurrent rendering of multiple React components.
+  # When enabled, async_react_component calls will execute their HTTP requests
+  # in parallel instead of sequentially.
+  #
+  # @example Enable for all actions
+  #   class ProductsController < ApplicationController
+  #     include ReactOnRailsPro::AsyncRendering
+  #     enable_async_react_rendering
+  #   end
+  #
+  # @example Enable for specific actions only
+  #   class ProductsController < ApplicationController
+  #     include ReactOnRailsPro::AsyncRendering
+  #     enable_async_react_rendering only: [:show, :index]
+  #   end
+  #
+  # @example Enable for all except specific actions
+  #   class ProductsController < ApplicationController
+  #     include ReactOnRailsPro::AsyncRendering
+  #     enable_async_react_rendering except: [:create, :update]
+  #   end
+  #
+  module AsyncRendering
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Enables async React component rendering for controller actions.
+      # Accepts standard Rails filter options like :only and :except.
+      #
+      # @param options [Hash] Options passed to around_action (e.g., only:, except:)
+      def enable_async_react_rendering(**options)
+        around_action :wrap_in_async_react_context, **options
+      end
+    end
+
+    private
+
+    def wrap_in_async_react_context
+      require "async"
+      require "async/barrier"
+
+      Sync do
+        @react_on_rails_async_barrier = Async::Barrier.new
+        yield
+        check_for_unresolved_async_components
+      ensure
+        @react_on_rails_async_barrier&.stop
+        @react_on_rails_async_barrier = nil
+      end
+    end
+
+    def check_for_unresolved_async_components
+      return if @react_on_rails_async_barrier.nil?
+
+      pending_tasks = @react_on_rails_async_barrier.size
+      return if pending_tasks.zero?
+
+      Rails.logger.error(
+        "[React on Rails Pro] #{pending_tasks} async component(s) were started but never resolved. " \
+        "Make sure to call .value on all AsyncValue objects returned by async_react_component " \
+        "or cached_async_react_component. Unresolved tasks will be stopped."
+      )
+    end
+  end
+end