fix TS problems

Author: AbanoubGhadban

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

@@ -10,7 +10,7 @@ interface LicenseData {
   plan?: string; // Optional: license plan (e.g., "free", "paid")
   issued_by?: string; // Optional: who issued the license
   // Allow additional fields
-  [key: string]: any;
+  [key: string]: unknown;
 }
 
 // Module-level state for caching
@@ -19,54 +19,88 @@ let cachedLicenseData: LicenseData | undefined;
 let cachedValidationError: string | undefined;
 
 /**
- * Validates the license and exits the process if invalid.
- * Caches the result after first validation.
- *
- * @throws Exits process if license is invalid
+ * Handles invalid license by logging error and exiting.
+ * @private
  */
-export function validateLicense(): void {
-  if (cachedValid !== undefined) {
-    return;
-  }
-
-  cachedValid = performValidation();
+function handleInvalidLicense(message: string): never {
+  const fullMessage = `[React on Rails Pro] ${message}`;
+  console.error(fullMessage);
+  // Validation errors should prevent the application from starting
+  process.exit(1);
 }
 
 /**
- * Gets the decoded license data.
- *
- * @returns Decoded license data or undefined if no license
+ * Logs license information for analytics.
+ * @private
  */
-export function getLicenseData(): LicenseData | undefined {
-  if (!cachedLicenseData) {
-    loadAndDecodeLicense();
+function logLicenseInfo(license: LicenseData): void {
+  const { plan, issued_by: issuedBy } = license;
+
+  if (plan) {
+    console.log(`[React on Rails Pro] License plan: ${plan}`);
+  }
+  if (issuedBy) {
+    console.log(`[React on Rails Pro] Issued by: ${issuedBy}`);
   }
-  return cachedLicenseData;
 }
 
 /**
- * Gets the validation error message if validation failed.
- *
- * @returns Error message or undefined
+ * Loads the license string from environment variable or config file.
+ * @private
  */
-export function getValidationError(): string | undefined {
-  return cachedValidationError;
+// eslint-disable-next-line consistent-return
+function loadLicenseString(): string | never {
+  // First try environment variable
+  const envLicense = process.env.REACT_ON_RAILS_PRO_LICENSE;
+  if (envLicense) {
+    return envLicense;
+  }
+
+  // Then try config file (relative to project root)
+  try {
+    const configPath = path.join(process.cwd(), 'config', 'react_on_rails_pro_license.key');
+    if (fs.existsSync(configPath)) {
+      return fs.readFileSync(configPath, 'utf8').trim();
+    }
+  } catch {
+    // File doesn't exist or can't be read
+  }
+
+  cachedValidationError =
+    'No license found. Please set REACT_ON_RAILS_PRO_LICENSE environment variable ' +
+    'or create config/react_on_rails_pro_license.key file. ' +
+    'Get a FREE evaluation license at https://shakacode.com/react-on-rails-pro';
+
+  handleInvalidLicense(cachedValidationError);
 }
 
 /**
- * Resets all cached validation state (primarily for testing).
+ * Loads and decodes the license from environment or file.
+ * @private
  */
-export function reset(): void {
-  cachedValid = undefined;
-  cachedLicenseData = undefined;
-  cachedValidationError = undefined;
+function loadAndDecodeLicense(): LicenseData {
+  const licenseString = loadLicenseString();
+
+  const decoded = jwt.verify(licenseString, PUBLIC_KEY, {
+    // Enforce RS256 algorithm only to prevent "alg=none" and downgrade attacks.
+    // Adding other algorithms to the whitelist (e.g., ['RS256', 'HS256']) can introduce vulnerabilities:
+    // If the public key is mistakenly used as a secret for HMAC algorithms (like HS256), attackers could forge tokens.
+    // Always carefully review algorithm changes to avoid signature bypass risks.
+    algorithms: ['RS256'],
+    // Disable automatic expiration verification so we can handle it manually with custom logic
+    ignoreExpiration: true,
+  }) as LicenseData;
+
+  cachedLicenseData = decoded;
+  return decoded;
 }
 
 /**
  * Performs the actual license validation logic.
  * @private
  */
-function performValidation(): boolean {
+// eslint-disable-next-line consistent-return
+function performValidation(): boolean | never {
   try {
     const license = loadAndDecodeLicense();
 
@@ -92,93 +126,67 @@ function performValidation(): boolean {
     logLicenseInfo(license);
 
     return true;
-  } catch (error: any) {
-    if (error.name === 'JsonWebTokenError') {
+  } catch (error: unknown) {
+    if (error instanceof Error && error.name === 'JsonWebTokenError') {
       cachedValidationError =
         `Invalid license signature: ${error.message}. ` +
         'Your license file may be corrupted. ' +
         'Get a FREE evaluation license at https://shakacode.com/react-on-rails-pro';
-    } else {
+    } else if (error instanceof Error) {
       cachedValidationError =
         `License validation error: ${error.message}. ` +
         'Get a FREE evaluation license at https://shakacode.com/react-on-rails-pro';
+    } else {
+      cachedValidationError =
+        'License validation error: Unknown error. ' +
+        'Get a FREE evaluation license at https://shakacode.com/react-on-rails-pro';
     }
     handleInvalidLicense(cachedValidationError);
   }
 }
 
 /**
- * Loads and decodes the license from environment or file.
- * @private
+ * Validates the license and exits the process if invalid.
+ * Caches the result after first validation.
+ *
+ * @returns true if license is valid
+ * @throws Exits process if license is invalid
  */
-function loadAndDecodeLicense(): LicenseData {
-  const licenseString = loadLicenseString();
-
-  const decoded = jwt.verify(licenseString, PUBLIC_KEY, {
-    // Enforce RS256 algorithm only to prevent "alg=none" and downgrade attacks.
-    // Adding other algorithms to the whitelist (e.g., ['RS256', 'HS256']) can introduce vulnerabilities:
-    // If the public key is mistakenly used as a secret for HMAC algorithms (like HS256), attackers could forge tokens.
-    // Always carefully review algorithm changes to avoid signature bypass risks.
-    algorithms: ['RS256'],
-    // Disable automatic expiration verification so we can handle it manually with custom logic
-    ignoreExpiration: true,
-  }) as LicenseData;
+export function validateLicense(): boolean {
+  if (cachedValid !== undefined) {
+    return cachedValid;
+  }
 
-  cachedLicenseData = decoded;
-  return decoded;
+  cachedValid = performValidation();
+  return cachedValid;
 }
 
 /**
- * Loads the license string from environment variable or config file.
- * @private
+ * Gets the decoded license data.
+ *
+ * @returns Decoded license data or undefined if no license
  */
-function loadLicenseString(): string {
-  // First try environment variable
-  const envLicense = process.env.REACT_ON_RAILS_PRO_LICENSE;
-  if (envLicense) {
-    return envLicense;
-  }
-
-  // Then try config file (relative to project root)
-  try {
-    const configPath = path.join(process.cwd(), 'config', 'react_on_rails_pro_license.key');
-    if (fs.existsSync(configPath)) {
-      return fs.readFileSync(configPath, 'utf8').trim();
-    }
-  } catch (error) {
-    // File doesn't exist or can't be read
+export function getLicenseData(): LicenseData | undefined {
+  if (!cachedLicenseData) {
+    loadAndDecodeLicense();
   }
-
-  cachedValidationError =
-    'No license found. Please set REACT_ON_RAILS_PRO_LICENSE environment variable ' +
-    'or create config/react_on_rails_pro_license.key file. ' +
-    'Get a FREE evaluation license at https://shakacode.com/react-on-rails-pro';
-
-  handleInvalidLicense(cachedValidationError);
+  return cachedLicenseData;
 }
 
 /**
- * Handles invalid license by logging error and exiting.
- * @private
+ * Gets the validation error message if validation failed.
+ *
+ * @returns Error message or undefined
  */
-function handleInvalidLicense(message: string): never {
-  const fullMessage = `[React on Rails Pro] ${message}`;
-  console.error(fullMessage);
-  // Validation errors should prevent the application from starting
-  process.exit(1);
+export function getValidationError(): string | undefined {
+  return cachedValidationError;
 }
 
 /**
- * Logs license information for analytics.
- * @private
+ * Resets all cached validation state (primarily for testing).
  */
-function logLicenseInfo(license: LicenseData): void {
-  const { plan, issued_by: issuedBy } = license;
-
-  if (plan) {
-    console.log(`[React on Rails Pro] License plan: ${plan}`);
-  }
-  if (issuedBy) {
-    console.log(`[React on Rails Pro] Issued by: ${issuedBy}`);
-  }
+export function reset(): void {
+  cachedValid = undefined;
+  cachedLicenseData = undefined;
+  cachedValidationError = undefined;
 }