react_on_rails 17.1.0 → 17.2.0.rc.1

data/lib/generators/react_on_rails/pro_setup.rb

@@ -2,6 +2,7 @@
 
 require "securerandom"
 require_relative "generator_messages"
+require_relative "generated_webpack_config_pair"
 require "react_on_rails/node_renderer_procfile"
 require "react_on_rails/pro_migration"
 
@@ -36,9 +37,8 @@ module ReactOnRails
       # Loader helpers emitted by
       # templates/base/base/config/webpack/serverWebpackConfig.js.tt.
       #
-      # Keep both blocks byte-identical to that template: a fresh `--pro` install renders
-      # the template while a standalone Pro upgrade patches an existing base config, and
-      # the two must produce the same source text so drift is detectable (issue #4786).
+      # Keep these parity-test anchors byte-identical to the template (issue #4786).
+      # Migration recognition uses the entire rendered pair, never these snippets.
       GET_LOADER_PATH_JS = <<~JS
         // Normalizes an entry of a webpack/rspack `rule.use` array to its loader path.
         // Entries may be a bare string, a `{ loader, options }` object, or null.
@@ -56,15 +56,6 @@ module ReactOnRails
         }
       JS
 
-      BUNDLER_REQUIRE_PATTERN =
-        %r{(const bundler = config\.assets_bundler.*\n.*require\('@rspack/core'\).*\n.*: require\('webpack'\);)}
-
-      # Matches any declaration of the getLoaderPath symbol, however it is written. The
-      # emitted extractLoader calls getLoaderPath, so we must never add a second
-      # declaration: `function` next to an existing `const` is a SyntaxError, not a
-      # silent shadow, and the generated config would fail to parse in Node.
-      GET_LOADER_PATH_DECLARATION = /(?:function\s+getLoaderPath\s*\(|(?:const|let|var)\s+getLoaderPath\s*=)/
-
       # Main entry point for Pro setup.
       # Orchestrates creation of all Pro-related files and configuration.
       #
@@ -157,8 +148,8 @@ module ReactOnRails
 
           Then run: bundle install
 
-          No license needed for evaluation or non-production use.
-          Free or low-cost production licenses available for startups and small companies.
+          No license key is needed to run Pro. Production is free for small organizations, charities, schools, and hospitals;
+          larger organizations subscribe: https://reactonrails.com/pricing/
           See the upgrade guide: https://reactonrails.com/docs/pro/upgrading-to-pro/
         MSG
         true
@@ -439,228 +430,65 @@ module ReactOnRails
         say "✅ Added Node Renderer to #{procfile}", :green
       end
 
-      # Update webpack configs to enable Pro settings.
-      # This is needed for standalone Pro upgrades where the base install
-      # created webpack configs without Pro settings enabled.
-      #
-      # Updates serverWebpackConfig.js:
-      # - Adds extractLoader helper function (required by rscWebpackConfig.js)
-      # - Adds Babel SSR caller setup (required for correct SSR compilation)
-      # - Enables libraryTarget: 'commonjs2' (required for Node Renderer)
-      # - Enables serverWebpackConfig.target = 'node' (required for Node.js modules)
-      # - Disables Node.js polyfills via node = false (required for real __dirname)
-      # - Changes module.exports to Pro style (required by rscWebpackConfig.js)
-      #
-      # Updates ServerClientOrBoth.js:
-      # - Changes import to destructured style (required for Pro object export)
+      # Only replace complete, unchanged generated pairs. Inspecting declarations or
+      # individual markers cannot establish that customized JavaScript is safe to rewrite.
       def update_webpack_config_for_pro
-        webpack_config, webpack_config_path = webpack_config_paths
-
-        unless File.exist?(webpack_config_path)
-          say "ℹ️  serverWebpackConfig.js not found, skipping webpack update", :yellow
+        paths = generated_webpack_pair_paths
+        contents = read_generated_webpack_pair(paths) if paths
+        replacement = GeneratedWebpackConfigPair.pro_upgrade(contents) if contents
+        unless replacement
+          warn_unknown_webpack_pair
           return
         end
 
-        content = File.read(webpack_config_path)
-        server_config_ready = pro_server_config_ready?(content)
-        import_ready = server_client_import_ready?
-
-        # Skip only when both server config and import style are already updated.
-        if server_config_ready && import_ready
+        if replacement == contents
           say "ℹ️  Webpack config already has Pro settings enabled, skipping", :yellow
           return
         end
 
-        say "📝 Updating serverWebpackConfig.js for Pro...", :yellow
-
-        unless server_config_ready
-          # Add extractLoader helper function after bundler require
-          add_extract_loader_to_server_config(webpack_config, content)
-
-          # Add Babel SSR caller setup (uses extractLoader, so must come after)
-          add_babel_ssr_caller_to_server_config(webpack_config, content)
-
-          # Uncomment libraryTarget: 'commonjs2'
-          library_target_pattern = %r{// If using the React on Rails Pro.*\n\s*// libraryTarget: 'commonjs2',}
-          library_target_replacement = "// Required for React on Rails Pro Node Renderer\n    " \
-                                       "libraryTarget: 'commonjs2',"
-          gsub_file(webpack_config, library_target_pattern, library_target_replacement)
-
-          # Replace stale comments and uncomment target = 'node', add node = false
-          # The base template has 4 lines: 2 explanatory comments + "uncomment" hint + commented code
-          # Replace with clean Pro output matching the template's use_pro? branch
-          # rubocop:disable Layout/LineLength
-          target_node_pattern = %r{\s*// If using the default 'web',.*\n\s*// break with SSR\..*\n\s*// If using the React on Rails Pro.*\n\s*// serverWebpackConfig\.target = 'node'}
-          # rubocop:enable Layout/LineLength
-          target_node_replacement = "\n\n  " \
-                                    "// React on Rails Pro uses Node renderer, so target must be 'node'\n  " \
-                                    "// This fixes issues with libraries like Emotion and loadable-components\n  " \
-                                    "serverWebpackConfig.target = 'node';\n\n  " \
-                                    "// Disable Node.js polyfills - not needed when targeting Node\n  " \
-                                    "serverWebpackConfig.node = false;"
-          gsub_file(webpack_config, target_node_pattern, target_node_replacement)
-
-          # Change module.exports to Pro style (exports object with default and extractLoader)
-          update_server_config_exports(webpack_config)
+        paths.zip(replacement).each do |path, content|
+          create_file(path, content, force: true)
         end
-
-        # Update ServerClientOrBoth.js import style
-        update_server_client_or_both_import
-
-        verify_pro_webpack_transforms(webpack_config)
         say "✅ Updated webpack configs for Pro", :green
       end
 
-      def webpack_config_paths
-        config = destination_config_path("config/webpack/serverWebpackConfig.js")
-        [config, File.join(destination_root, config)]
-      end
-
-      def add_extract_loader_to_server_config(webpack_config, content)
-        # Skip if extractLoader already exists
-        return if content.include?("function extractLoader")
-
-        if content.include?(GET_LOADER_PATH_JS)
-          # Config rendered by the current base template: append extractLoader directly after
-          # the shared getLoaderPath helper so the result matches the template's Pro output.
-          gsub_file(webpack_config, GET_LOADER_PATH_JS, "#{GET_LOADER_PATH_JS}\n#{EXTRACT_LOADER_JS}")
-        elsif content.match?(GET_LOADER_PATH_DECLARATION)
-          # The app already declares getLoaderPath but has customized it (reformatted, recommented,
-          # or rewritten as an arrow function). Reuse whatever is there and emit extractLoader only.
-          # Emitting our own copy would redeclare the identifier, which is a SyntaxError next to an
-          # existing const/let and silent shadowing next to another function declaration.
-          gsub_file(webpack_config, BUNDLER_REQUIRE_PATTERN, "\\1\n\n#{EXTRACT_LOADER_JS}".chomp)
-        else
-          # Base config generated before getLoaderPath existed: emit both helpers after the
-          # bundler require so extractLoader's dependency is present.
-          gsub_file(
-            webpack_config,
-            BUNDLER_REQUIRE_PATTERN,
-            "\\1\n\n#{GET_LOADER_PATH_JS}\n#{EXTRACT_LOADER_JS}".chomp
-          )
+      # Unlike resolve_server_client_or_both_path, discovery must not rename files
+      # or edit environment imports before the entire pair has been recognized.
+      def generated_webpack_pair_paths
+        server = destination_config_path("config/webpack/serverWebpackConfig.js")
+        companions = %w[ServerClientOrBoth.js generateWebpackConfigs.js].map do |name|
+          destination_config_path("config/webpack/#{name}")
         end
-      end
+        existing = companions.select do |path|
+          absolute = File.join(destination_root, path)
+          File.exist?(absolute) || File.symlink?(absolute)
+        end
+        return unless existing.one?
 
-      def add_babel_ssr_caller_to_server_config(webpack_config, content)
-        return if content.include?("babelLoader.options.caller")
-
-        babel_ssr_code = "\n\n      " \
-                         "// Set SSR caller for Babel (if using Babel instead of SWC)\n      " \
-                         "const babelLoader = extractLoader(rule, 'babel-loader');\n      " \
-                         "if (babelLoader && babelLoader.options) {\n        " \
-                         "babelLoader.options.caller = { ssr: true };\n      " \
-                         "}"
-
-        # Insert after cssLoader.options.modules; [\s\S]*? covers both single-line and spread syntax patterns.
-        gsub_file(
-          webpack_config,
-          /(cssLoader\.options\.modules = \{[\s\S]*?exportOnlyLocals: true[\s\S]*?\};\s*\n\s*\})/,
-          "\\1#{babel_ssr_code}"
-        )
-        new_content = File.read(File.join(destination_root, webpack_config))
-        return if new_content.include?("babelLoader.options.caller")
+        paths = [server, existing.first]
+        return unless paths.all? do |path|
+          absolute = File.join(destination_root, path)
+          File.file?(absolute) && !File.symlink?(absolute)
+        end
 
-        say_status :warning, "Babel SSR caller insertion failed in #{webpack_config}; manual edit required.", :yellow
+        paths
       end
 
-      def update_server_config_exports(webpack_config)
-        # Change from: module.exports = configureServer;
-        # To: module.exports = { default: configureServer, extractLoader };
-        gsub_file(
-          webpack_config,
-          /^module\.exports = configureServer;\s*$/,
-          "module.exports = {\n  default: configureServer,\n  extractLoader,\n};\n"
-        )
+      def read_generated_webpack_pair(paths)
+        paths.map { |path| File.binread(File.join(destination_root, path)) }
+      rescue SystemCallError, IOError
+        nil
       end
 
-      def verify_pro_webpack_transforms(webpack_config)
-        content = File.read(File.join(destination_root, webpack_config))
-        missing = missing_server_config_transforms(content)
-        missing.concat(missing_server_client_import_transform)
-        return if missing.empty?
-
+      def warn_unknown_webpack_pair
         GeneratorMessages.add_warning(<<~MSG.strip)
-          ⚠️  Some Pro webpack transforms may not have applied correctly.
-
-          The following expected patterns were not found in #{webpack_config}:
-          #{missing.map { |m| "  - #{m}" }.join("\n")}
-
-          This can happen if your webpack config has been customized.
-          Please verify #{webpack_config} manually.
+          Skipped Pro webpack updates: the config pair is missing, ambiguous, customized,
+          or does not match a supported current generated pair.
+          Both webpack configs and their paths were left unchanged. Update them manually using the Pro setup guide:
+          https://reactonrails.com/docs/pro/upgrading-to-pro/
         MSG
       end
 
-      def missing_server_config_transforms(content)
-        checks = [
-          "libraryTarget: 'commonjs2',",
-          "function extractLoader",
-          "babelLoader.options.caller = { ssr: true }",
-          "serverWebpackConfig.target = 'node'",
-          "serverWebpackConfig.node = false",
-          "default: configureServer",
-          "extractLoader,"
-        ]
-
-        checks.reject { |pattern| content.include?(pattern) }
-      end
-
-      def missing_server_client_import_transform
-        server_client_path = resolve_server_client_or_both_path
-        return [] unless server_client_path
-
-        content = File.read(File.join(destination_root, server_client_path))
-        return [] if content.include?("{ default: serverWebpackConfig }")
-
-        ["{ default: serverWebpackConfig }"]
-      end
-
-      def update_server_client_or_both_import
-        server_client_path = resolve_server_client_or_both_path
-        return unless server_client_path
-
-        content = File.read(File.join(destination_root, server_client_path))
-
-        # Skip if already using destructured import
-        return if content.include?("{ default: serverWebpackConfig }")
-
-        # Change from: const serverWebpackConfig = require('./serverWebpackConfig');
-        # To: const { default: serverWebpackConfig } = require('./serverWebpackConfig');
-        gsub_file(
-          server_client_path,
-          %r{^const serverWebpackConfig = require\('\./serverWebpackConfig'\);$},
-          "const { default: serverWebpackConfig } = require('./serverWebpackConfig');"
-        )
-
-        new_content = File.read(File.join(destination_root, server_client_path))
-        return if new_content.include?("{ default: serverWebpackConfig }")
-
-        say_status(
-          :warning,
-          "ServerClientOrBoth import update failed in #{server_client_path}; manual edit required.",
-          :yellow
-        )
-      end
-
-      def pro_server_config_ready?(content)
-        # Check for the Pro-specific comment marker (written by the transform) to avoid
-        # false-negatives when commented-out lines also contain the pattern string.
-        content.include?("// Required for React on Rails Pro Node Renderer") &&
-          content.include?("function extractLoader") &&
-          content.include?("babelLoader.options.caller = { ssr: true }") &&
-          content.include?("serverWebpackConfig.target = 'node'") &&
-          content.include?("serverWebpackConfig.node = false") &&
-          content.include?("default: configureServer") &&
-          content.include?("extractLoader,")
-      end
-
-      def server_client_import_ready?
-        server_client_path = resolve_server_client_or_both_path
-        return true unless server_client_path
-
-        content = File.read(File.join(destination_root, server_client_path))
-        content.include?("{ default: serverWebpackConfig }")
-      end
-
       def pro_gem_auto_install_command
         "bundle add #{PRO_GEM_NAME} --version='#{pro_gem_version_requirement}' --strict"
       end

data/lib/generators/react_on_rails/rsc_setup/client_references.rb

@@ -43,8 +43,10 @@ module ReactOnRails
             // (which re-runs the hook). Running bin/shakapacker directly after changing server
             // components is covered by the best-effort staleness warning below.
             //
-            // The resolution cascade below is mirrored, branch for branch, by the Pro dummy's
-            // hand-written rscManifestClientReferences.js and pinned on both sides by contract tests.
+            // The resolution cascade below — including the react-on-rails-pro client-component
+            // registrations appended to every branch's result (issue #5079) — is mirrored, branch
+            // for branch, by the Pro dummy's hand-written rscManifestClientReferences.js and pinned
+            // on both sides by contract tests.
             const rscClientReferences = (() => {
               // Required inside the IIFE rather than at the top of the file because the module-scope
               // bindings 'resolve' (from 'path') and 'config' (from 'shakapacker') are already
@@ -168,40 +170,73 @@ module ReactOnRails
                 );
               };
 
-              if (configuredRefsJson) {
-                const resolvedRefsJson = resolve(configuredRefsJson);
-                if (!existsSync(resolvedRefsJson)) {
-                  throw new Error(
-                    `RSC_MANIFEST_CLIENT_REFERENCES_JSON is set but the file does not exist: ${resolvedRefsJson}`,
-                  );
+              const resolveDiscoveredClientReferences = () => {
+                if (configuredRefsJson) {
+                  const resolvedRefsJson = resolve(configuredRefsJson);
+                  if (!existsSync(resolvedRefsJson)) {
+                    throw new Error(
+                      `RSC_MANIFEST_CLIENT_REFERENCES_JSON is set but the file does not exist: ${resolvedRefsJson}`,
+                    );
+                  }
+                  warnIfManifestStale(resolvedRefsJson);
+                  return readManifestReferences(resolvedRefsJson);
                 }
-                warnIfManifestStale(resolvedRefsJson);
-                return readManifestReferences(resolvedRefsJson);
-              }
 
-              if (process.env.RSC_REFERENCE_DISCOVERY_BUILD === 'true' || process.env.RSC_BUNDLE_ONLY === 'true') {
-                return [fallbackRscClientReferences];
-              }
-
-              if (existsSync(defaultRefsJson)) {
-                warnIfManifestStale(defaultRefsJson);
-                return readManifestReferences(defaultRefsJson);
-              }
-
-              if (existsSync(serverComponentRegistrationEntry)) {
-                if (!rscConfigSupportsDiscovery()) {
-                  console.warn(
-                    `[react_on_rails] Missing ${defaultRefsJson}, but this app's RSC webpack config ` +
-                      'or precompile hook does not support manifest discovery yet; falling back to broad client ' +
-                      'reference scan. Re-run rails g react_on_rails:rsc to update generated configs.',
-                  );
+                if (process.env.RSC_REFERENCE_DISCOVERY_BUILD === 'true' || process.env.RSC_BUNDLE_ONLY === 'true') {
                   return [fallbackRscClientReferences];
                 }
 
-                throw new Error(`Missing ${defaultRefsJson}. Run bin/shakapacker-precompile-hook before bin/shakapacker.`);
-              }
+                if (existsSync(defaultRefsJson)) {
+                  warnIfManifestStale(defaultRefsJson);
+                  return readManifestReferences(defaultRefsJson);
+                }
+
+                if (existsSync(serverComponentRegistrationEntry)) {
+                  if (!rscConfigSupportsDiscovery()) {
+                    console.warn(
+                      `[react_on_rails] Missing ${defaultRefsJson}, but this app's RSC webpack config ` +
+                        'or precompile hook does not support manifest discovery yet; falling back to broad client ' +
+                        'reference scan. Re-run rails g react_on_rails:rsc to update generated configs.',
+                    );
+                    return [fallbackRscClientReferences];
+                  }
+
+                  throw new Error(`Missing ${defaultRefsJson}. Run bin/shakapacker-precompile-hook before bin/shakapacker.`);
+                }
+
+                return [fallbackRscClientReferences];
+              };
 
-              return [fallbackRscClientReferences];
+              // react-on-rails-pro ships its own 'use client' components (RSCRoute, RSCProvider, and
+              // the default RSC provider registration). Both the discovery build and the fallback
+              // directory scan only cover app source — node_modules is never scanned — so these can
+              // never be discovered and, without explicit registration, never reach
+              // react-client-manifest.json. Server components rendering them (e.g. a nested
+              // <RSCRoute> for section-level refetching) then fail the render-time manifest lookup
+              // even when the RSC bundle compiles (issue #5079). require.resolve returns the
+              // absolute realpath, which matches the module resource webpack records
+              // (resolve.symlinks defaults to true), so the manifest keys line up with the file URLs
+              // the RSC bundle's client references carry even when react-on-rails-pro is installed
+              // through a symlink (pnpm, workspaces). A function (invoked in the return below, after
+              // the discovered references resolve) so both this resolver and its Pro dummy mirror
+              // surface the same first error when both steps fail.
+              const reactOnRailsProClientReferences = () =>
+                [
+                  'react-on-rails-pro/RSCRoute',
+                  'react-on-rails-pro/RSCProvider',
+                  'react-on-rails-pro/registerDefaultRSCProvider/client',
+                ].map((subpath) => {
+                  try {
+                    return require.resolve(subpath);
+                  } catch (err) {
+                    throw new Error(
+                      `Failed to resolve the react-on-rails-pro client component "${subpath}" for RSC ` +
+                        `client-reference registration: ${err.message}`,
+                    );
+                  }
+                });
+
+              return [...new Set([...resolveDiscoveredClientReferences(), ...reactOnRailsProClientReferences()])];
             })();
           JS
         end
@@ -277,6 +312,10 @@ module ReactOnRails
 
             content = read_current_rsc_config(config_path, fallback: content)
           end
+          # A previously generated IIFE (no react-on-rails-pro registrations — issue #5079) also
+          # counts as generated below; warn so the user registers the components manually.
+          warn_outdated_rsc_client_references_helper(config_path) if
+            outdated_generated_rsc_client_references_defined?(content)
           return :scoped if generated_rsc_client_references_defined?(content)
 
           warn_unscoped_rsc_client_references_helper(config_path)
@@ -312,6 +351,12 @@ module ReactOnRails
             content = normalized_content
           end
 
+          # A resolver emitted by a previous generator version (no react-on-rails-pro
+          # client-component registrations — issue #5079) is deliberately not rewritten; warn
+          # before the scoped-references short-circuit below treats it as already current.
+          warn_outdated_rsc_client_references_helper(config_path) if
+            outdated_generated_rsc_client_references_defined?(content)
+
           return unless rsc_plugin_sections_safe_to_rewrite?(config_path, content, is_server:)
 
           return if rsc_plugin_uses_scoped_client_references?(content, is_server:)
@@ -1405,6 +1450,31 @@ module ReactOnRails
           write_existing_rsc_config(config_path, updated_content, action: :rewrite)
         end
 
+        # True when the file carries a manifest-backed generated resolver IIFE that does not
+        # register the react-on-rails-pro client components (issue #5079) — either the resolver a
+        # previous generator version emitted, or a user customization of one. The generator never
+        # rewrites such a resolver; it warns with manual registration instructions instead.
+        def outdated_generated_rsc_client_references_defined?(content)
+          return false unless generated_rsc_client_references_defined?(content)
+
+          iife_body = generated_rsc_client_references_iife_body(content)
+          return false unless iife_body
+
+          !js_code_matches?(iife_body, /\breactOnRailsProClientReferences\b/)
+        end
+
+        def warn_outdated_rsc_client_references_helper(config_path)
+          GeneratorMessages.add_warning(
+            "#{config_path} contains a rscClientReferences resolver from a previous generator " \
+            "version: it does not register the react-on-rails-pro package's own client components " \
+            "(RSCRoute, RSCProvider, registerDefaultRSCProvider/client — issue #5079). The file was " \
+            "left unchanged. Add require.resolve entries for those components to your " \
+            "clientReferences (see the RSC setup docs at " \
+            "https://reactonrails.com/docs/pro/react-server-components/create-without-ssr), or " \
+            "remove the generated resolver block and re-run this generator to emit the current one."
+          )
+        end
+
         def read_current_rsc_config(config_path, fallback:)
           return fallback if options[:pretend] || options[:skip]
 

data/lib/generators/react_on_rails/rsc_setup.rb

@@ -82,17 +82,9 @@ module ReactOnRails
         react_version = detect_react_version
         return if react_version.nil? # React not installed yet, will be installed by generator
 
-        version = Gem::Version.new(react_version)
-        major, minor, patch = version.segments
+        major, minor, patch = react_version.split(".").map(&:to_i)
 
-        if version.prerelease?
-          GeneratorMessages.add_warning(<<~MSG.strip)
-            ⚠️  RSC requires stable React (detected: #{react_version}).
-
-            React prereleases are not supported. Install matching stable React/React DOM versions:
-              #{manual_add_packages_command(["react@#{RSC_REACT_VERSION_RANGE}", "react-dom@#{RSC_REACT_VERSION_RANGE}"])}
-          MSG
-        elsif major != RSC_SUPPORTED_REACT_MAJOR || minor != RSC_SUPPORTED_REACT_MINOR
+        if major != RSC_SUPPORTED_REACT_MAJOR || minor != RSC_SUPPORTED_REACT_MINOR
           GeneratorMessages.add_warning(<<~MSG.strip)
             ⚠️  RSC requires React #{RSC_SUPPORTED_REACT_LINE} (detected: #{react_version})
 
@@ -105,14 +97,13 @@ module ReactOnRails
           MSG
         elsif patch < RSC_MINIMUM_REACT_PATCH
           GeneratorMessages.add_warning(<<~MSG.strip)
-            ⚠️  React #{react_version} is below the required minimum for RSC.
+            ⚠️  React #{react_version} is below the recommended minimum for RSC.
 
-            react-on-rails-rsc #{JsDependencyManager::RSC_PACKAGE_VERSION_PIN} requires
-            matching stable React/React DOM #{RSC_MINIMUM_REACT_VERSION}+ on #{RSC_SUPPORTED_REACT_LINE}.
-            The Node Renderer refuses startup until React and React DOM are upgraded together:
-              #{manual_add_packages_command(["react@#{RSC_REACT_VERSION_RANGE}", "react-dom@#{RSC_REACT_VERSION_RANGE}"])}
+            Please upgrade to at least React #{RSC_MINIMUM_REACT_VERSION}:
+              #{manual_add_packages_command(["react@#{RSC_MINIMUM_REACT_VERSION}", "react-dom@#{RSC_MINIMUM_REACT_VERSION}"])}
 
-            The standalone RSC generator does not upgrade your React or React DOM dependencies.
+            react-on-rails-rsc 19.2.x with patch >= 19.2.1 is coordinated with
+            React/React DOM #{RSC_MINIMUM_REACT_VERSION}+ for the React on Rails Pro 17 RSC runtime.
           MSG
         end
       end

data/lib/generators/react_on_rails/templates/pro/base/config/initializers/react_on_rails_pro.rb.tt

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # See https://reactonrails.com/docs/configuration/configuration-pro
-# License: Set REACT_ON_RAILS_PRO_LICENSE environment variable
+# Optional license key from your subscription: set REACT_ON_RAILS_PRO_LICENSE to mark your pages Licensed.
 ReactOnRailsPro.configure do |config|
   config.server_renderer = "NodeRenderer"
   config.renderer_url = ENV.fetch("REACT_RENDERER_URL", "http://localhost:3800")