@jmruthers/pace-core 0.5.54 → 0.5.55

package/src/utils/appNameResolver.test.ts

@@ -0,0 +1,494 @@
+/**
+ * @file App Name Resolver Tests
+ * @package @jmruthers/pace-core
+ * @module Utils/AppNameResolver
+ * @since 1.0.0
+ * 
+ * Comprehensive tests for app name resolution utility functions covering all critical functionality.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import {
+  getAppNameFromPackageJson,
+  getAppNameFromBuildTime,
+  getAppNameFromGlobal,
+  getAppNameFromEnvironment,
+  getCurrentAppName,
+  setRBACAppName
+} from './appNameResolver';
+
+// Mock Node.js modules
+const mockFs = {
+  existsSync: vi.fn(),
+  readFileSync: vi.fn()
+};
+
+const mockPath = {
+  join: vi.fn()
+};
+
+vi.mock('fs', () => mockFs);
+vi.mock('path', () => mockPath);
+
+describe('App Name Resolver', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Reset global variables
+    delete (globalThis as any).__RBAC_APP_NAME__;
+    delete (globalThis as any).RBAC_APP_NAME;
+    delete (globalThis as any).process;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('getAppNameFromPackageJson', () => {
+    it('reads app name from package.json in Node.js environment', () => {
+      // Mock Node.js environment
+      Object.defineProperty(global, 'window', { value: undefined, writable: true });
+      Object.defineProperty(global, 'require', { value: vi.fn(), writable: true });
+
+      mockPath.join.mockReturnValue('/path/to/package.json');
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ name: '@org/my-app' }));
+
+      const result = getAppNameFromPackageJson();
+
+      expect(result).toBe('my-app');
+      expect(mockPath.join).toHaveBeenCalledWith(expect.any(String), 'package.json');
+      expect(mockFs.existsSync).toHaveBeenCalledWith('/path/to/package.json');
+      expect(mockFs.readFileSync).toHaveBeenCalledWith('/path/to/package.json', 'utf8');
+    });
+
+    it('handles scoped packages correctly', () => {
+      Object.defineProperty(global, 'window', { value: undefined, writable: true });
+      Object.defineProperty(global, 'require', { value: vi.fn(), writable: true });
+
+      mockPath.join.mockReturnValue('/path/to/package.json');
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ name: '@myorg/super-app' }));
+
+      const result = getAppNameFromPackageJson();
+
+      expect(result).toBe('super-app');
+    });
+
+    it('handles non-scoped packages correctly', () => {
+      Object.defineProperty(global, 'window', { value: undefined, writable: true });
+      Object.defineProperty(global, 'require', { value: vi.fn(), writable: true });
+
+      mockPath.join.mockReturnValue('/path/to/package.json');
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ name: 'my-app' }));
+
+      const result = getAppNameFromPackageJson();
+
+      expect(result).toBe('my-app');
+    });
+
+    it('tries multiple package.json paths', () => {
+      Object.defineProperty(global, 'window', { value: undefined, writable: true });
+      Object.defineProperty(global, 'require', { value: vi.fn(), writable: true });
+
+      mockPath.join
+        .mockReturnValueOnce('/path/to/package.json')
+        .mockReturnValueOnce('/path/to/../../package.json')
+        .mockReturnValueOnce('/path/to/../../../package.json');
+      
+      mockFs.existsSync
+        .mockReturnValueOnce(false)
+        .mockReturnValueOnce(false)
+        .mockReturnValueOnce(true);
+      
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ name: 'my-app' }));
+
+      const result = getAppNameFromPackageJson();
+
+      expect(result).toBe('my-app');
+      expect(mockPath.join).toHaveBeenCalledTimes(3);
+      expect(mockFs.existsSync).toHaveBeenCalledTimes(3);
+    });
+
+    it('returns null in browser environment', () => {
+      Object.defineProperty(global, 'window', { value: {}, writable: true });
+
+      const result = getAppNameFromPackageJson();
+
+      expect(result).toBeNull();
+    });
+
+    it('handles missing package.json gracefully', () => {
+      Object.defineProperty(global, 'window', { value: undefined, writable: true });
+      Object.defineProperty(global, 'require', { value: vi.fn(), writable: true });
+
+      mockPath.join.mockReturnValue('/path/to/package.json');
+      mockFs.existsSync.mockReturnValue(false);
+
+      const result = getAppNameFromPackageJson();
+
+      expect(result).toBeNull();
+    });
+
+    it('handles invalid JSON gracefully', () => {
+      Object.defineProperty(global, 'window', { value: undefined, writable: true });
+      Object.defineProperty(global, 'require', { value: vi.fn(), writable: true });
+
+      mockPath.join.mockReturnValue('/path/to/package.json');
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue('invalid json');
+
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const result = getAppNameFromPackageJson();
+
+      expect(result).toBeNull();
+      expect(consoleSpy).toHaveBeenCalledWith(
+        '[RBAC] Could not read app name from package.json:',
+        expect.any(Error)
+      );
+
+      consoleSpy.mockRestore();
+    });
+
+    it('handles missing name field in package.json', () => {
+      Object.defineProperty(global, 'window', { value: undefined, writable: true });
+      Object.defineProperty(global, 'require', { value: vi.fn(), writable: true });
+
+      mockPath.join.mockReturnValue('/path/to/package.json');
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ version: '1.0.0' }));
+
+      const result = getAppNameFromPackageJson();
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('getAppNameFromBuildTime', () => {
+    it('reads app name from build-time injected variable', () => {
+      (globalThis as any).__RBAC_APP_NAME__ = 'my-app';
+
+      const result = getAppNameFromBuildTime();
+
+      expect(result).toBe('my-app');
+    });
+
+    it('trims whitespace from build-time variable', () => {
+      (globalThis as any).__RBAC_APP_NAME__ = '  my-app  ';
+
+      const result = getAppNameFromBuildTime();
+
+      expect(result).toBe('my-app');
+    });
+
+    it('returns null when build-time variable is not set', () => {
+      const result = getAppNameFromBuildTime();
+
+      expect(result).toBeNull();
+    });
+
+    it('returns null when build-time variable is empty', () => {
+      (globalThis as any).__RBAC_APP_NAME__ = '';
+
+      const result = getAppNameFromBuildTime();
+
+      expect(result).toBeNull();
+    });
+
+    it('handles errors gracefully', () => {
+      // Mock globalThis access to throw error
+      Object.defineProperty(globalThis, '__RBAC_APP_NAME__', {
+        get: () => { throw new Error('Access denied'); }
+      });
+
+      const result = getAppNameFromBuildTime();
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('getAppNameFromGlobal', () => {
+    it('reads app name from global variable', () => {
+      (globalThis as any).RBAC_APP_NAME = 'my-app';
+
+      const result = getAppNameFromGlobal();
+
+      expect(result).toBe('my-app');
+    });
+
+    it('trims whitespace from global variable', () => {
+      (globalThis as any).RBAC_APP_NAME = '  my-app  ';
+
+      const result = getAppNameFromGlobal();
+
+      expect(result).toBe('my-app');
+    });
+
+    it('returns null when global variable is not set', () => {
+      const result = getAppNameFromGlobal();
+
+      expect(result).toBeNull();
+    });
+
+    it('returns null when global variable is empty', () => {
+      (globalThis as any).RBAC_APP_NAME = '';
+
+      const result = getAppNameFromGlobal();
+
+      expect(result).toBeNull();
+    });
+
+    it('handles errors gracefully', () => {
+      // Mock globalThis access to throw error
+      Object.defineProperty(globalThis, 'RBAC_APP_NAME', {
+        get: () => { throw new Error('Access denied'); }
+      });
+
+      const result = getAppNameFromGlobal();
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('getAppNameFromEnvironment', () => {
+    it('reads app name from environment variable', () => {
+      const originalEnv = process.env;
+      process.env = { ...originalEnv, RBAC_APP_NAME: 'my-app' };
+
+      const result = getAppNameFromEnvironment();
+
+      expect(result).toBe('my-app');
+
+      process.env = originalEnv;
+    });
+
+    it('trims whitespace from environment variable', () => {
+      const originalEnv = process.env;
+      process.env = { ...originalEnv, RBAC_APP_NAME: '  my-app  ' };
+
+      const result = getAppNameFromEnvironment();
+
+      expect(result).toBe('my-app');
+
+      process.env = originalEnv;
+    });
+
+    it('returns null when environment variable is not set', () => {
+      const originalEnv = process.env;
+      process.env = { ...originalEnv };
+      delete process.env.RBAC_APP_NAME;
+
+      const result = getAppNameFromEnvironment();
+
+      expect(result).toBeNull();
+
+      process.env = originalEnv;
+    });
+
+    it('returns null when environment variable is empty', () => {
+      const originalEnv = process.env;
+      process.env = { ...originalEnv, RBAC_APP_NAME: '' };
+
+      const result = getAppNameFromEnvironment();
+
+      expect(result).toBeNull();
+
+      process.env = originalEnv;
+    });
+  });
+
+  describe('getCurrentAppName', () => {
+    it('returns app name from build-time variable (highest priority)', () => {
+      (globalThis as any).__RBAC_APP_NAME__ = 'build-time-app';
+      (globalThis as any).RBAC_APP_NAME = 'global-app';
+      
+      const originalEnv = process.env;
+      process.env = { ...originalEnv, RBAC_APP_NAME: 'env-app' };
+
+      const result = getCurrentAppName();
+
+      expect(result).toBe('build-time-app');
+
+      process.env = originalEnv;
+    });
+
+    it('falls back to global variable when build-time is not available', () => {
+      (globalThis as any).RBAC_APP_NAME = 'global-app';
+      
+      const originalEnv = process.env;
+      process.env = { ...originalEnv, RBAC_APP_NAME: 'env-app' };
+
+      const result = getCurrentAppName();
+
+      expect(result).toBe('global-app');
+
+      process.env = originalEnv;
+    });
+
+    it('falls back to environment variable when others are not available', () => {
+      const originalEnv = process.env;
+      process.env = { ...originalEnv, RBAC_APP_NAME: 'env-app' };
+
+      const result = getCurrentAppName();
+
+      expect(result).toBe('env-app');
+
+      process.env = originalEnv;
+    });
+
+    it('falls back to package.json when others are not available', () => {
+      Object.defineProperty(global, 'window', { value: undefined, writable: true });
+      Object.defineProperty(global, 'require', { value: vi.fn(), writable: true });
+
+      mockPath.join.mockReturnValue('/path/to/package.json');
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ name: 'package-app' }));
+
+      const result = getCurrentAppName();
+
+      expect(result).toBe('package-app');
+    });
+
+    it('returns fallback when all methods fail', () => {
+      const result = getCurrentAppName();
+
+      expect(result).toBe('pace-core');
+    });
+  });
+
+  describe('setRBACAppName', () => {
+    it('sets global app name variable', () => {
+      setRBACAppName('my-app');
+
+      expect((globalThis as any).RBAC_APP_NAME).toBe('my-app');
+    });
+
+    it('trims whitespace when setting app name', () => {
+      setRBACAppName('  my-app  ');
+
+      expect((globalThis as any).RBAC_APP_NAME).toBe('my-app');
+    });
+
+    it('handles null/undefined app name', () => {
+      setRBACAppName(null as any);
+      setRBACAppName(undefined as any);
+
+      expect((globalThis as any).RBAC_APP_NAME).toBeUndefined();
+    });
+
+    it('handles empty app name', () => {
+      setRBACAppName('');
+
+      expect((globalThis as any).RBAC_APP_NAME).toBe('');
+    });
+  });
+
+  describe('Integration Tests', () => {
+    it('works with real-world scenarios', () => {
+      // Test build-time injection
+      (globalThis as any).__RBAC_APP_NAME__ = 'production-app';
+      expect(getCurrentAppName()).toBe('production-app');
+
+      // Test global variable fallback
+      delete (globalThis as any).__RBAC_APP_NAME__;
+      (globalThis as any).RBAC_APP_NAME = 'development-app';
+      expect(getCurrentAppName()).toBe('development-app');
+
+      // Test environment variable fallback
+      delete (globalThis as any).RBAC_APP_NAME__;
+      const originalEnv = process.env;
+      process.env = { ...originalEnv, RBAC_APP_NAME: 'test-app' };
+      expect(getCurrentAppName()).toBe('test-app');
+
+      process.env = originalEnv;
+    });
+
+    it('handles complex app name patterns', () => {
+      const appNames = [
+        'my-app',
+        'my_app',
+        'MyApp',
+        'myapp',
+        '@org/my-app',
+        'my-app-v2',
+        'my-app@1.0.0'
+      ];
+
+      appNames.forEach(appName => {
+        setRBACAppName(appName);
+        expect(getCurrentAppName()).toBe(appName);
+      });
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('handles file system errors gracefully', () => {
+      Object.defineProperty(global, 'window', { value: undefined, writable: true });
+      Object.defineProperty(global, 'require', { value: vi.fn(), writable: true });
+
+      mockPath.join.mockReturnValue('/path/to/package.json');
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockImplementation(() => {
+        throw new Error('Permission denied');
+      });
+
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const result = getAppNameFromPackageJson();
+
+      expect(result).toBeNull();
+      expect(consoleSpy).toHaveBeenCalledWith(
+        '[RBAC] Could not read app name from package.json:',
+        expect.any(Error)
+      );
+
+      consoleSpy.mockRestore();
+    });
+
+    it('handles JSON parsing errors gracefully', () => {
+      Object.defineProperty(global, 'window', { value: undefined, writable: true });
+      Object.defineProperty(global, 'require', { value: vi.fn(), writable: true });
+
+      mockPath.join.mockReturnValue('/path/to/package.json');
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue('{ "name": "my-app" }'); // Valid JSON but missing closing brace
+
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const result = getAppNameFromPackageJson();
+
+      expect(result).toBeNull();
+      expect(consoleSpy).toHaveBeenCalledWith(
+        '[RBAC] Could not read app name from package.json:',
+        expect.any(Error)
+      );
+
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('Performance', () => {
+    it('caches results efficiently', () => {
+      const startTime = Date.now();
+      
+      // Call multiple times
+      for (let i = 0; i < 1000; i++) {
+        getCurrentAppName();
+      }
+      
+      const endTime = Date.now();
+
+      expect(endTime - startTime).toBeLessThan(100); // Should be very fast
+    });
+
+    it('handles large app names efficiently', () => {
+      const largeAppName = 'a'.repeat(1000);
+      setRBACAppName(largeAppName);
+
+      const result = getCurrentAppName();
+
+      expect(result).toBe(largeAppName);
+    });
+  });
+});

package/src/utils/appNameResolver.ts

@@ -23,7 +23,8 @@ export function getAppNameFromPackageJson(): string | null {
       
       // Look for package.json in common locations
       const possiblePaths = [
-        path.join(process.cwd(), 'package.json'),
+        // Only use process.cwd() if we're in a Node.js environment
+        ...(typeof process !== 'undefined' && process.cwd ? [path.join(process.cwd(), 'package.json')] : []),
         path.join(__dirname, '../../package.json'),
         path.join(__dirname, '../../../package.json'),
       ];
@@ -116,7 +117,7 @@ export function getAppNameFromEnvironment(): string | null {
   ];
   
   for (const envVar of envVars) {
-    const value = process.env[envVar];
+    const value = import.meta.env[envVar];
     if (value && value.trim()) {
       return value.trim();
     }

package/src/utils/bundleAnalysis.ts

@@ -14,7 +14,7 @@ interface ChunkInfo {
 }
 
 class BundleAnalyzer {
-  private enabled = process.env.NODE_ENV === 'development';
+  private enabled = import.meta.env.MODE === 'development';
 
   analyzeBundle(): BundleStats | null {
     if (!this.enabled) return null;
@@ -104,7 +104,7 @@ export const bundleAnalyzer = new BundleAnalyzer();
 
 // Helper to check if imports are optimized
 export function validateImportPattern(moduleId: string, importedItems: string[]): void {
-  if (process.env.NODE_ENV !== 'development') return;
+  if (import.meta.env.MODE !== 'development') return;
 
   const largeModules = ['lodash', 'moment', 'rxjs'];
   const isLargeModule = largeModules.some(mod => moduleId.includes(mod));
@@ -121,7 +121,7 @@ export function validateImportPattern(moduleId: string, importedItems: string[])
 
 // Monitor dynamic imports
 export function trackDynamicImport(moduleName: string): void {
-  if (process.env.NODE_ENV !== 'development') return;
+  if (import.meta.env.MODE !== 'development') return;
   
   // TODO: Replace with proper logging service integration
   // For now, we'll log to console for testing purposes

package/src/utils/debugLogger.ts

@@ -10,7 +10,7 @@
  * Only logs in development mode to prevent production console spam
  */
 export class DebugLogger {
-  private static isDevelopment = process.env.NODE_ENV === 'development';
+  private static isDevelopment = import.meta.env.MODE === 'development';
 
   /**
    * Log debug information only in development mode