Add Pro-only feature validation for immediate_hydration and generated_component_packs_loading_strategy

Prevents non-Pro users from using these Pro-only features while maintaining
backward compatibility for Pro users.

Changes:
- Add validate_pro_only_features method to detect Pro-only settings in non-Pro
- In production: logs error without crashing
- In non-production: raises ReactOnRails::Error with helpful message
- Update validate_generated_component_packs_loading_strategy to skip auto-setting for non-Pro
- Remove Pro-only settings from spec/dummy initializer
- Add comprehensive unit tests for Pro-only validation
- Update existing tests to stub ReactOnRailsPro for Pro feature tests

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

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

Author: justin808

lib/react_on_rails/configuration.rb

@@ -142,10 +142,43 @@ def setup_config_values
       check_component_registry_timeout
       validate_generated_component_packs_loading_strategy
       validate_enforce_private_server_bundles
+      validate_pro_only_features
     end
 
     private
 
+    def validate_pro_only_features
+      return if defined?(ReactOnRailsPro)
+
+      pro_only_features = []
+
+      pro_only_features << "config.immediate_hydration = true" if immediate_hydration == true
+
+      if generated_component_packs_loading_strategy.present?
+        pro_only_features << "config.generated_component_packs_loading_strategy = " \
+                             ":#{generated_component_packs_loading_strategy}"
+      end
+
+      return if pro_only_features.empty?
+
+      msg = <<~MSG
+        **ERROR** ReactOnRails: You are using Pro-only features without React on Rails Pro:
+
+        #{pro_only_features.map { |f| "  - #{f}" }.join("\n")}
+
+        These features are only available with a React on Rails Pro license.
+        Please either:
+        1. Remove these settings from your config/initializers/react_on_rails.rb
+        2. Purchase a React on Rails Pro license at https://www.shakacode.com/react-on-rails-pro
+
+        For more information, see: https://www.shakacode.com/react-on-rails/docs/
+      MSG
+
+      return Rails.logger.error(msg) if Rails.env.production?
+
+      raise ReactOnRails::Error, msg
+    end
+
     def check_component_registry_timeout
       self.component_registry_timeout = DEFAULT_COMPONENT_REGISTRY_TIMEOUT if component_registry_timeout.nil?
 
@@ -176,6 +209,14 @@ def validate_generated_component_packs_loading_strategy
         1. Use :defer or :sync loading strategy instead of :async
         2. Upgrade to Shakapacker v8.2.0 or above to enable async script loading
       MSG
+
+      # Don't auto-set loading strategy for non-Pro users - this is a Pro-only feature
+      # For Pro users, the setting will be auto-set in ReactOnRailsPro configuration
+      if generated_component_packs_loading_strategy.nil? && !defined?(ReactOnRailsPro)
+        # Leave as nil for non-Pro - the Pro validation will be skipped
+        return
+      end
+
       if PackerUtils.supports_async_loading?
         self.generated_component_packs_loading_strategy ||= :async
       elsif generated_component_packs_loading_strategy.nil?

spec/dummy/config/initializers/react_on_rails.rb

@@ -41,11 +41,4 @@ def self.adjust_props_for_client_side_hydration(component_name, props)
   config.rendering_props_extension = RenderingPropsExtension
   config.components_subdirectory = "startup"
   config.auto_load_bundle = true
-  config.immediate_hydration = false
-
-  # Use :defer to prevent race conditions with auto-generated component packs.
-  # To test with :async (CI default), set: REACT_ON_RAILS_LOADING_STRATEGY=async
-  # See: spec/dummy/TESTING_LOCALLY.md for reproducing CI failures
-  loading_strategy = ENV.fetch("REACT_ON_RAILS_LOADING_STRATEGY", "defer").to_sym
-  config.generated_component_packs_loading_strategy = loading_strategy
 end

spec/react_on_rails/configuration_spec.rb

@@ -282,6 +282,8 @@ module ReactOnRails
         before do
           allow(ReactOnRails::PackerUtils).to receive(:shakapacker_version_requirement_met?)
             .with("8.2.0").and_return(true)
+          # Simulate Pro being available for these feature tests
+          stub_const("ReactOnRailsPro", Module.new)
         end
 
         it "defaults to :async" do
@@ -330,6 +332,8 @@ module ReactOnRails
           allow(ReactOnRails::PackerUtils).to receive(:shakapacker_version_requirement_met?)
             .with("8.2.0").and_return(false)
           allow(Rails.logger).to receive(:warn)
+          # Simulate Pro being available for these feature tests
+          stub_const("ReactOnRailsPro", Module.new)
         end
 
         it "defaults to :sync and logs a warning" do
@@ -421,6 +425,115 @@ module ReactOnRails
         end
       end
     end
+
+    describe "Pro-only feature validation" do
+      context "when ReactOnRailsPro is not defined" do
+        before do
+          # Ensure ReactOnRailsPro is not defined
+          hide_const("ReactOnRailsPro") if defined?(ReactOnRailsPro)
+          # Mock PackerUtils for generated_component_packs_loading_strategy
+          allow(ReactOnRails::PackerUtils).to receive(:supports_async_loading?).and_return(true)
+        end
+
+        context "when immediate_hydration is set to true" do
+          it "raises error in non-production environments" do
+            allow(Rails.env).to receive(:production?).and_return(false)
+            expect do
+              ReactOnRails.configure do |config|
+                config.immediate_hydration = true
+              end
+            end.to raise_error(ReactOnRails::Error, /Pro-only features without React on Rails Pro/)
+          end
+
+          it "logs error in production but does not raise" do
+            allow(Rails.env).to receive(:production?).and_return(true)
+            allow(Rails.logger).to receive(:error)
+            expect do
+              ReactOnRails.configure do |config|
+                config.immediate_hydration = true
+              end
+            end.not_to raise_error
+            expect(Rails.logger).to have_received(:error).with(/Pro-only features/)
+          end
+        end
+
+        context "when generated_component_packs_loading_strategy is explicitly set" do
+          it "raises error in non-production environments" do
+            allow(Rails.env).to receive(:production?).and_return(false)
+            expect do
+              ReactOnRails.configure do |config|
+                config.generated_component_packs_loading_strategy = :async
+              end
+            end.to raise_error(ReactOnRails::Error, /Pro-only features without React on Rails Pro/)
+          end
+
+          it "logs error in production but does not raise" do
+            allow(Rails.env).to receive(:production?).and_return(true)
+            allow(Rails.logger).to receive(:error)
+            expect do
+              ReactOnRails.configure do |config|
+                config.generated_component_packs_loading_strategy = :defer
+              end
+            end.not_to raise_error
+            expect(Rails.logger).to have_received(:error).with(/Pro-only features/)
+          end
+        end
+
+        context "when both Pro-only features are set" do
+          it "lists both features in error message" do
+            allow(Rails.env).to receive(:production?).and_return(false)
+            expect do
+              ReactOnRails.configure do |config|
+                config.immediate_hydration = true
+                config.generated_component_packs_loading_strategy = :async
+              end
+            end.to raise_error(ReactOnRails::Error, /immediate_hydration.*generated_component_packs_loading_strategy/m)
+          end
+        end
+
+        context "when immediate_hydration is set to false" do
+          it "does not raise error" do
+            expect do
+              ReactOnRails.configure do |config|
+                config.immediate_hydration = false
+              end
+            end.not_to raise_error
+          end
+        end
+
+        context "when no Pro-only features are set" do
+          it "does not raise error" do
+            expect do
+              ReactOnRails.configure {} # rubocop:disable Lint/EmptyBlock
+            end.not_to raise_error
+          end
+        end
+      end
+
+      context "when ReactOnRailsPro is defined" do
+        before do
+          # Simulate ReactOnRailsPro being defined
+          stub_const("ReactOnRailsPro", Module.new)
+          allow(ReactOnRails::PackerUtils).to receive(:supports_async_loading?).and_return(true)
+        end
+
+        it "allows immediate_hydration = true" do
+          expect do
+            ReactOnRails.configure do |config|
+              config.immediate_hydration = true
+            end
+          end.not_to raise_error
+        end
+
+        it "allows generated_component_packs_loading_strategy to be set" do
+          expect do
+            ReactOnRails.configure do |config|
+              config.generated_component_packs_loading_strategy = :async
+            end
+          end.not_to raise_error
+        end
+      end
+    end
   end
 end