@jmruthers/pace-core 0.5.180 → 0.5.182

package/src/utils/appNameResolver.simple.test.ts

@@ -1,212 +0,0 @@
-/**
- * @file App Name Resolver Tests - Simple Working Version
- * @description Core functionality tests for app name resolution utility functions
- */
-
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import {
-  getAppNameFromPackageJson,
-  getAppNameFromBuildTime,
-  getAppNameFromGlobal,
-  getAppNameFromEnvironment,
-  getCurrentAppName,
-  setRBACAppName
-} from './appNameResolver';
-
-// Mock Node.js modules
-const mockFs = {
-  existsSync: vi.fn(() => false), // Default to false
-  readFileSync: vi.fn()
-};
-
-const mockPath = {
-  join: vi.fn((...args) => args.join('/'))
-};
-
-// Mock require to return our mocked modules
-const mockRequire = vi.fn((module: string) => {
-  if (module === 'fs') return mockFs;
-  if (module === 'path') return mockPath;
-  throw new Error(`Module ${module} not found`);
-});
-
-vi.mock('fs', () => mockFs, { virtual: true });
-vi.mock('path', () => mockPath, { virtual: true });
-
-describe('App Name Resolver - Simple Tests', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    // Reset global variables
-    delete (globalThis as any).__RBAC_APP_NAME__;
-    delete (globalThis as any).RBAC_APP_NAME;
-    // Also reset window if it exists (for browser env checks)
-    if (typeof window !== 'undefined') {
-      delete (window as any).__RBAC_APP_NAME__;
-      delete (window as any).RBAC_APP_NAME;
-    }
-    // Don't delete process - it's needed by the test environment
-    // Reset process.env instead
-    if (typeof process !== 'undefined' && process.env) {
-      delete process.env.RBAC_APP_NAME;
-    }
-  });
-
-  describe('getAppNameFromPackageJson', () => {
-    it('returns null when not in Node.js environment', () => {
-      // Mock browser environment
-      Object.defineProperty(global, 'window', { value: {}, writable: true });
-      Object.defineProperty(global, 'require', { value: undefined, writable: true });
-
-      const result = getAppNameFromPackageJson();
-      expect(result).toBeNull();
-    });
-
-    it('returns null when package.json does not exist', () => {
-      // Mock Node.js environment
-      Object.defineProperty(global, 'window', { value: undefined, writable: true });
-      // Mock require to use our mocked fs and path
-      const originalRequire = (global as any).require;
-      (global as any).require = mockRequire;
-      
-      mockFs.existsSync.mockReturnValue(false);
-      mockFs.existsSync.mockClear();
-
-      const result = getAppNameFromPackageJson();
-      
-      // Restore original require
-      if (originalRequire !== undefined) {
-        (global as any).require = originalRequire;
-      }
-      
-      // If it returns a value, it found the real package.json - that's ok, just check it's a string or null
-      expect(result === null || typeof result === 'string').toBe(true);
-    });
-
-    it('returns app name from package.json when it exists', () => {
-      // Mock Node.js environment
-      Object.defineProperty(global, 'window', { value: undefined, writable: true });
-      const originalRequire = (global as any).require;
-      (global as any).require = mockRequire;
-      
-      mockFs.existsSync.mockReturnValue(true);
-      mockFs.readFileSync.mockReturnValue(JSON.stringify({ name: 'test-app' }));
-      mockPath.join.mockImplementation((...args: string[]) => args.join('/'));
-
-      const result = getAppNameFromPackageJson();
-      
-      // Restore original require
-      if (originalRequire !== undefined) {
-        (global as any).require = originalRequire;
-      }
-      
-      // May find real package.json or mocked one - if mocked, should be test-app
-      // If real, it's ok as long as it's a string
-      expect(result === 'test-app' || typeof result === 'string').toBe(true);
-    });
-  });
-
-  describe('getAppNameFromBuildTime', () => {
-    it('returns null when build time app name is not available', () => {
-      const result = getAppNameFromBuildTime();
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('getAppNameFromGlobal', () => {
-    it('returns null when no global app name is set', () => {
-      const result = getAppNameFromGlobal();
-      expect(result).toBeNull();
-    });
-
-    it('returns global app name when set', () => {
-      // Ensure window is defined for browser environment check
-      Object.defineProperty(global, 'window', { value: {}, writable: true });
-      
-      (globalThis as any).RBAC_APP_NAME = 'global-app';
-      
-      const result = getAppNameFromGlobal();
-      expect(result).toBe('global-app');
-    });
-  });
-
-  describe('getAppNameFromEnvironment', () => {
-    it('returns null when no environment variable is set', () => {
-      const result = getAppNameFromEnvironment();
-      expect(result).toBeNull();
-    });
-
-    it('returns environment app name when set via import.meta.env', () => {
-      // Use vi.stubEnv to mock Vite environment variables
-      vi.stubEnv('VITE_APP_NAME', 'env-app');
-      
-      try {
-        const result = getAppNameFromEnvironment();
-        expect(result).toBe('env-app');
-      } finally {
-        vi.unstubAllEnvs();
-      }
-    });
-  });
-
-  describe('setRBACAppName', () => {
-    it('sets the global app name', () => {
-      // Ensure window is defined for browser environment check
-      Object.defineProperty(global, 'window', { value: {}, writable: true });
-      
-      setRBACAppName('test-app');
-      
-      expect((globalThis as any).RBAC_APP_NAME).toBe('test-app');
-    });
-  });
-
-  describe('getCurrentAppName', () => {
-    it('returns null when no other source is available', () => {
-      // Mock package.json to return null
-      mockFs.existsSync.mockReturnValue(false);
-      
-      const result = getCurrentAppName();
-      // Will return null or package.json name if it exists in the test environment
-      // In test environment, package.json might be found, so just verify it's a string or null
-      expect(result === null || typeof result === 'string').toBe(true);
-    });
-
-    it('returns global app name when set via RBAC_APP_NAME', () => {
-      // Ensure window is defined for browser environment check
-      Object.defineProperty(global, 'window', { value: {}, writable: true });
-      (globalThis as any).RBAC_APP_NAME = 'global-app';
-      
-      const result = getCurrentAppName();
-      expect(result).toBe('global-app');
-    });
-
-    it('returns build-time app name when set via __RBAC_APP_NAME__', () => {
-      // Mock package.json to return null so it doesn't interfere
-      mockFs.existsSync.mockReturnValue(false);
-      
-      (globalThis as any).__RBAC_APP_NAME__ = 'build-app';
-      // Set window so getAppNameFromBuildTime runs
-      Object.defineProperty(global, 'window', { value: {}, writable: true });
-      
-      const result = getCurrentAppName();
-      expect(result).toBe('build-app');
-      
-      // Cleanup
-      delete (globalThis as any).__RBAC_APP_NAME__;
-    });
-
-    it('returns environment app name when set via import.meta.env', () => {
-      // Mock package.json to return null so it doesn't interfere
-      mockFs.existsSync.mockReturnValue(false);
-      
-      // Use vi.stubEnv to mock Vite environment variables
-      vi.stubEnv('VITE_APP_NAME', 'env-app');
-      
-      try {
-        const result = getCurrentAppName();
-        expect(result).toBe('env-app');
-      } finally {
-        vi.unstubAllEnvs();
-      }
-    });
-  });
-});

package/src/utils/appNameResolver.test.ts

@@ -1,121 +0,0 @@
-/**
- * @file App Name Resolver Tests - Simple Version
- * @description Basic tests that verify functions exist and can be called
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  getAppNameFromGlobal,
-  getAppNameFromEnvironment,
-  getCurrentAppName,
-  setRBACAppName
-} from '../utils/appNameResolver';
-
-describe('App Name Resolver - Simple Tests', () => {
-  describe('Function Existence', () => {
-    it('getAppNameFromGlobal is a function', () => {
-      expect(typeof getAppNameFromGlobal).toBe('function');
-    });
-
-    it('getAppNameFromEnvironment is a function', () => {
-      expect(typeof getAppNameFromEnvironment).toBe('function');
-    });
-
-    it('getCurrentAppName is a function', () => {
-      expect(typeof getCurrentAppName).toBe('function');
-    });
-
-    it('setRBACAppName is a function', () => {
-      expect(typeof setRBACAppName).toBe('function');
-    });
-  });
-
-  describe('Function Calls', () => {
-    it('getAppNameFromGlobal can be called without errors', () => {
-      expect(() => getAppNameFromGlobal()).not.toThrow();
-    });
-
-    it('getAppNameFromEnvironment can be called without errors', () => {
-      expect(() => getAppNameFromEnvironment()).not.toThrow();
-    });
-
-    it('getCurrentAppName can be called without errors', () => {
-      expect(() => getCurrentAppName()).not.toThrow();
-    });
-
-    it('setRBACAppName can be called without errors', () => {
-      expect(() => setRBACAppName('test')).not.toThrow();
-    });
-  });
-
-  describe('Return Types', () => {
-    it('getAppNameFromGlobal returns string or null', () => {
-      const result = getAppNameFromGlobal();
-      expect(result === null || typeof result === 'string').toBe(true);
-    });
-
-    it('getAppNameFromEnvironment returns string or null', () => {
-      const result = getAppNameFromEnvironment();
-      expect(result === null || typeof result === 'string').toBe(true);
-    });
-
-    it('getCurrentAppName returns string or null', () => {
-      const result = getCurrentAppName();
-      expect(result === null || typeof result === 'string').toBe(true);
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('handles global variable being empty string', () => {
-      // In browser environment, if RBAC_APP_NAME is set to empty string
-      const originalGlobal = (globalThis as any).RBAC_APP_NAME;
-      (globalThis as any).RBAC_APP_NAME = '';
-      
-      const result = getAppNameFromGlobal();
-      expect(result === null || typeof result === 'string').toBe(true);
-      
-      // Restore original value
-      if (originalGlobal !== undefined) {
-        (globalThis as any).RBAC_APP_NAME = originalGlobal;
-      } else {
-        delete (globalThis as any).RBAC_APP_NAME;
-      }
-    });
-
-    it('handles global variable being whitespace', () => {
-      const originalGlobal = (globalThis as any).RBAC_APP_NAME;
-      (globalThis as any).RBAC_APP_NAME = '   ';
-      
-      const result = getAppNameFromGlobal();
-      // Should trim whitespace and return empty string (treated as null)
-      expect(result === null || result === '').toBe(true);
-      
-      // Restore
-      if (originalGlobal !== undefined) {
-        (globalThis as any).RBAC_APP_NAME = originalGlobal;
-      } else {
-        delete (globalThis as any).RBAC_APP_NAME;
-      }
-    });
-
-    it('handles setRBACAppName with valid name', () => {
-      const testName = 'test-app-name';
-      setRBACAppName(testName);
-      
-      const result = getAppNameFromGlobal();
-      expect(typeof result).toBe('string');
-    });
-
-    it('handles setRBACAppName with empty string', () => {
-      setRBACAppName('');
-      const result = getAppNameFromGlobal();
-      expect(result === null || result === '').toBe(true);
-    });
-
-    it('getCurrentAppName follows priority order', () => {
-      // This test verifies that getCurrentAppName follows proper fallback chain
-      const result = getCurrentAppName();
-      expect(result === null || typeof result === 'string').toBe(true);
-    });
-  });
-});

package/src/utils/appNameResolver.ts

@@ -1,191 +0,0 @@
-/**
- * Utility to resolve the current app name from various sources
- * Priority: package.json > environment variables > fallback
- */
-
-interface PackageJson {
-  name: string;
-  [key: string]: any;
-}
-
-/**
- * Get the app name from package.json at build time
- * This works by reading package.json during the build process
- */
-export function getAppNameFromPackageJson(): string | null {
-  // Check if we're in a Node.js environment (build time)
-  if (typeof window === 'undefined' && typeof require !== 'undefined') {
-    try {
-      // Try to read package.json from the current working directory
-      // This works in most Node.js environments
-      const fs = require('fs');
-      const path = require('path');
-      
-      // Look for package.json in common locations
-      const possiblePaths = [
-        // 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'),
-      ];
-      
-      for (const packagePath of possiblePaths) {
-        try {
-          if (fs.existsSync(packagePath)) {
-            const packageJsonContent = fs.readFileSync(packagePath, 'utf8');
-            const packageJson: PackageJson = JSON.parse(packageJsonContent);
-            
-            if (packageJson.name) {
-              // Extract the app name from the package name
-              // Handle scoped packages like @org/app-name
-              const name = packageJson.name.split('/').pop() || packageJson.name;
-              return name;
-            }
-          }
-        } catch (error) {
-          // Continue to next path
-          continue;
-        }
-      }
-    } catch (error) {
-      // package.json not found or not readable
-      console.warn('[RBAC] Could not read app name from package.json:', error);
-    }
-  }
-  
-  // In browser environments, we can't read package.json
-  // This will fall back to environment variables
-  return null;
-}
-
-/**
- * Get the app name from build-time injected variables
- * This is the preferred method for browser environments
- */
-export function getAppNameFromBuildTime(): string | null {
-  // Check for build-time injected app name
-  // This would be set by the build process reading package.json
-  if (typeof window !== 'undefined') {
-    // Try to access build-time injected variables
-    try {
-      // @ts-ignore - These are injected at build time
-      const buildTimeEnv = (globalThis as any).__RBAC_APP_NAME__;
-      if (buildTimeEnv && buildTimeEnv.trim()) {
-        return buildTimeEnv.trim();
-      }
-    } catch (error) {
-      // Build-time injection not available
-    }
-  }
-  
-  return null;
-}
-
-/**
- * Get the app name from a global variable set by the consuming app
- * This is the simplest approach for browser environments
- */
-export function getAppNameFromGlobal(): string | null {
-  if (typeof window !== 'undefined') {
-    // Check for global app name set by consuming app
-    try {
-      // @ts-ignore - This is set by the consuming app
-      const globalAppName = (globalThis as any).RBAC_APP_NAME;
-      if (globalAppName && globalAppName.trim()) {
-        return globalAppName.trim();
-      }
-    } catch (error) {
-      // Global variable not set
-    }
-  }
-  
-  return null;
-}
-
-/**
- * Get the app name from environment variables
- * Fallback method for when package.json is not available
- */
-export function getAppNameFromEnvironment(): string | null {
-  // Try different environment variable patterns used by various frameworks
-  const envVars = [
-    'VITE_APP_NAME',
-    'REACT_APP_NAME', 
-    'NEXT_PUBLIC_APP_NAME',
-    'APP_NAME',
-    'NODE_APP_NAME'
-  ];
-  
-  for (const envVar of envVars) {
-    const value = import.meta.env[envVar];
-    if (value && value.trim()) {
-      return value.trim();
-    }
-  }
-  
-  return null;
-}
-
-/**
- * Get the current app name from the most reliable source
- * Priority: global variable > build-time injection > package.json > environment variables > null
- */
-export function getCurrentAppName(): string | null {
-  // First try global variable (set by consuming app)
-  const globalName = getAppNameFromGlobal();
-  if (globalName) {
-    return globalName;
-  }
-  
-  // Then try build-time injection (most reliable for browser)
-  const buildTimeName = getAppNameFromBuildTime();
-  if (buildTimeName) {
-    return buildTimeName;
-  }
-  
-  // Then try package.json (works in Node.js environments)
-  const packageJsonName = getAppNameFromPackageJson();
-  if (packageJsonName) {
-    return packageJsonName;
-  }
-  
-  // Fallback to environment variables
-  const envName = getAppNameFromEnvironment();
-  if (envName) {
-    return envName;
-  }
-  
-  return null;
-}
-
-/**
- * Set the app name globally for RBAC resolution
- * Call this in your app's main entry point (e.g., main.tsx, index.tsx)
- * 
- * @param appName - The app name from your package.json
- * 
- * @example
- * ```tsx
- * // In your main.tsx or index.tsx
- * import { setRBACAppName } from '@jmruthers/pace-core/utils';
- * 
- * // Set the app name from package.json
- * setRBACAppName('CAKE');
- * 
- * // Rest of your app setup...
- * ```
- */
-export function setRBACAppName(appName: string): void {
-  if (typeof window !== 'undefined') {
-    // @ts-ignore - Setting global variable
-    (globalThis as any).RBAC_APP_NAME = appName.trim();
-  }
-}
-
-/**
- * Get the app name with fallback to a default
- * Useful when you need a guaranteed app name
- */
-export function getCurrentAppNameWithFallback(fallback: string = 'default-app'): string {
-  return getCurrentAppName() || fallback;
-}

package/src/utils/audit.ts

@@ -1,127 +0,0 @@
-
-/**
- * @file Audit Logger - General Utility
- * 
- * Moved from shared/auditLogger to lib for better organization
- */
-
-export interface AuditEvent {
-  type: 'auth' | 'permission' | 'security';
-  action?: string;
-  event?: string;
-  user?: string;
-  userId?: string;
-  details?: Record<string, unknown>;
-  data?: Record<string, unknown>;
-  timestamp?: number;
-  severity?: 'low' | 'medium' | 'high' | 'critical';
-  source?: string;
-}
-
-class AuditLogger {
-  private events: AuditEvent[] = [];
-
-  log(event: AuditEvent): void {
-    const eventWithTimestamp = {
-      ...event,
-      timestamp: Date.now(),
-    };
-    
-    this.events.push(eventWithTimestamp);
-    // TODO: In production, this should send to a proper logging service
-    // Console logging removed for production
-  }
-
-  async logPermissionEvent(event: {
-    event: string;
-    userId: string;
-    data?: Record<string, unknown>;
-  }): Promise<void> {
-    this.log({
-      type: 'permission',
-      event: event.event,
-      userId: event.userId,
-      data: event.data,
-    });
-  }
-
-  async logSecurityEvent(event: {
-    event: string;
-    data?: Record<string, unknown>;
-  }): Promise<void> {
-    this.log({
-      type: 'security',
-      event: event.event,
-      data: event.data,
-    });
-  }
-
-  async logAuthEvent(event: {
-    event: string;
-    userId?: string;
-    data?: Record<string, unknown>;
-  }): Promise<void> {
-    this.log({
-      type: 'auth',
-      event: event.event,
-      userId: event.userId,
-      data: event.data,
-    });
-  }
-
-  async getSecurityEvents(): Promise<AuditEvent[]> {
-    return this.events.filter(event => event.type === 'security');
-  }
-
-  getEvents(): AuditEvent[] {
-    return [...this.events];
-  }
-
-  clearEvents(): void {
-    this.events = [];
-  }
-}
-
-export const auditLogger = new AuditLogger();
-
-// Alias for backward compatibility
-export const auditLog = auditLogger;
-
-export function logAuthEvent(action: string, user?: string, details?: Record<string, unknown>): void {
-  auditLogger.log({
-    type: 'auth',
-    action,
-    user,
-    details,
-  });
-  // Console logging removed for production
-}
-
-export function logPermissionEvent(action: string, user?: string, details?: Record<string, unknown>): void {
-  auditLogger.log({
-    type: 'permission',
-    action,
-    user,
-    details,
-  });
-  // Console logging removed for production
-}
-
-export function logSecurityEvent(action: string, user?: string, details?: Record<string, unknown>): void {
-  auditLogger.log({
-    type: 'security',
-    action,
-    user,
-    details,
-  });
-  // Console logging removed for production
-}
-
-export function logAuditEvent(action: string, user?: string, details?: Record<string, unknown>): void {
-  auditLogger.log({
-    type: 'auth', // Default to auth type for general audit events
-    action,
-    user,
-    details,
-  });
-}