react_on_rails 17.1.0 → 17.2.0.rc.0

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.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")