Implement license expiration handling with a 1-month grace period for production environments and update related tests for clarity and coverage

Author: AbanoubGhadban

react_on_rails_pro/LICENSE_SETUP.md

@@ -84,13 +84,27 @@ The license is validated at multiple points:
 
 React on Rails Pro requires a valid license in **all environments**:
 
-- ✅ **Development**: Requires license (use FREE license)
-- ✅ **Test**: Requires license (use FREE license)
-- ✅ **CI/CD**: Requires license (use FREE license)
-- ✅ **Production**: Requires license (use paid license)
+- ✅ **Development**: Requires license (use FREE license) - **Fails immediately on expiration**
+- ✅ **Test**: Requires license (use FREE license) - **Fails immediately on expiration**
+- ✅ **CI/CD**: Requires license (use FREE license) - **Fails immediately on expiration**
+- ✅ **Production**: Requires license (use paid license) - **1-month grace period after expiration**
 
 Get your FREE evaluation license in 30 seconds - no credit card required!
 
+### Production Grace Period
+
+**Production environments only** receive a **1-month grace period** when a license expires:
+
+- ⚠️ **During grace period**: Application continues to run but logs ERROR messages on every startup
+- ❌ **After grace period**: Application fails to start (same as dev/test)
+- 🔔 **Warning messages**: Include days remaining in grace period
+- ✅ **Development/Test**: No grace period - fails immediately (helps catch expiration early)
+
+**Important**: The grace period is designed to give production deployments time to renew, but you should:
+1. Monitor your logs for license expiration warnings
+2. Renew licenses before they expire
+3. Test license renewal in development/staging first
+
 ## Team Setup
 
 ### For Development Teams
@@ -158,11 +172,20 @@ window.railsContext.rorPro
 
 ### Error: "License has expired"
 
+**What happens:**
+- **Development/Test/CI**: Application fails to start immediately
+- **Production**: 1-month grace period with ERROR logs, then fails to start
+
 **Solutions:**
 1. **Free License**: Get a new 3-month FREE license
 2. **Paid License**: Contact support to renew
 3. Visit: [https://shakacode.com/react-on-rails-pro](https://shakacode.com/react-on-rails-pro)
 
+**If you see grace period warnings in production:**
+- You have time to renew, but don't wait!
+- The warning shows how many days remain
+- Plan your license renewal before the grace period ends
+
 ### Error: "License is missing required expiration field"
 
 **Cause:** You may have an old license format

react_on_rails_pro/lib/react_on_rails_pro/license_validator.rb

@@ -30,6 +30,9 @@ def license_data
 
       private
 
+      # Grace period: 1 month (in seconds)
+      GRACE_PERIOD_SECONDS = 30 * 24 * 60 * 60
+
       def validate_license
         license = load_and_decode_license
 
@@ -41,12 +44,28 @@ def validate_license
           handle_invalid_license(@validation_error)
         end
 
-        # Check expiry
-        if Time.now.to_i > license["exp"]
-          @validation_error = "License has expired. " \
+        # Check expiry with grace period for production
+        current_time = Time.now.to_i
+        exp_time = license["exp"]
+
+        if current_time > exp_time
+          days_expired = ((current_time - exp_time) / (24 * 60 * 60)).to_i
+
+          @validation_error = "License has expired #{days_expired} day(s) ago. " \
                               "Get a FREE evaluation license (3 months) at https://shakacode.com/react-on-rails-pro " \
                               "or upgrade to a paid license for production use."
-          handle_invalid_license(@validation_error)
+
+          # In production, allow a grace period of 1 month with error logging
+          if production? && within_grace_period?(exp_time)
+            grace_days_remaining = grace_days_remaining(exp_time)
+            Rails.logger.error(
+              "[React on Rails Pro] WARNING: #{@validation_error} " \
+              "Grace period: #{grace_days_remaining} day(s) remaining. " \
+              "Application will fail to start after grace period expires."
+            )
+          else
+            handle_invalid_license(@validation_error)
+          end
         end
 
         # Log license type if present (for analytics)
@@ -64,6 +83,20 @@ def validate_license
         handle_invalid_license(@validation_error)
       end
 
+      def production?
+        Rails.env.production?
+      end
+
+      def within_grace_period?(exp_time)
+        Time.now.to_i <= exp_time + GRACE_PERIOD_SECONDS
+      end
+
+      def grace_days_remaining(exp_time)
+        grace_end = exp_time + GRACE_PERIOD_SECONDS
+        seconds_remaining = grace_end - Time.now.to_i
+        (seconds_remaining / (24 * 60 * 60)).to_i
+      end
+
       def load_and_decode_license
         license_string = load_license_string
 

react_on_rails_pro/packages/node-renderer/src/shared/licenseValidator.ts

@@ -23,6 +23,9 @@ let cachedValid: boolean | undefined;
 let cachedLicenseData: LicenseData | undefined;
 let cachedValidationError: string | undefined;
 
+// Grace period: 1 month (in seconds)
+const GRACE_PERIOD_SECONDS = 30 * 24 * 60 * 60;
+
 /**
  * Handles invalid license by logging error and exiting.
  * @private
@@ -34,6 +37,32 @@ function handleInvalidLicense(message: string): never {
   process.exit(1);
 }
 
+/**
+ * Checks if the current environment is production.
+ * @private
+ */
+function isProduction(): boolean {
+  return process.env.NODE_ENV === 'production';
+}
+
+/**
+ * Checks if the license is within the grace period.
+ * @private
+ */
+function isWithinGracePeriod(expTime: number): boolean {
+  return Date.now() / 1000 <= expTime + GRACE_PERIOD_SECONDS;
+}
+
+/**
+ * Calculates remaining grace period days.
+ * @private
+ */
+function graceDaysRemaining(expTime: number): number {
+  const graceEnd = expTime + GRACE_PERIOD_SECONDS;
+  const secondsRemaining = graceEnd - Date.now() / 1000;
+  return Math.floor(secondsRemaining / (24 * 60 * 60));
+}
+
 /**
  * Logs license information for analytics.
  * @private
@@ -119,14 +148,30 @@ function performValidation(): boolean | never {
       handleInvalidLicense(cachedValidationError);
     }
 
-    // Check expiry
+    // Check expiry with grace period for production
     // Date.now() returns milliseconds, but JWT exp is in Unix seconds, so divide by 1000
-    if (Date.now() / 1000 > license.exp) {
+    const currentTime = Date.now() / 1000;
+    const expTime = license.exp;
+
+    if (currentTime > expTime) {
+      const daysExpired = Math.floor((currentTime - expTime) / (24 * 60 * 60));
+
       cachedValidationError =
-        'License has expired. ' +
+        `License has expired ${daysExpired} day(s) ago. ` +
         'Get a FREE evaluation license (3 months) at https://shakacode.com/react-on-rails-pro ' +
         'or upgrade to a paid license for production use.';
-      handleInvalidLicense(cachedValidationError);
+
+      // In production, allow a grace period of 1 month with error logging
+      if (isProduction() && isWithinGracePeriod(expTime)) {
+        const graceDays = graceDaysRemaining(expTime);
+        console.error(
+          `[React on Rails Pro] WARNING: ${cachedValidationError} ` +
+            `Grace period: ${graceDays} day(s) remaining. ` +
+            'Application will fail to start after grace period expires.',
+        );
+      } else {
+        handleInvalidLicense(cachedValidationError);
+      }
     }
 
     // Log license type if present (for analytics)

react_on_rails_pro/packages/node-renderer/tests/licenseValidator.test.ts

@@ -104,25 +104,74 @@ describe('LicenseValidator', () => {
       expect(module.validateLicense()).toBe(true);
     });
 
-    it('calls process.exit for expired license', () => {
-      const expiredPayload = {
-        sub: 'test@example.com',
-        iat: Math.floor(Date.now() / 1000) - 7200,
-        exp: Math.floor(Date.now() / 1000) - 3600, // Expired 1 hour ago
-      };
+    describe('expired license behavior', () => {
+      it('calls process.exit for expired license in development/test', () => {
+        const expiredPayload = {
+          sub: 'test@example.com',
+          iat: Math.floor(Date.now() / 1000) - 7200,
+          exp: Math.floor(Date.now() / 1000) - 3600, // Expired 1 hour ago
+        };
+
+        const expiredToken = jwt.sign(expiredPayload, testPrivateKey, { algorithm: 'RS256' });
+        mockLicenseEnv(expiredToken);
+        // Ensure NODE_ENV is not production
+        delete process.env.NODE_ENV;
+
+        const module = jest.requireActual<LicenseValidatorModule>('../src/shared/licenseValidator');
+
+        // Call validateLicense which should trigger process.exit
+        module.validateLicense();
+
+        // Verify process.exit was called with code 1
+        expect(mockProcessExit).toHaveBeenCalledWith(1);
+        expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('License has expired'));
+        expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('FREE evaluation license'));
+      });
 
-      const expiredToken = jwt.sign(expiredPayload, testPrivateKey, { algorithm: 'RS256' });
-      mockLicenseEnv(expiredToken);
+      it('logs warning but does not exit in production within grace period', () => {
+        // Expired 10 days ago (within 30-day grace period)
+        const expiredWithinGrace = {
+          sub: 'test@example.com',
+          iat: Math.floor(Date.now() / 1000) - 15 * 24 * 60 * 60,
+          exp: Math.floor(Date.now() / 1000) - 10 * 24 * 60 * 60,
+        };
 
-      const module = jest.requireActual<LicenseValidatorModule>('../src/shared/licenseValidator');
+        const expiredToken = jwt.sign(expiredWithinGrace, testPrivateKey, { algorithm: 'RS256' });
+        mockLicenseEnv(expiredToken);
+        process.env.NODE_ENV = 'production';
 
-      // Call validateLicense which should trigger process.exit
-      module.validateLicense();
+        const module = jest.requireActual<LicenseValidatorModule>('../src/shared/licenseValidator');
 
-      // Verify process.exit was called with code 1
-      expect(mockProcessExit).toHaveBeenCalledWith(1);
-      expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('License has expired'));
-      expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('FREE evaluation license'));
+        // Should not exit
+        expect(() => module.validateLicense()).not.toThrow();
+        expect(mockProcessExit).not.toHaveBeenCalled();
+
+        // Should log warning
+        expect(mockConsoleError).toHaveBeenCalledWith(
+          expect.stringMatching(/WARNING:.*License has expired.*Grace period:.*day\(s\) remaining/),
+        );
+      });
+
+      it('calls process.exit in production outside grace period', () => {
+        // Expired 35 days ago (outside 30-day grace period)
+        const expiredOutsideGrace = {
+          sub: 'test@example.com',
+          iat: Math.floor(Date.now() / 1000) - 60 * 24 * 60 * 60,
+          exp: Math.floor(Date.now() / 1000) - 35 * 24 * 60 * 60,
+        };
+
+        const expiredToken = jwt.sign(expiredOutsideGrace, testPrivateKey, { algorithm: 'RS256' });
+        mockLicenseEnv(expiredToken);
+        process.env.NODE_ENV = 'production';
+
+        const module = jest.requireActual<LicenseValidatorModule>('../src/shared/licenseValidator');
+
+        module.validateLicense();
+
+        // Verify process.exit was called with code 1
+        expect(mockProcessExit).toHaveBeenCalledWith(1);
+        expect(mockConsoleError).toHaveBeenCalledWith(expect.stringContaining('License has expired'));
+      });
     });
 
     it('calls process.exit for license missing exp field', () => {

react_on_rails_pro/spec/react_on_rails_pro/license_validator_spec.rb

@@ -73,12 +73,75 @@
         ENV["REACT_ON_RAILS_PRO_LICENSE"] = expired_token
       end
 
-      it "raises error" do
-        expect { described_class.validate! }.to raise_error(ReactOnRailsPro::Error, /License has expired/)
+      context "in development/test environment" do
+        before do
+          allow(Rails).to receive(:env).and_return(ActiveSupport::StringInquirer.new("development"))
+        end
+
+        it "raises error immediately" do
+          expect { described_class.validate! }.to raise_error(ReactOnRailsPro::Error, /License has expired/)
+        end
+
+        it "includes FREE license information in error message" do
+          expect { described_class.validate! }.to raise_error(ReactOnRailsPro::Error, /FREE evaluation license/)
+        end
       end
 
-      it "includes FREE license information in error message" do
-        expect { described_class.validate! }.to raise_error(ReactOnRailsPro::Error, /FREE evaluation license/)
+      context "in production environment" do
+        before do
+          allow(Rails).to receive(:env).and_return(ActiveSupport::StringInquirer.new("production"))
+        end
+
+        context "within grace period (expired < 1 month ago)" do
+          let(:expired_within_grace) do
+            {
+              sub: "test@example.com",
+              iat: Time.now.to_i - (15 * 24 * 60 * 60), # Issued 15 days ago
+              exp: Time.now.to_i - (10 * 24 * 60 * 60)  # Expired 10 days ago (within 1 month grace)
+            }
+          end
+
+          before do
+            token = JWT.encode(expired_within_grace, test_private_key, "RS256")
+            ENV["REACT_ON_RAILS_PRO_LICENSE"] = token
+          end
+
+          it "does not raise error" do
+            expect { described_class.validate! }.not_to raise_error
+          end
+
+          it "logs warning with grace period remaining" do
+            expect(mock_logger).to receive(:error).with(/WARNING:.*License has expired.*Grace period:.*day\(s\) remaining/)
+            described_class.validate!
+          end
+
+          it "returns true" do
+            expect(described_class.validate!).to be true
+          end
+        end
+
+        context "outside grace period (expired > 1 month ago)" do
+          let(:expired_outside_grace) do
+            {
+              sub: "test@example.com",
+              iat: Time.now.to_i - (60 * 24 * 60 * 60), # Issued 60 days ago
+              exp: Time.now.to_i - (35 * 24 * 60 * 60)  # Expired 35 days ago (outside 1 month grace)
+            }
+          end
+
+          before do
+            token = JWT.encode(expired_outside_grace, test_private_key, "RS256")
+            ENV["REACT_ON_RAILS_PRO_LICENSE"] = token
+          end
+
+          it "raises error" do
+            expect { described_class.validate! }.to raise_error(ReactOnRailsPro::Error, /License has expired/)
+          end
+
+          it "includes FREE license information in error message" do
+            expect { described_class.validate! }.to raise_error(ReactOnRailsPro::Error, /FREE evaluation license/)
+          end
+        end
       end
     end