react_on_rails 11.0.0 → 11.1.0

data/lib/react_on_rails/configuration.rb

@@ -1,103 +1,15 @@
 # frozen_string_literal: true
 
-# NOTE: ReactOnRails::Utils.using_webpacker? always will return false when called here.
-
 module ReactOnRails
   def self.configure
     yield(configuration)
-    setup_config_values
+    configuration.setup_config_values
   end
 
   DEFAULT_GENERATED_ASSETS_DIR = File.join(%w[public webpack], Rails.env).freeze
-
-  def self.setup_config_values
-    ensure_webpack_generated_files_exists
-    configure_generated_assets_dirs_deprecation
-    configure_skip_display_none_deprecation
-    ensure_generated_assets_dir_present
-    ensure_server_bundle_js_file_has_no_path
-    check_i18n_directory_exists
-    check_i18n_yml_directory_exists
-    check_server_render_method_is_only_execjs
-  end
-
-  def self.check_server_render_method_is_only_execjs
-    return if @configuration.server_render_method.blank? ||
-              @configuration.server_render_method == "ExecJS"
-
-    msg = <<-MSG.strip_heredoc
-      Error configuring /config/react_on_rails.rb: invalid value for `config.server_render_method`.
-      If you wish to use a server render method other than ExecJS, contact justin@shakacode.com
-      for details.
-    MSG
-    raise ReactOnRails::Error, msg
-  end
-
-  def self.check_i18n_directory_exists
-    return if @configuration.i18n_dir.nil?
-    return if Dir.exist?(@configuration.i18n_dir)
-
-    msg = <<-MSG.strip_heredoc
-      Error configuring /config/react_on_rails.rb: invalid value for `config.i18n_dir`.
-      Directory does not exist: #{@configuration.i18n_dir}. Set to value to nil or comment it
-      out if not using the React on Rails i18n feature.
-    MSG
-    raise ReactOnRails::Error, msg
-  end
-
-  def self.check_i18n_yml_directory_exists
-    return if @configuration.i18n_yml_dir.nil?
-    return if Dir.exist?(@configuration.i18n_yml_dir)
-
-    msg = <<-MSG.strip_heredoc
-      Error configuring /config/react_on_rails.rb: invalid value for `config.i18n_yml_dir`.
-      Directory does not exist: #{@configuration.i18n_yml_dir}. Set to value to nil or comment it
-      out if not using this i18n with React on Rails, or if you want to use all translation files.
-    MSG
-    raise ReactOnRails::Error, msg
-  end
-
-  def self.ensure_generated_assets_dir_present
-    return if @configuration.generated_assets_dir.present?
-
-    @configuration.generated_assets_dir = DEFAULT_GENERATED_ASSETS_DIR
-    puts "ReactOnRails: Set generated_assets_dir to default: #{DEFAULT_GENERATED_ASSETS_DIR}"
-  end
-
-  def self.configure_generated_assets_dirs_deprecation
-    return if @configuration.generated_assets_dirs.blank?
-
-    puts "[DEPRECATION] ReactOnRails: Use config.generated_assets_dir rather than "\
-        "generated_assets_dirs"
-    if @configuration.generated_assets_dir.blank?
-      @configuration.generated_assets_dir = @configuration.generated_assets_dirs
-    else
-      puts "[DEPRECATION] ReactOnRails. You have both generated_assets_dirs and "\
-          "generated_assets_dir defined. Define ONLY generated_assets_dir"
-    end
-  end
-
-  def self.ensure_webpack_generated_files_exists
-    return unless @configuration.webpack_generated_files.empty?
-
-    files = ["hello-world-bundle.js"]
-    files << @configuration.server_bundle_js_file if @configuration.server_bundle_js_file.present?
-
-    @configuration.webpack_generated_files = files
-  end
-
-  def self.ensure_server_bundle_js_file_has_no_path
-    return unless @configuration.server_bundle_js_file.include?(File::SEPARATOR)
-
-    puts "[DEPRECATION] ReactOnRails: remove path from server_bundle_js_file in configuration. "\
-        "All generated files must go in #{@configuration.generated_assets_dir}"
-    @configuration.server_bundle_js_file = File.basename(@configuration.server_bundle_js_file)
-  end
-
-  def self.configure_skip_display_none_deprecation
-    return if @configuration.skip_display_none.nil?
-    puts "[DEPRECATION] ReactOnRails: remove skip_display_none from configuration."
-  end
+  DEFAULT_SERVER_RENDER_TIMEOUT = 20
+  DEFAULT_POOL_SIZE = 1
+  DEFAULT_RANDOM_DOM_ID = TRUE # for backwards compatability
 
   def self.configuration
     @configuration ||= Configuration.new(
@@ -112,8 +24,8 @@ module ReactOnRails
       raise_on_prerender_error: false,
       trace: Rails.env.development?,
       development_mode: Rails.env.development?,
-      server_renderer_pool_size: 1,
-      server_renderer_timeout: 20,
+      server_renderer_pool_size: DEFAULT_POOL_SIZE,
+      server_renderer_timeout: DEFAULT_SERVER_RENDER_TIMEOUT,
       skip_display_none: nil,
       # skip_display_none is deprecated
       webpack_generated_files: %w[manifest.json],
@@ -121,7 +33,8 @@ module ReactOnRails
       server_render_method: nil,
       symlink_non_digested_assets_regex: nil,
       build_test_command: "",
-      build_production_command: ""
+      build_production_command: "",
+      random_dom_id: DEFAULT_RANDOM_DOM_ID
     )
   end
 
@@ -134,7 +47,7 @@ module ReactOnRails
                   :webpack_generated_files, :rendering_extension, :build_test_command,
                   :build_production_command,
                   :i18n_dir, :i18n_yml_dir,
-                  :server_render_method, :symlink_non_digested_assets_regex
+                  :server_render_method, :symlink_non_digested_assets_regex, :random_dom_id
 
     def initialize(node_modules_location: nil, server_bundle_js_file: nil, prerender: nil,
                    replay_console: nil,
@@ -145,7 +58,7 @@ module ReactOnRails
                    generated_assets_dir: nil, webpack_generated_files: nil,
                    rendering_extension: nil, build_test_command: nil,
                    build_production_command: nil,
-                   i18n_dir: nil, i18n_yml_dir: nil,
+                   i18n_dir: nil, i18n_yml_dir: nil, random_dom_id: nil,
                    server_render_method: nil, symlink_non_digested_assets_regex: nil)
       self.node_modules_location = node_modules_location.present? ? node_modules_location : Rails.root
       self.server_bundle_js_file = server_bundle_js_file
@@ -156,6 +69,7 @@ module ReactOnRails
       self.i18n_dir = i18n_dir
       self.i18n_yml_dir = i18n_yml_dir
 
+      self.random_dom_id = random_dom_id
       self.prerender = prerender
       self.replay_console = replay_console
       self.logging_on_server = logging_on_server
@@ -178,5 +92,133 @@ module ReactOnRails
       self.server_render_method = server_render_method
       self.symlink_non_digested_assets_regex = symlink_non_digested_assets_regex
     end
+
+    # on ReactOnRails
+    def setup_config_values
+      ensure_webpack_generated_files_exists
+      configure_generated_assets_dirs_deprecation
+      configure_skip_display_none_deprecation
+      ensure_generated_assets_dir_present
+      ensure_server_bundle_js_file_has_no_path
+      check_i18n_directory_exists
+      check_i18n_yml_directory_exists
+      check_server_render_method_is_only_execjs
+      error_if_using_webpacker_and_generated_assets_dir_not_match_public_output_path
+    end
+
+    private
+
+    def error_if_using_webpacker_and_generated_assets_dir_not_match_public_output_path
+      return unless ReactOnRails::WebpackerUtils.using_webpacker?
+
+      return if generated_assets_dir.blank?
+
+      webpacker_public_output_path = ReactOnRails::WebpackerUtils.webpacker_public_output_path
+
+      if File.expand_path(generated_assets_dir) == webpacker_public_output_path.to_s
+        Rails.logger.warn("You specified /config/initializers/react_on_rails.rb generated_assets_dir "\
+        "with Webpacker. Remove this line from your configuration file.")
+      else
+        msg = <<-MSG.strip_heredoc
+        Error configuring /config/initializers/react_on_rails.rb: You are using webpacker
+        and your specified value for generated_assets_dir = #{generated_assets_dir}
+        that does not match the value for public_output_path specified in
+        webpacker.yml = #{webpacker_public_output_path}. You should remove the configuration
+        value for "generated_assets_dir" from your config/initializers/react_on_rails.rb file.
+        MSG
+        raise ReactOnRails::Error, msg
+      end
+    end
+
+    def check_server_render_method_is_only_execjs
+      return if server_render_method.blank? ||
+                server_render_method == "ExecJS"
+
+      msg = <<-MSG.strip_heredoc
+      Error configuring /config/initializers/react_on_rails.rb: invalid value for `config.server_render_method`.
+      If you wish to use a server render method other than ExecJS, contact justin@shakacode.com
+      for details.
+      MSG
+      raise ReactOnRails::Error, msg
+    end
+
+    def check_i18n_directory_exists
+      return if i18n_dir.nil?
+      return if Dir.exist?(i18n_dir)
+
+      msg = <<-MSG.strip_heredoc
+      Error configuring /config/initializers/react_on_rails.rb: invalid value for `config.i18n_dir`.
+      Directory does not exist: #{i18n_dir}. Set to value to nil or comment it
+      out if not using the React on Rails i18n feature.
+      MSG
+      raise ReactOnRails::Error, msg
+    end
+
+    def check_i18n_yml_directory_exists
+      return if i18n_yml_dir.nil?
+      return if Dir.exist?(i18n_yml_dir)
+
+      msg = <<-MSG.strip_heredoc
+      Error configuring /config/initializers/react_on_rails.rb: invalid value for `config.i18n_yml_dir`.
+      Directory does not exist: #{i18n_yml_dir}. Set to value to nil or comment it
+      out if not using this i18n with React on Rails, or if you want to use all translation files.
+      MSG
+      raise ReactOnRails::Error, msg
+    end
+
+    def ensure_generated_assets_dir_present
+      return if generated_assets_dir.present? || ReactOnRails::WebpackerUtils.using_webpacker?
+
+      self.generated_assets_dir = DEFAULT_GENERATED_ASSETS_DIR
+      Rails.logger.warn "ReactOnRails: Set generated_assets_dir to default: #{DEFAULT_GENERATED_ASSETS_DIR}"
+    end
+
+    def configure_generated_assets_dirs_deprecation
+      return if generated_assets_dirs.blank?
+
+      if ReactOnRails::WebpackerUtils.using_webpacker?
+        webpacker_public_output_path = ReactOnRails::WebpackerUtils.webpacker_public_output_path
+        Rails.logger.warn "Error configuring config/initializers/react_on_rails. Define neither the "\
+        "generated_assets_dirs no the generated_assets_dir when using Webpacker. This is defined by "\
+        "public_output_path specified in webpacker.yml = #{webpacker_public_output_path}."
+        return
+      end
+
+      Rails.logger.warn "[DEPRECATION] ReactOnRails: Use config.generated_assets_dir rather than "\
+        "generated_assets_dirs"
+      if generated_assets_dir.blank?
+        self.generated_assets_dir = generated_assets_dirs
+      else
+        Rails.logger.warn "[DEPRECATION] ReactOnRails. You have both generated_assets_dirs and "\
+          "generated_assets_dir defined. Define ONLY generated_assets_dir if NOT using Webpacker"\
+          " and define neither if using Webpacker"
+      end
+    end
+
+    def ensure_webpack_generated_files_exists
+      return unless webpack_generated_files.empty?
+
+      files = ["hello-world-bundle.js"]
+      files << server_bundle_js_file if server_bundle_js_file.present?
+
+      self.webpack_generated_files = files
+    end
+
+    def ensure_server_bundle_js_file_has_no_path
+      return unless server_bundle_js_file.include?(File::SEPARATOR)
+
+      assets_dir = ReactOnRails::Utils.generated_assets_full_path
+      self.server_bundle_js_file = File.basename(server_bundle_js_file)
+
+      Rails.logger.warn do
+        "[DEPRECATION] ReactOnRails: remove path from server_bundle_js_file in configuration. "\
+      "All generated files must go in #{assets_dir}. Using file basename #{server_bundle_js_file}"
+      end
+    end
+
+    def configure_skip_display_none_deprecation
+      return if skip_display_none.nil?
+      Rails.logger.warn "[DEPRECATION] ReactOnRails: remove skip_display_none from configuration."
+    end
   end
 end

data/lib/react_on_rails/{react_on_rails_helper.rb → helper.rb}

@@ -98,17 +98,18 @@ module ReactOnRails
     #   raise_on_prerender_error: <true/false> Default to false. True will raise exception on server
     #      if the JS code throws
     # Any other options are passed to the content tag, including the id.
-    def react_component(component_name, raw_options = {})
-      internal_result = internal_react_component(component_name, raw_options)
-      server_rendered_html = internal_result["result"]["html"]
-      console_script = internal_result["result"]["consoleReplayScript"]
+    # random_dom_id can be set to override the global default.
+    def react_component(component_name, options = {})
+      internal_result = internal_react_component(component_name, options)
+      server_rendered_html = internal_result[:result]["html"]
+      console_script = internal_result[:result]["consoleReplayScript"]
 
       if server_rendered_html.is_a?(String)
         build_react_component_result_for_server_rendered_string(
           server_rendered_html: server_rendered_html,
-          component_specification_tag: internal_result["tag"],
+          component_specification_tag: internal_result[:tag],
           console_script: console_script,
-          options: internal_result["options"]
+          render_options: internal_result[:render_options]
         )
       elsif server_rendered_html.is_a?(Hash)
         msg = <<-MSG.strip_heredoc
@@ -116,43 +117,61 @@ module ReactOnRails
         https://github.com/shakacode/react_on_rails/blob/master/spec/dummy/client/app/startup/ReactHelmetServerApp.jsx
         for an example of the necessary javascript configuration."
         MSG
-        raise ReactOnRailsPro::Error, msg
+        raise ReactOnRails::Error, msg
 
       else
         msg = <<-MSG.strip_heredoc
-        ReactOnRails: server_rendered_html is expected to be a String. If you're trying to
-        use a generator function to return a Hash to your ruby view code, then use
+        ReactOnRails: server_rendered_html is expected to be a String for #{component_name}. If you're
+        trying to use a generator function to return a Hash to your ruby view code, then use
         react_component_hash instead of react_component and see
         https://github.com/shakacode/react_on_rails/blob/master/spec/dummy/client/app/startup/ReactHelmetServerApp.jsx
-        for an example of the necessary javascript configuration."
+        for an example of the JavaScript code."
         MSG
-        raise ReactOnRailsPro::Error, msg
+        raise ReactOnRails::Error, msg
       end
     end
 
-    def react_component_hash(component_name, raw_options = {})
-      internal_result = internal_react_component(component_name, raw_options)
-      server_rendered_html = internal_result["result"]["html"]
-      console_script = internal_result["result"]["consoleReplayScript"]
-
-      if server_rendered_html.is_a?(String) && internal_result["result"]["hasErrors"]
-        server_rendered_html = { COMPONENT_HTML_KEY => internal_result["result"]["html"] }
+    # 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:
+    # 1. prerender: true is automatically added, as this method doesn't make sense for client only
+    #    rendering.
+    # 2. Your JavaScript for server rendering must return an Object for the key server_rendered_html.
+    # 3. Your view code must expect an object and not a string.
+    #
+    # Here is an example of the view code:
+    #    <% react_helmet_app = react_component_hash("ReactHelmetApp", prerender: true,
+    #                                               props: { helloWorldData: { name: "Mr. Server Side Rendering"}},
+    #                                               id: "react-helmet-0", trace: true) %>
+    #    <% content_for :title do %>
+    #      <%= react_helmet_app['title'] %>
+    #    <% end %>
+    #    <%= react_helmet_app["componentHtml"] %>
+    #
+    def react_component_hash(component_name, options = {})
+      options[:prerender] = true
+      internal_result = internal_react_component(component_name, options)
+      server_rendered_html = internal_result[:result]["html"]
+      console_script = internal_result[:result]["consoleReplayScript"]
+
+      if server_rendered_html.is_a?(String) && internal_result[:result]["hasErrors"]
+        server_rendered_html = { COMPONENT_HTML_KEY => internal_result[:result]["html"] }
       end
 
       if server_rendered_html.is_a?(Hash)
         build_react_component_result_for_server_rendered_hash(
           server_rendered_html: server_rendered_html,
-          component_specification_tag: internal_result["tag"],
+          component_specification_tag: internal_result[:tag],
           console_script: console_script,
-          options: internal_result["options"]
+          render_options: internal_result[:render_options]
         )
       else
         msg = <<-MSG.strip_heredoc
-        Generator function used by react_component_hash is expected to return an Object. See
-        https://github.com/shakacode/react_on_rails/blob/master/spec/dummy/client/app/startup/ReactHelmetServerApp.jsx
-        for an example of the necessary javascript configuration.
+          Generator function used by react_component_hash for #{component_name} is expected to return
+          an Object. See https://github.com/shakacode/react_on_rails/blob/master/spec/dummy/client/app/startup/ReactHelmetServerApp.jsx
+          for an example of the JavaScript code."
         MSG
-        raise ReactOnRailsPro::Error, msg
+        raise ReactOnRails::Error, msg
       end
     end
 
@@ -199,8 +218,12 @@ module ReactOnRails
     # Helper method to take javascript expression and returns the output from evaluating it.
     # If you have more than one line that needs to be executed, wrap it in an IIFE.
     # JS exceptions are caught and console messages are handled properly.
+    # Options include:{ prerender:, trace:, raise_on_prerender_error: }
     def server_render_js(js_expression, options = {})
-      wrapper_js = <<-JS.strip_heredoc
+      render_options = ReactOnRails::ReactComponent::RenderOptions
+                       .new(react_component_name: "generic-js", options: options)
+
+      js_code = <<-JS.strip_heredoc
       (function() {
         var htmlResult = '';
         var consoleReplayScript = '';
@@ -228,20 +251,21 @@ module ReactOnRails
       })()
       JS
 
-      result = ReactOnRails::ServerRenderingPool.server_render_js_with_console_logging(wrapper_js)
+      result = ReactOnRails::ServerRenderingPool
+               .server_render_js_with_console_logging(js_code, render_options)
 
       html = result["html"]
       console_log_script = result["consoleLogScript"]
-      raw("#{html}#{replay_console_option(options[:replay_console_option]) ? console_log_script : ''}")
+      raw("#{html}#{render_options.replay_console ? console_log_script : ''}")
     rescue ExecJS::ProgramError => err
       raise ReactOnRails::PrerenderError, component_name: "N/A (server_render_js called)",
                                           err: err,
-                                          js_code: wrapper_js
+                                          js_code: js_code
     end
 
     def json_safe_and_pretty(hash_or_string)
       return "{}" if hash_or_string.nil?
-      unless hash_or_string.class.in?([Hash, String])
+      unless hash_or_string.is_a?(String) || hash_or_string.is_a?(Hash)
         raise ReactOnRails::Error, "#{__method__} only accepts String or Hash as argument "\
             "(#{hash_or_string.class} given)."
       end
@@ -257,16 +281,16 @@ module ReactOnRails
       server_rendered_html: required("server_rendered_html"),
       component_specification_tag: required("component_specification_tag"),
       console_script: required("console_script"),
-      options: required("options")
+      render_options: required("render_options")
     )
-      content_tag_options = options.html_options
-      content_tag_options[:id] = options.dom_id
+      content_tag_options = render_options.html_options
+      content_tag_options[:id] = render_options.dom_id
 
       rendered_output = content_tag(:div,
                                     server_rendered_html.html_safe,
                                     content_tag_options)
 
-      result_console_script = options.replay_console ? console_script : ""
+      result_console_script = render_options.replay_console ? console_script : ""
       result = compose_react_component_html_with_spec_and_console(
         component_specification_tag, rendered_output, result_console_script
       )
@@ -278,20 +302,20 @@ module ReactOnRails
       server_rendered_html: required("server_rendered_html"),
       component_specification_tag: required("component_specification_tag"),
       console_script: required("console_script"),
-      options: required("options")
+      render_options: required("render_options")
     )
-      content_tag_options = options.html_options
-      content_tag_options[:id] = options.dom_id
+      content_tag_options = render_options.html_options
+      content_tag_options[:id] = render_options.dom_id
 
       unless server_rendered_html[COMPONENT_HTML_KEY]
-        raise ReactOnRailsPro::Error, "server_rendered_html hash expected to contain \"#{COMPONENT_HTML_KEY}\" key."
+        raise ReactOnRails::Error, "server_rendered_html hash expected to contain \"#{COMPONENT_HTML_KEY}\" key."
       end
 
       rendered_output = content_tag(:div,
                                     server_rendered_html[COMPONENT_HTML_KEY].html_safe,
                                     content_tag_options)
 
-      result_console_script = options.replay_console ? console_script : ""
+      result_console_script = render_options.replay_console ? console_script : ""
       result = compose_react_component_html_with_spec_and_console(
         component_specification_tag, rendered_output, result_console_script
       )
@@ -335,7 +359,7 @@ module ReactOnRails
       "#{rails_context_content}\n#{render_value}".html_safe
     end
 
-    def internal_react_component(component_name, raw_options = {})
+    def internal_react_component(react_component_name, options = {})
       # Create the JavaScript and HTML to allow either client or server rendering of the
       # react_component.
       #
@@ -343,27 +367,27 @@ module ReactOnRails
       # (re-hydrate the data). This enables react rendered on the client to see that the
       # server has already rendered the HTML.
 
-      options = ReactOnRails::ReactComponent::Options.new(name: component_name, options: raw_options)
+      render_options = ReactOnRails::ReactComponent::RenderOptions.new(react_component_name: react_component_name,
+                                                                       options: options)
 
       # Setup the page_loaded_js, which is the same regardless of prerendering or not!
       # The reason is that React is smart about not doing extra work if the server rendering did its job.
       component_specification_tag = content_tag(:script,
-                                                json_safe_and_pretty(options.props).html_safe,
+                                                json_safe_and_pretty(render_options.props).html_safe,
                                                 type: "application/json",
                                                 class: "js-react-on-rails-component",
-                                                "data-component-name" => options.name,
-                                                "data-trace" => (options.trace ? true : nil),
-                                                "data-dom-id" => options.dom_id)
+                                                "data-component-name" => render_options.react_component_name,
+                                                "data-trace" => (render_options.trace ? true : nil),
+                                                "data-dom-id" => render_options.dom_id)
 
       # Create the HTML rendering part
-      result = server_rendered_react_component_html(options.props,
-                                                    options.name,
-                                                    options.dom_id,
-                                                    prerender: options.prerender,
-                                                    trace: options.trace,
-                                                    raise_on_prerender_error: options.raise_on_prerender_error)
-
-      { "options" => options, "tag" => component_specification_tag, "result" => result }
+      result = server_rendered_react_component(render_options)
+
+      {
+        render_options: render_options,
+        tag: component_specification_tag,
+        result: result
+      }
     end
 
     def render_redux_store_data(redux_store_data)
@@ -379,15 +403,12 @@ module ReactOnRails
       props.is_a?(String) ? props : props.to_json
     end
 
-    # Returns Array [0]: html, [1]: script to console log
-    # NOTE, these are NOT html_safe!
-    def server_rendered_react_component_html(
-      props, react_component_name, dom_id,
-      prerender: required("prerender"),
-      trace: required("trace"),
-      raise_on_prerender_error: required("raise_on_prerender_error")
-    )
-      return { "html" => "", "consoleReplayScript" => "" } unless prerender
+    # Returns object with values that are NOT html_safe!
+    def server_rendered_react_component(render_options)
+      return { "html" => "", "consoleReplayScript" => "" } unless render_options.prerender
+
+      react_component_name = render_options.react_component_name
+      props = render_options.props
 
       # On server `location` option is added (`location = request.fullpath`)
       # React Router needs this to match the current route
@@ -411,53 +432,55 @@ module ReactOnRails
       # Read more here: http://timelessrepo.com/json-isnt-a-javascript-subset
 
       # rubocop:disable Layout/IndentHeredoc
-      wrapper_js = <<-JS
+      js_code = <<-JS
 (function() {
   var railsContext = #{rails_context(server_side: true).to_json};
 #{initialize_redux_stores}
   var props = #{props_string(props).gsub("\u2028", '\u2028').gsub("\u2029", '\u2029')};
   return ReactOnRails.serverRenderReactComponent({
     name: '#{react_component_name}',
-    domNodeId: '#{dom_id}',
+    domNodeId: '#{render_options.dom_id}',
     props: props,
-    trace: #{trace},
+    trace: #{render_options.trace},
     railsContext: railsContext
   });
 })()
       JS
       # rubocop:enable Layout/IndentHeredoc
 
-      result = ReactOnRails::ServerRenderingPool.server_render_js_with_console_logging(wrapper_js)
+      begin
+        result = ReactOnRails::ServerRenderingPool.server_render_js_with_console_logging(js_code, render_options)
+      rescue StandardError => err
+        # This error came from the renderer
+        raise ReactOnRails::PrerenderError, component_name: react_component_name,
+                                            # Sanitize as this might be browser logged
+                                            props: sanitized_props_string(props),
+                                            err: err,
+                                            js_code: js_code
+      end
 
-      if result["hasErrors"] && raise_on_prerender_error
+      if result["hasErrors"] && render_options.raise_on_prerender_error
         # We caught this exception on our backtrace handler
         raise ReactOnRails::PrerenderError, component_name: react_component_name,
                                             # Sanitize as this might be browser logged
                                             props: sanitized_props_string(props),
                                             err: nil,
-                                            js_code: wrapper_js,
+                                            js_code: js_code,
                                             console_messages: result["consoleReplayScript"]
 
       end
       result
-    rescue ExecJS::ProgramError => err
-      # This error came from execJs
-      raise ReactOnRails::PrerenderError, component_name: react_component_name,
-                                          # Sanitize as this might be browser logged
-                                          props: sanitized_props_string(props),
-                                          err: err,
-                                          js_code: wrapper_js
     end
 
     def initialize_redux_stores
-      return "" unless @registered_stores.present? || @registered_stores_defer_render.present?
-      declarations = "var reduxProps, store, storeGenerator;\n".dup
-      all_stores = (@registered_stores || []) + (@registered_stores_defer_render || [])
-
       result = <<-JS.dup
       ReactOnRails.clearHydratedStores();
       JS
 
+      return result unless @registered_stores.present? || @registered_stores_defer_render.present?
+      declarations = "var reduxProps, store, storeGenerator;\n".dup
+      all_stores = (@registered_stores || []) + (@registered_stores_defer_render || [])
+
       result << all_stores.each_with_object(declarations) do |redux_store_data, memo|
         store_name = redux_store_data[:store_name]
         props = props_string(redux_store_data[:props])
@@ -481,7 +504,9 @@ module ReactOnRails
           inMailer: in_mailer?,
           # Locale settings
           i18nLocale: I18n.locale,
-          i18nDefaultLocale: I18n.default_locale
+          i18nDefaultLocale: I18n.default_locale,
+          rorVersion: ReactOnRails::VERSION,
+          rorPro: ReactOnRails::Utils.react_on_rails_pro?
         }
         if defined?(request) && request.present?
           # Check for encoding of the request's original_url and try to force-encoding the

data/lib/react_on_rails/json_parse_error.rb

@@ -0,0 +1,26 @@
+module ReactOnRails
+  class JsonParseError < ::ReactOnRails::Error
+    attr_reader :json
+
+    def initialize(parse_error, json)
+      @json = json
+      @original_error = parse_error
+      super(parse_error.message)
+    end
+
+    def to_honeybadger_context
+      to_error_context
+    end
+
+    def raven_context
+      to_error_context
+    end
+
+    def to_error_context
+      {
+        original_error: @original_error,
+        json: @json
+      }
+    end
+  end
+end