react_on_rails_pro 17.1.0.rc.1 → 17.1.0.rc.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 161dafc96a1df0f6a646aecb23c4a8f6e266ef7d08ba12ea96fdb54568d86fce
-  data.tar.gz: d596bae3e825c5d7d436947dce7bb63d372e5a373b049b7f87fdcd190b4943c3
+  metadata.gz: af819b8f0320a216aaa75d812fa78f376694161a3225932570950158241bced4
+  data.tar.gz: b3d8ce02b32b91360b89b2278d05a5e5ba5716cbd7a5a909e2c000e89e0f93d5
 SHA512:
-  metadata.gz: f462b4af0cd52ef87917277edb7d1a6b5e706ea7b0cdd63814a1c0304ab3dc8fac150783b24ed8ef1e2a01f13c5d1fbfae334982bc83a0d88cb9e7ec82d766d5
-  data.tar.gz: 258b491c7b0d939e8c913388e631a96ab4cbbb433963e65e0e4a89e0b8644d2654f84e40f2ed4ce2501f6bf0dce2a46efef53d3d351ce62a84e741cf718bab9b
+  metadata.gz: ffdefae73ac6d2f573b4d2041c81484356d6aaf17968e1a33187b6fefdefd4017eda37a6471e6bdd2dbac82f6ed64ba85a7e0fee11208513137b439712c5af58
+  data.tar.gz: 3f53042c50b650ef0407db5a763a8378caa2ff03643f3047c690a4c601ed6d1b027ee150614ae903027ead086ff677d2b44b1a5c5715f4a6846718e749efe985

data/Gemfile.lock

@@ -9,7 +9,7 @@ GIT
 PATH
   remote: ..
   specs:
-    react_on_rails (17.1.0.rc.1)
+    react_on_rails (17.1.0.rc.2)
       addressable
       connection_pool
       execjs (~> 2.5)
@@ -20,14 +20,14 @@ PATH
 PATH
   remote: .
   specs:
-    react_on_rails_pro (17.1.0.rc.1)
+    react_on_rails_pro (17.1.0.rc.2)
       async (>= 2.29)
       async-http (~> 0.95)
       execjs (~> 2.9)
       io-endpoint (~> 0.17.0)
       jwt (>= 2.5, < 4)
       nokogiri (>= 1.12, < 2)
-      react_on_rails (= 17.1.0.rc.1)
+      react_on_rails (= 17.1.0.rc.2)
 
 GEM
   remote: https://rubygems.org/

data/lib/react_on_rails_pro/server_rendering_pool/pro_rendering.rb

@@ -95,16 +95,24 @@ module ReactOnRailsPro
         end
 
         def render_streaming_with_cache(prerender_cache_key, js_code, render_options)
-          # Streaming path: try to serve from cache; otherwise wrap upstream stream
+          # Streaming path: try to serve from cache; otherwise wrap upstream stream.
+          # The cache key ignores random dom ids, so a cached stream may have been produced for
+          # another mount point; StreamCache rebinds it to this render's dom id (issue #4984).
           cache_options = render_options.internal_option(:cache_options)
-          cached_stream = ReactOnRailsPro::StreamCache.fetch_stream(prerender_cache_key, cache_options:)
+          dom_node_id = render_options.dom_id
+          cached_stream = ReactOnRailsPro::StreamCache.fetch_stream(
+            prerender_cache_key,
+            cache_options:,
+            dom_node_id:
+          )
           return cached_stream if cached_stream
 
           upstream = render_on_pool(js_code, render_options)
           ReactOnRailsPro::StreamCache.wrap_and_cache(
             prerender_cache_key,
             upstream,
-            cache_options:
+            cache_options:,
+            dom_node_id:
           )
         end
 

data/lib/react_on_rails_pro/stream_cache.rb

@@ -15,22 +15,38 @@
 
 module ReactOnRailsPro
   class StreamCache
+    CACHED_CHUNKS_KEY = "chunks"
+    CACHED_DOM_NODE_ID_KEY = "dom_node_id"
+
     class << self
       # Returns a stream-like object that responds to `each_chunk` and yields cached chunks
       # or nil if not present in cache. Pass the same cache_options given to wrap_and_cache
       # so key-altering options such as :namespace resolve to the written entry.
-      def fetch_stream(cache_key, cache_options: nil)
-        cached_chunks = Rails.cache.read(cache_key, cache_options)
-        return nil unless cached_chunks.is_a?(Array)
+      #
+      # `dom_node_id` is the mount point of the render being served. The prerender cache key
+      # deliberately ignores random dom ids (see ProRendering.without_random_values) so one
+      # cached render serves every mount point, but the cached chunks embed the dom id of the
+      # render that produced them (RSC payload keys, console replay scripts). Replaying them
+      # unchanged under another mount id leaves the browser without an embedded payload for
+      # its own node, so cached chunks are rebound to the current dom id on the way out.
+      # See https://github.com/shakacode/react_on_rails/issues/4984.
+      def fetch_stream(cache_key, cache_options: nil, dom_node_id: nil)
+        entry = cached_entry(Rails.cache.read(cache_key, cache_options))
+        return nil unless entry
 
-        build_stream_from_chunks(cached_chunks)
+        chunks = DomNodeIdRewriter.rewrite(
+          entry.fetch(CACHED_CHUNKS_KEY),
+          from: entry[CACHED_DOM_NODE_ID_KEY],
+          to: dom_node_id
+        )
+        build_stream_from_chunks(chunks)
       end
 
       # Wraps an upstream stream (responds to `each_chunk`), yields chunks downstream while
-      # buffering them, and writes the chunks array to Rails.cache on successful completion.
-      # Returns a stream-like object that responds to `each_chunk`.
-      def wrap_and_cache(cache_key, upstream_stream, cache_options: nil)
-        component = CachingComponent.new(upstream_stream, cache_key, cache_options)
+      # buffering them, and writes the chunks array plus the producing dom id to Rails.cache on
+      # successful completion. Returns a stream-like object that responds to `each_chunk`.
+      def wrap_and_cache(cache_key, upstream_stream, cache_options: nil, dom_node_id: nil)
+        component = CachingComponent.new(upstream_stream, cache_key, cache_options, dom_node_id)
         ReactOnRailsPro::StreamDecorator.new(component)
       end
 
@@ -39,6 +55,97 @@ module ReactOnRailsPro
         component = CachedChunksComponent.new(chunks)
         ReactOnRailsPro::StreamDecorator.new(component)
       end
+
+      private
+
+      # Entries written before the producing dom id was retained were bare chunk arrays. They
+      # cannot be rebound safely, so they are treated as a miss and re-rendered into the current
+      # shape. (The base cache key also embeds the Pro version, so such entries are not normally
+      # reachable after an upgrade.)
+      def cached_entry(cached)
+        return nil unless cached.is_a?(Hash) && cached[CACHED_CHUNKS_KEY].is_a?(Array)
+
+        cached
+      end
+    end
+
+    # Rebinds the dom id embedded in cached chunks to the mount point of the current render.
+    # Chunks are either Strings or renderer Hashes whose "html" and "consoleReplayScript" values
+    # carry the markup. The html is rewritten as one document and re-split at the original chunk
+    # boundaries, so an id that straddles two chunks is still replaced and the frame count is kept.
+    module DomNodeIdRewriter
+      HTML_KEY = "html"
+      CONSOLE_REPLAY_SCRIPT_KEY = "consoleReplayScript"
+
+      module_function
+
+      def rewrite(chunks, from:, to:)
+        return chunks if from.to_s.empty? || to.to_s.empty? || from == to
+
+        html_pieces = chunks.map { |chunk| markup_of(chunk) }
+        rewritten_html = resplit(
+          html_pieces.join, html_pieces.map(&:bytesize), from, to,
+          landing_index: chunks.index { |chunk| markup?(chunk) } || 0
+        )
+        chunks.each_with_index.map { |chunk, index| rebind_chunk(chunk, rewritten_html[index], from, to) }
+      end
+
+      def markup?(chunk)
+        chunk.is_a?(String) || (chunk.is_a?(Hash) && chunk[HTML_KEY].is_a?(String))
+      end
+
+      # Every chunk contributes its markup to one joined document: a String chunk is the markup
+      # itself, a Hash chunk contributes its "html", anything else contributes nothing.
+      def markup_of(chunk)
+        return chunk if chunk.is_a?(String)
+        return chunk[HTML_KEY] if chunk.is_a?(Hash) && chunk[HTML_KEY].is_a?(String)
+
+        ""
+      end
+
+      def rebind_chunk(chunk, rewritten_html, from, to)
+        return rewritten_html if chunk.is_a?(String)
+        return chunk unless chunk.is_a?(Hash)
+
+        rebind_hash(chunk, rewritten_html, from, to)
+      end
+
+      def rebind_hash(chunk, rewritten_html, from, to)
+        rebound = chunk.dup
+        rebound[HTML_KEY] = rewritten_html if chunk[HTML_KEY].is_a?(String)
+        if chunk[CONSOLE_REPLAY_SCRIPT_KEY].is_a?(String)
+          rebound[CONSOLE_REPLAY_SCRIPT_KEY] = replace_literal(chunk[CONSOLE_REPLAY_SCRIPT_KEY], from, to)
+        end
+        rebound
+      end
+
+      # Splits `document` back into pieces sized like `sizes` (in bytes). Random dom ids share one
+      # format, so the substitution keeps every byte offset and the original boundaries are exact.
+      # If the ids ever differ in length, byte offsets would no longer align (and could cut a
+      # multibyte character), so the whole rewritten document is delivered in the first piece that
+      # carries markup (`landing_index`) and every other piece is empty; the concatenation is
+      # identical either way.
+      def resplit(document, sizes, from, to, landing_index: 0)
+        rewritten = replace_literal(document, from, to)
+        if from.bytesize != to.bytesize
+          pieces = Array.new(sizes.length, "")
+          pieces[landing_index] = rewritten unless pieces.empty?
+          return pieces
+        end
+
+        offset = 0
+        sizes.each_with_index.map do |size, index|
+          piece = index == sizes.length - 1 ? rewritten.byteslice(offset..) : rewritten.byteslice(offset, size)
+          offset += size
+          piece || ""
+        end
+      end
+
+      # The block form keeps `to` literal: a String replacement would interpret backreference
+      # sequences such as `\0` or `\\`.
+      def replace_literal(text, from, to)
+        text.gsub(from) { to }
+      end
     end
 
     class CachedChunksComponent
@@ -54,10 +161,11 @@ module ReactOnRailsPro
     end
 
     class CachingComponent
-      def initialize(upstream_stream, cache_key, cache_options)
+      def initialize(upstream_stream, cache_key, cache_options, dom_node_id = nil)
         @upstream_stream = upstream_stream
         @cache_key = cache_key
         @cache_options = cache_options
+        @dom_node_id = dom_node_id
       end
 
       def each_chunk(&block)
@@ -85,7 +193,11 @@ module ReactOnRailsPro
         # See https://github.com/shakacode/react_on_rails/issues/4581.
         return if stream_has_errors
 
-        Rails.cache.write(@cache_key, buffered_chunks, @cache_options || {})
+        Rails.cache.write(
+          @cache_key,
+          { CACHED_DOM_NODE_ID_KEY => @dom_node_id, CACHED_CHUNKS_KEY => buffered_chunks },
+          @cache_options || {}
+        )
       end
 
       private

data/lib/react_on_rails_pro/version.rb

@@ -14,6 +14,6 @@
 # https://github.com/shakacode/react_on_rails/blob/main/REACT-ON-RAILS-PRO-LICENSE.md
 
 module ReactOnRailsPro
-  VERSION = "17.1.0.rc.1"
+  VERSION = "17.1.0.rc.2"
   PROTOCOL_VERSION = "2.0.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: react_on_rails_pro
 version: !ruby/object:Gem::Version
-  version: 17.1.0.rc.1
+  version: 17.1.0.rc.2
 platform: ruby
 authors:
 - Justin Gordon
@@ -111,14 +111,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 17.1.0.rc.1
+        version: 17.1.0.rc.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 17.1.0.rc.1
+        version: 17.1.0.rc.2
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement