Refactor generateRSCPayload from global to parameter

Fix data leakage issue by passing generateRSCPayload as a parameter
instead of defining it as a global function in the VM context.

Changes:
- Changed globalThis.generateRSCPayload to local const in server_rendering_js_code.rb
- Pass generateRSCPayload as parameter to ReactOnRails rendering functions
- Update RSCRequestTracker to accept generateRSCPayload in constructor
- Update streamingUtils to extract and pass generateRSCPayload from options
- Add GenerateRSCPayloadFunction type and add to Params interface
- Update test fixtures to reflect new local function pattern

This prevents concurrent requests from sharing state and eliminates
potential race conditions where one request could use another's context.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: AbanoubGhadban

packages/react-on-rails-pro/src/RSCRequestTracker.ts

@@ -17,26 +17,10 @@ import {
   RSCPayloadStreamInfo,
   RSCPayloadCallback,
   RailsContextWithServerComponentMetadata,
+  GenerateRSCPayloadFunction,
 } from 'react-on-rails/types';
 import { extractErrorMessage } from './utils.ts';
 
-/**
- * Global function provided by React on Rails Pro for generating RSC payloads.
- *
- * This function is injected into the global scope during server-side rendering
- * by the RORP rendering request. It handles the actual generation of React Server
- * Component payloads on the server side.
- *
- * @see https://github.com/shakacode/react_on_rails_pro/blob/master/lib/react_on_rails_pro/server_rendering_js_code.rb
- */
-declare global {
-  function generateRSCPayload(
-    componentName: string,
-    props: unknown,
-    railsContext: RailsContextWithServerComponentMetadata,
-  ): Promise<NodeJS.ReadableStream>;
-}
-
 /**
  * RSC Request Tracker - manages RSC payload generation and tracking for a single request.
  *
@@ -52,8 +36,14 @@ class RSCRequestTracker {
 
   private railsContext: RailsContextWithServerComponentMetadata;
 
-  constructor(railsContext: RailsContextWithServerComponentMetadata) {
+  private generateRSCPayload?: GenerateRSCPayloadFunction;
+
+  constructor(
+    railsContext: RailsContextWithServerComponentMetadata,
+    generateRSCPayload?: GenerateRSCPayloadFunction,
+  ) {
     this.railsContext = railsContext;
+    this.generateRSCPayload = generateRSCPayload;
   }
 
   /**
@@ -120,8 +110,8 @@ class RSCRequestTracker {
    * @throws Error if generateRSCPayload is not available or fails
    */
   async getRSCPayloadStream(componentName: string, props: unknown): Promise<NodeJS.ReadableStream> {
-    // Validate that the global generateRSCPayload function is available
-    if (typeof generateRSCPayload !== 'function') {
+    // Validate that the generateRSCPayload function is available
+    if (!this.generateRSCPayload) {
       throw new Error(
         'generateRSCPayload is not defined. Please ensure that you are using at least version 4.0.0 of ' +
           'React on Rails Pro and the Node renderer, and that ReactOnRailsPro.configuration.enable_rsc_support ' +
@@ -130,7 +120,7 @@ class RSCRequestTracker {
     }
 
     try {
-      const stream = await generateRSCPayload(componentName, props, this.railsContext);
+      const stream = await this.generateRSCPayload(componentName, props, this.railsContext);
 
       // Tee stream to allow for multiple consumers:
       //   1. stream1 - Used by React's runtime to perform server-side rendering

packages/react-on-rails-pro/src/streamingUtils.ts

@@ -181,11 +181,19 @@ export const streamServerRenderedComponent = <T, P extends RenderParams>(
   renderStrategy: StreamRenderer<T, P>,
   handleError: (options: ErrorOptions) => PipeableOrReadableStream,
 ): T => {
-  const { name: componentName, domNodeId, trace, props, railsContext, throwJsErrors } = options;
+  const {
+    name: componentName,
+    domNodeId,
+    trace,
+    props,
+    railsContext,
+    throwJsErrors,
+    generateRSCPayload,
+  } = options;
 
   assertRailsContextWithServerComponentMetadata(railsContext);
   const postSSRHookTracker = new PostSSRHookTracker();
-  const rscRequestTracker = new RSCRequestTracker(railsContext);
+  const rscRequestTracker = new RSCRequestTracker(railsContext, generateRSCPayload);
   const streamingTrackers = {
     postSSRHookTracker,
     rscRequestTracker,

packages/react-on-rails/src/types/index.ts

@@ -216,11 +216,18 @@ export interface RegisteredComponent {
 
 export type ItemRegistrationCallback<T> = (component: T) => void;
 
+export type GenerateRSCPayloadFunction = (
+  componentName: string,
+  props: unknown,
+  railsContext: RailsContext,
+) => Promise<NodeJS.ReadableStream>;
+
 interface Params {
   props?: Record<string, unknown>;
   railsContext?: RailsContext;
   domNodeId?: string;
   trace?: boolean;
+  generateRSCPayload?: GenerateRSCPayloadFunction;
 }
 
 export interface RenderParams extends Params {

react_on_rails_pro/lib/react_on_rails_pro/server_rendering_js_code.rb

@@ -37,13 +37,11 @@ def generate_rsc_payload_js_function(render_options)
           rscBundleHash: '#{ReactOnRailsPro::Utils.rsc_bundle_hash}',
         }
         const runOnOtherBundle = globalThis.runOnOtherBundle;
-        if (typeof generateRSCPayload !== 'function') {
-          globalThis.generateRSCPayload = function generateRSCPayload(componentName, props, railsContext) {
-            const { renderingRequest, rscBundleHash } = railsContext.serverSideRSCPayloadParameters;
-            const propsString = JSON.stringify(props);
-            const newRenderingRequest = renderingRequest.replace(/\\(\\s*\\)\\s*$/, `('${componentName}', ${propsString})`);
-            return runOnOtherBundle(rscBundleHash, newRenderingRequest);
-          }
+        const generateRSCPayload = function generateRSCPayload(componentName, props, railsContext) {
+          const { renderingRequest, rscBundleHash } = railsContext.serverSideRSCPayloadParameters;
+          const propsString = JSON.stringify(props);
+          const newRenderingRequest = renderingRequest.replace(/\\(\\s*\\)\\s*$/, `('${componentName}', ${propsString})`);
+          return runOnOtherBundle(rscBundleHash, newRenderingRequest);
         }
         JS
       end
@@ -94,6 +92,7 @@ def render(props_string, rails_context, redux_stores, react_component_name, rend
             railsContext: railsContext,
             throwJsErrors: #{ReactOnRailsPro.configuration.throw_js_errors},
             renderingReturnsPromises: #{ReactOnRailsPro.configuration.rendering_returns_promises},
+            generateRSCPayload: typeof generateRSCPayload !== 'undefined' ? generateRSCPayload : undefined,
           });
         })()
         JS

react_on_rails_pro/packages/node-renderer/tests/fixtures/projects/spec-dummy/asyncComponentsTreeForTestingRenderingRequest.js

@@ -9,13 +9,11 @@
   }
 
   const runOnOtherBundle = globalThis.runOnOtherBundle;
-  if (typeof generateRSCPayload !== 'function') {
-    globalThis.generateRSCPayload = function generateRSCPayload(componentName, props, railsContext) {
-      const { renderingRequest, rscBundleHash } = railsContext.serverSideRSCPayloadParameters;
-      const propsString = JSON.stringify(props);
-      const newRenderingRequest = renderingRequest.replace(/\(\s*\)\s*$/, `('${componentName}', ${propsString})`);
-      return runOnOtherBundle(rscBundleHash, newRenderingRequest);
-    }
+  const generateRSCPayload = function generateRSCPayload(componentName, props, railsContext) {
+    const { renderingRequest, rscBundleHash } = railsContext.serverSideRSCPayloadParameters;
+    const propsString = JSON.stringify(props);
+    const newRenderingRequest = renderingRequest.replace(/\(\s*\)\s*$/, `('${componentName}', ${propsString})`);
+    return runOnOtherBundle(rscBundleHash, newRenderingRequest);
   }
 
   ReactOnRails.clearHydratedStores();
@@ -35,5 +33,6 @@
     railsContext: railsContext,
     throwJsErrors: false,
     renderingReturnsPromises: true,
+    generateRSCPayload: typeof generateRSCPayload !== 'undefined' ? generateRSCPayload : undefined,
   });
 })()

react_on_rails_pro/packages/node-renderer/tests/incrementalHtmlStreaming.test.ts

@@ -161,8 +161,7 @@ it('incremental render html', async () => {
   close();
 });
 
-// TODO: fix the problem of having a global shared `runOnOtherBundle` function
-it.skip('raises an error if a specific async prop is not sent', async () => {
+it('raises an error if a specific async prop is not sent', async () => {
   const { status, body } = await makeRequest();
   expect(body).toBe('');
   expect(status).toBe(200);