react_on_rails 16.1.2 → 16.2.0

data/lib/react_on_rails/helper.rb

@@ -7,16 +7,17 @@
 # 1. The white spacing in this file matters!
 # 2. Keep all #{some_var} fully to the left so that all indentation is done evenly in that var
 require "react_on_rails/prerender_error"
+require "react_on_rails/smart_error"
 require "addressable/uri"
 require "react_on_rails/utils"
 require "react_on_rails/json_output"
 require "active_support/concern"
-require "react_on_rails/pro/helper"
+require "react_on_rails/pro_helper"
 
 module ReactOnRails
   module Helper
     include ReactOnRails::Utils::Required
-    include ReactOnRails::Pro::Helper
+    include ReactOnRails::ProHelper
 
     COMPONENT_HTML_KEY = "componentHtml"
 
@@ -94,104 +95,6 @@ module ReactOnRails
       end
     end
 
-    # Streams a server-side rendered React component using React's `renderToPipeableStream`.
-    # Supports React 18 features like Suspense, concurrent rendering, and selective hydration.
-    # Enables progressive rendering and improved performance for large components.
-    #
-    # Note: This function can only be used with React on Rails Pro.
-    # The view that uses this function must be rendered using the
-    # `stream_view_containing_react_components` method from the React on Rails Pro gem.
-    #
-    # Example of an async React component that can benefit from streaming:
-    #
-    # const AsyncComponent = async () => {
-    #   const data = await fetchData();
-    #   return <div>{data}</div>;
-    # };
-    #
-    # function App() {
-    #   return (
-    #     <Suspense fallback={<div>Loading...</div>}>
-    #       <AsyncComponent />
-    #     </Suspense>
-    #   );
-    # }
-    #
-    # @param [String] component_name Name of your registered component
-    # @param [Hash] options Options for rendering
-    # @option options [Hash] :props Props to pass to the react component
-    # @option options [String] :dom_id DOM ID of the component container
-    # @option options [Hash] :html_options Options passed to content_tag
-    # @option options [Boolean] :trace Set to true to add extra debugging information to the HTML
-    # @option options [Boolean] :raise_on_prerender_error Set to true to raise exceptions during server-side rendering
-    # Any other options are passed to the content tag, including the id.
-    def stream_react_component(component_name, options = {})
-      # stream_react_component doesn't have the prerender option
-      # 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
-        internal_stream_react_component(component_name, options)
-      end
-    end
-
-    # Renders the React Server Component (RSC) payload for a given component. This helper generates
-    # a special format designed by React for serializing server components and transmitting them
-    # to the client.
-    #
-    # @return [String] Returns a Newline Delimited JSON (NDJSON) stream where each line contains a JSON object with:
-    #   - html: The RSC payload containing the rendered server components and client component references
-    #   - consoleReplayScript: JavaScript to replay server-side console logs in the client
-    #   - hasErrors: Boolean indicating if any errors occurred during rendering
-    #   - isShellReady: Boolean indicating if the initial shell is ready for hydration
-    #
-    # Example NDJSON stream:
-    #   {"html":"<RSC Payload>","consoleReplayScript":"","hasErrors":false,"isShellReady":true}
-    #   {"html":"<RSC Payload>","consoleReplayScript":"console.log('Loading...')","hasErrors":false,"isShellReady":true}
-    #
-    # The RSC payload within the html field contains:
-    # - The component's rendered output from the server
-    # - References to client components that need hydration
-    # - Data props passed to client components
-    #
-    # @param component_name [String] The name of the React component to render. This component should
-    #   be a server component or a mixed component tree containing both server and client components.
-    #
-    # @param options [Hash] Options for rendering the component
-    # @option options [Hash] :props Props to pass to the component (default: {})
-    # @option options [Boolean] :trace Enable tracing for debugging (default: false)
-    # @option options [String] :id Custom DOM ID for the component container (optional)
-    #
-    # @example Basic usage with a server component
-    #   <%= rsc_payload_react_component("ReactServerComponentPage") %>
-    #
-    # @example With props and tracing enabled
-    #   <%= rsc_payload_react_component("RSCPostsPage",
-    #         props: { artificialDelay: 1000 },
-    #         trace: true) %>
-    #
-    # @note This helper requires React Server Components support to be enabled in your configuration:
-    #   ReactOnRailsPro.configure do |config|
-    #     config.enable_rsc_support = true
-    #   end
-    #
-    # @raise [ReactOnRailsPro::Error] if RSC support is not enabled in configuration
-    #
-    # @note You don't have to deal directly with this helper function - it's used internally by the
-    # `rsc_payload_route` helper function. The returned data from this function is used internally by
-    # components registered using the `registerServerComponent` function. Don't use it unless you need
-    # more control over the RSC payload generation. To know more about RSC payload, see the following link:
-    # @see https://www.shakacode.com/react-on-rails-pro/docs/how-react-server-components-works.md
-    #   for technical details about the RSC payload format
-    def rsc_payload_react_component(component_name, options = {})
-      # 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
-        internal_rsc_payload_react_component(component_name, options)
-      end
-    end
-
     # react_component_hash is used to return multiple HTML strings for server rendering, such as for
     # adding meta-tags to a page.
     # It is exactly like react_component except for the following:
@@ -252,10 +155,10 @@ module ReactOnRails
     # props: Ruby Hash or JSON string which contains the properties to pass to the redux store.
     # Options
     #    defer: false -- pass as true if you wish to render this below your component.
-    #    immediate_hydration: false -- React on Rails Pro (licensed) feature. Pass as true if you wish to
-    #                        hydrate this store immediately instead of waiting for the page to load.
+    #    immediate_hydration: nil -- React on Rails Pro (licensed) feature. When nil (default), Pro users
+    #                        get immediate hydration, non-Pro users don't. Can be explicitly overridden.
     def redux_store(store_name, props: {}, defer: false, immediate_hydration: nil)
-      immediate_hydration = ReactOnRails.configuration.immediate_hydration if immediate_hydration.nil?
+      immediate_hydration = ReactOnRails::Utils.normalize_immediate_hydration(immediate_hydration, store_name, "Store")
 
       redux_store_data = { store_name: store_name,
                            props: props,
@@ -323,7 +226,7 @@ module ReactOnRails
           }
         }
 
-        consoleReplayScript = ReactOnRails.buildConsoleReplay();
+        consoleReplayScript = ReactOnRails.getConsoleReplayScript();
 
         return JSON.stringify({
             html: htmlResult,
@@ -339,8 +242,9 @@ module ReactOnRails
                .server_render_js_with_console_logging(js_code, render_options)
 
       html = result["html"]
-      console_log_script = result["consoleLogScript"]
-      raw("#{html}#{console_log_script if render_options.replay_console}")
+      console_script = result["consoleReplayScript"]
+      console_script_tag = wrap_console_script_with_nonce(console_script) if render_options.replay_console
+      raw("#{html}#{console_script_tag}")
     rescue ExecJS::ProgramError => err
       raise ReactOnRails::PrerenderError.new(component_name: "N/A (server_render_js called)",
                                              err: err,
@@ -366,7 +270,7 @@ module ReactOnRails
     #
     # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
     def rails_context(server_side: true)
-      # ALERT: Keep in sync with node_package/src/types/index.ts for the properties of RailsContext
+      # ALERT: Keep in sync with packages/react-on-rails/src/types/index.ts for the properties of RailsContext
       @rails_context ||= begin
         result = {
           componentRegistryTimeout: ReactOnRails.configuration.component_registry_timeout,
@@ -446,32 +350,6 @@ module ReactOnRails
 
     # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
-    def run_stream_inside_fiber
-      unless ReactOnRails::Utils.react_on_rails_pro?
-        raise ReactOnRails::Error,
-              "You must use React on Rails Pro to use the stream_react_component method."
-      end
-
-      if @rorp_rendering_fibers.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
-        stream = yield
-        stream.each_chunk do |chunk|
-          Fiber.yield chunk
-        end
-      end
-
-      @rorp_rendering_fibers << rendering_fiber
-
-      # 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
-    end
-
     def registered_stores
       @registered_stores ||= []
     end
@@ -494,25 +372,6 @@ module ReactOnRails
                                                       options: options)
     end
 
-    def internal_stream_react_component(component_name, options = {})
-      options = options.merge(render_mode: :html_streaming)
-      result = internal_react_component(component_name, options)
-      build_react_component_result_for_server_streamed_content(
-        rendered_html_stream: result[:result],
-        component_specification_tag: result[:tag],
-        render_options: result[:render_options]
-      )
-    end
-
-    def internal_rsc_payload_react_component(react_component_name, options = {})
-      options = options.merge(render_mode: :rsc_payload_streaming)
-      render_options = create_render_options(react_component_name, options)
-      json_stream = server_rendered_react_component(render_options)
-      json_stream.transform do |chunk|
-        "#{chunk.to_json}\n".html_safe
-      end
-    end
-
     def generated_components_pack_path(component_name)
       "#{ReactOnRails::PackerUtils.packer_source_entry_path}/generated/#{component_name}.js"
     end
@@ -536,7 +395,7 @@ module ReactOnRails
                                     server_rendered_html.html_safe,
                                     content_tag_options)
 
-      result_console_script = render_options.replay_console ? console_script : ""
+      result_console_script = render_options.replay_console ? wrap_console_script_with_nonce(console_script) : ""
       result = compose_react_component_html_with_spec_and_console(
         component_specification_tag, rendered_output, result_console_script
       )
@@ -544,32 +403,6 @@ module ReactOnRails
       prepend_render_rails_context(result)
     end
 
-    def build_react_component_result_for_server_streamed_content(
-      rendered_html_stream:,
-      component_specification_tag:,
-      render_options:
-    )
-      is_first_chunk = true
-      rendered_html_stream.transform do |chunk_json_result|
-        if is_first_chunk
-          is_first_chunk = false
-          build_react_component_result_for_server_rendered_string(
-            server_rendered_html: chunk_json_result["html"],
-            component_specification_tag: component_specification_tag,
-            console_script: chunk_json_result["consoleReplayScript"],
-            render_options: render_options
-          )
-        else
-          result_console_script = render_options.replay_console ? chunk_json_result["consoleReplayScript"] : ""
-          # 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(
-            "", chunk_json_result["html"], result_console_script
-          )
-        end
-      end
-    end
-
     def build_react_component_result_for_server_rendered_hash(
       server_rendered_html: required("server_rendered_html"),
       component_specification_tag: required("component_specification_tag"),
@@ -587,7 +420,7 @@ module ReactOnRails
                                     server_rendered_html[COMPONENT_HTML_KEY].html_safe,
                                     content_tag_options)
 
-      result_console_script = render_options.replay_console ? console_script : ""
+      result_console_script = render_options.replay_console ? wrap_console_script_with_nonce(console_script) : ""
       result = compose_react_component_html_with_spec_and_console(
         component_specification_tag, rendered_output, result_console_script
       )
@@ -604,6 +437,32 @@ module ReactOnRails
       )
     end
 
+    # Wraps console replay JavaScript code in a script tag with CSP nonce if available.
+    # The console_script_code is already sanitized by scriptSanitizedVal() in the JavaScript layer,
+    # so using html_safe here is secure.
+    def wrap_console_script_with_nonce(console_script_code)
+      return "" if console_script_code.blank?
+
+      # Get the CSP nonce if available (Rails 5.2+)
+      # Rails 5.2-6.0 use content_security_policy_nonce with no arguments
+      # Rails 6.1+ accept an optional directive argument
+      nonce = if respond_to?(:content_security_policy_nonce)
+                begin
+                  content_security_policy_nonce(:script)
+                rescue ArgumentError
+                  # Fallback for Rails versions that don't accept arguments
+                  content_security_policy_nonce
+                end
+              end
+
+      # Build the script tag with nonce if available
+      script_options = { id: "consoleReplayLog" }
+      script_options[:nonce] = nonce if nonce.present?
+
+      # Safe to use html_safe because content is pre-sanitized via scriptSanitizedVal()
+      content_tag(:script, console_script_code.html_safe, script_options)
+    end
+
     def compose_react_component_html_with_spec_and_console(component_specification_tag, rendered_output,
                                                            console_script)
       # IMPORTANT: Ensure that we mark string as html_safe to avoid escaping.
@@ -620,10 +479,23 @@ module ReactOnRails
 
       @rendered_rails_context = true
 
-      content_tag(:script,
-                  json_safe_and_pretty(data).html_safe,
-                  type: "application/json",
-                  id: "js-react-on-rails-context")
+      attribution_comment = react_on_rails_attribution_comment
+      script_tag = content_tag(:script,
+                               json_safe_and_pretty(data).html_safe,
+                               type: "application/json",
+                               id: "js-react-on-rails-context")
+
+      "#{attribution_comment}\n#{script_tag}".html_safe
+    end
+
+    # Generates the HTML attribution comment
+    # Pro version calls ReactOnRailsPro::Utils for license-specific details
+    def react_on_rails_attribution_comment
+      if ReactOnRails::Utils.react_on_rails_pro?
+        ReactOnRailsPro::Utils.pro_attribution_comment
+      else
+        "<!-- Powered by React on Rails (c) ShakaCode | Open Source -->"
+      end
     end
 
     # prepend the rails_context if not yet applied
@@ -742,6 +614,15 @@ module ReactOnRails
           # It doesn't make any transformation, it listens and raises error if a chunk has errors
           chunk_json_result
         end
+
+        result.rescue do |err|
+          # This error came from the renderer
+          raise ReactOnRails::PrerenderError.new(component_name: react_component_name,
+                                                 # Sanitize as this might be browser logged
+                                                 props: sanitized_props_string(props),
+                                                 err: err,
+                                                 js_code: js_code)
+        end
       elsif result["hasErrors"] && render_options.raise_on_prerender_error
         raise_prerender_error(result, react_component_name, props, js_code)
       end
@@ -794,14 +675,11 @@ module ReactOnRails
     end
 
     def raise_missing_autoloaded_bundle(react_component_name)
-      msg = <<~MSG
-        **ERROR** ReactOnRails: Component "#{react_component_name}" is configured as "auto_load_bundle: true"
-        but the generated component entrypoint, which should have been at #{generated_components_pack_path(react_component_name)},
-        is missing. You might want to check that this component is in a directory named "#{ReactOnRails.configuration.components_subdirectory}"
-        & that "bundle exec rake react_on_rails:generate_packs" has been run.
-      MSG
-
-      raise ReactOnRails::Error, msg
+      raise ReactOnRails::SmartError.new(
+        error_type: :missing_auto_loaded_bundle,
+        component_name: react_component_name,
+        expected_path: generated_components_pack_path(react_component_name)
+      )
     end
   end
 end

data/lib/react_on_rails/locales/base.rb

@@ -4,7 +4,7 @@ require "erb"
 
 module ReactOnRails
   module Locales
-    def self.compile
+    def self.compile(force: false)
       config = ReactOnRails.configuration
       check_config_directory_exists(
         directory: config.i18n_dir, key_name: "config.i18n_dir",
@@ -15,9 +15,9 @@ module ReactOnRails
         remove_if: "not using this i18n with React on Rails, or if you want to use all translation files"
       )
       if config.i18n_output_format&.downcase == "js"
-        ReactOnRails::Locales::ToJs.new
+        ReactOnRails::Locales::ToJs.new(force: force)
       else
-        ReactOnRails::Locales::ToJson.new
+        ReactOnRails::Locales::ToJson.new(force: force)
       end
     end
 
@@ -36,12 +36,23 @@ module ReactOnRails
     private_class_method :check_config_directory_exists
 
     class Base
-      def initialize
+      def initialize(force: false)
         return if i18n_dir.nil?
-        return unless obsolete?
+
+        if locale_files.empty?
+          puts "Warning: No locale files found in #{i18n_yml_dir || 'Rails i18n load path'}"
+          return
+        end
+
+        if !force && !obsolete?
+          puts "Locale files are up to date, skipping generation. " \
+               "Use 'rake react_on_rails:locale force=true' to force regeneration."
+          return
+        end
 
         @translations, @defaults = generate_translations
         convert
+        puts "Generated locale files in #{i18n_dir}"
       end
 
       private
@@ -49,6 +60,7 @@ module ReactOnRails
       def file_format; end
 
       def obsolete?
+        return true if exist_files.length != files.length # Some files missing
         return true if exist_files.empty?
 
         files_are_outdated

data/lib/react_on_rails/packer_utils.rb

@@ -55,8 +55,12 @@ module ReactOnRails
       # the webpack-dev-server is provided by the config value
       # "same_bundle_for_client_and_server" where a value of true
       # would mean that the bundle is created by the webpack-dev-server
-      is_bundle_running_on_server = (bundle_name == ReactOnRails.configuration.server_bundle_js_file) ||
-                                    (bundle_name == ReactOnRails.configuration.rsc_bundle_js_file)
+      is_bundle_running_on_server = bundle_name == ReactOnRails.configuration.server_bundle_js_file
+
+      # Check Pro RSC bundle if Pro is available
+      if ReactOnRails::Utils.react_on_rails_pro?
+        is_bundle_running_on_server ||= (bundle_name == ReactOnRailsPro.configuration.rsc_bundle_js_file)
+      end
 
       if ::Shakapacker.dev_server.running? && (!is_bundle_running_on_server ||
         ReactOnRails.configuration.same_bundle_for_client_and_server)
@@ -162,5 +166,78 @@ module ReactOnRails
 
       raise ReactOnRails::Error, msg
     end
+
+    # Check if shakapacker.yml has a precompile hook configured
+    # This prevents react_on_rails from running generate_packs twice
+    #
+    # Returns false if detection fails for any reason (missing shakapacker, malformed config, etc.)
+    # to ensure generate_packs runs rather than being incorrectly skipped
+    #
+    # Note: Currently checks a single hook value. Future enhancement will support hook lists
+    # to allow prepending/appending multiple commands. See related Shakapacker issue for details.
+    def self.shakapacker_precompile_hook_configured?
+      return false unless defined?(::Shakapacker)
+
+      hook_value = extract_precompile_hook
+      return false if hook_value.nil?
+
+      hook_contains_generate_packs?(hook_value)
+    rescue StandardError => e
+      # Swallow errors during hook detection to fail safe - if we can't detect the hook,
+      # we should run generate_packs rather than skip it incorrectly.
+      # Possible errors: NoMethodError (config method missing), TypeError (unexpected data structure),
+      # or errors from shakapacker's internal implementation changes
+      warn "Warning: Unable to detect shakapacker precompile hook: #{e.message}" if ENV["DEBUG"]
+      false
+    end
+
+    def self.extract_precompile_hook
+      # Access config data using private :data method since there's no public API
+      # to access the raw configuration hash needed for hook detection
+      config_data = ::Shakapacker.config.send(:data)
+
+      # Try symbol keys first (Shakapacker's internal format), then fall back to string keys
+      # The key is 'precompile_hook' at the top level of the config
+      config_data&.[](:precompile_hook) || config_data&.[]("precompile_hook")
+    end
+
+    def self.hook_contains_generate_packs?(hook_value)
+      # The hook value can be either:
+      # 1. A direct command containing the rake task
+      # 2. A path to a script file that needs to be read
+      return false if hook_value.blank?
+
+      # Check if it's a direct command first
+      return true if hook_value.to_s.match?(/\breact_on_rails:generate_packs\b/)
+
+      # Check if it's a script file path
+      script_path = resolve_hook_script_path(hook_value)
+      return false unless script_path && File.exist?(script_path)
+
+      # Read and check script contents
+      script_contents = File.read(script_path)
+      script_contents.match?(/\breact_on_rails:generate_packs\b/)
+    rescue StandardError
+      # If we can't read the script, assume it doesn't contain generate_packs
+      false
+    end
+
+    def self.resolve_hook_script_path(hook_value)
+      # Hook value might be a script path relative to Rails root
+      return nil unless defined?(Rails) && Rails.respond_to?(:root)
+
+      potential_path = Rails.root.join(hook_value.to_s.strip)
+      potential_path if potential_path.file?
+    end
+
+    # Returns the configured precompile hook value for logging/debugging
+    # Returns nil if no hook is configured
+    def self.shakapacker_precompile_hook_value
+      return nil unless defined?(::Shakapacker)
+
+      extract_precompile_hook
+    rescue StandardError
+      nil
+    end
   end
 end