@jmruthers/pace-core 0.2.4

package/src/utils/appIdResolver.ts

@@ -0,0 +1,130 @@
+/**
+ * App ID Resolution Utility
+ * @package @jmruthers/pace-core
+ * @module Utils/AppIdResolver
+ * @since 1.0.0
+ * 
+ * This module provides utilities to resolve app names to app IDs for database operations.
+ */
+
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { Database } from '../types/database';
+
+/**
+ * Resolves an app name to its corresponding app ID
+ * 
+ * @param supabase - Supabase client instance
+ * @param appName - The app name to resolve
+ * @returns Promise resolving to the app ID or null if not found
+ */
+export async function getAppId(
+  supabase: SupabaseClient<Database>,
+  appName: string
+): Promise<string | null> {
+  try {
+    const { data, error } = await supabase
+      .from('rbac_apps')
+      .select('id')
+      .ilike('name', appName)
+      .eq('is_active', true)
+      .single();
+
+    if (error) {
+      console.error('Failed to resolve app ID for app name:', appName, error);
+      return null;
+    }
+
+    return (data as { id: string } | null)?.id || null;
+  } catch (error) {
+    console.error('Error resolving app ID for app name:', appName, error);
+    return null;
+  }
+}
+
+/**
+ * Resolves multiple app names to their corresponding app IDs
+ * 
+ * @param supabase - Supabase client instance
+ * @param appNames - Array of app names to resolve
+ * @returns Promise resolving to a map of app names to app IDs
+ */
+export async function getAppIds(
+  supabase: SupabaseClient<Database>,
+  appNames: string[]
+): Promise<Record<string, string | null>> {
+  try {
+    // For case-insensitive matching with multiple values, we need to use OR conditions
+    // since PostgreSQL doesn't support case-insensitive IN with ILIKE
+    const orConditions = appNames.map(name => `name.ilike.${name}`).join(',');
+    
+    const { data, error } = await supabase
+      .from('rbac_apps')
+      .select('id, name')
+      .or(orConditions)
+      .eq('is_active', true);
+
+    if (error) {
+      console.error('Failed to resolve app IDs for app names:', appNames, error);
+      return {};
+    }
+
+    const result: Record<string, string | null> = {};
+    
+    // Initialize all app names with null
+    appNames.forEach(name => {
+      result[name] = null;
+    });
+
+    // Set resolved app IDs - match case-insensitively
+    (data as { id: string; name: string }[] | null)?.forEach(app => {
+      // Find the original app name that matches (case-insensitive)
+      const originalName = appNames.find(name => 
+        name.toLowerCase() === app.name.toLowerCase()
+      );
+      if (originalName) {
+        result[originalName] = app.id;
+      }
+    });
+
+    return result;
+  } catch (error) {
+    console.error('Error resolving app IDs for app names:', appNames, error);
+    return {};
+  }
+}
+
+/**
+ * Cached app ID resolver with TTL
+ */
+class CachedAppIdResolver {
+  private cache = new Map<string, { id: string | null; expires: number }>();
+  private ttl = 5 * 60 * 1000; // 5 minutes
+
+  async getAppId(
+    supabase: SupabaseClient<Database>,
+    appName: string
+  ): Promise<string | null> {
+    const now = Date.now();
+    const cached = this.cache.get(appName);
+
+    if (cached && cached.expires > now) {
+      return cached.id;
+    }
+
+    const id = await getAppId(supabase, appName);
+    this.cache.set(appName, { id, expires: now + this.ttl });
+
+    return id;
+  }
+
+  clearCache(): void {
+    this.cache.clear();
+  }
+
+  clearCacheForApp(appName: string): void {
+    this.cache.delete(appName);
+  }
+}
+
+// Export singleton instance
+export const cachedAppIdResolver = new CachedAppIdResolver();

package/src/utils/appNameResolver.ts

@@ -0,0 +1,190 @@
+/**
+ * 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 = [
+        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 = process.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

@@ -0,0 +1,127 @@
+
+/**
+ * @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,
+  });
+}

package/src/utils/auth-utils.ts

@@ -0,0 +1,96 @@
+/**
+ * @file Authentication utilities
+ */
+
+import type { User, SupabaseClient } from '@supabase/supabase-js';
+
+export interface LoginCredentials {
+  email: string;
+  password: string;
+}
+
+export interface SignUpData {
+  email: string;
+  password: string;
+}
+
+export interface AuthResponse {
+  user?: User;
+  error?: Error;
+}
+
+export async function signInWithEmail(credentials: LoginCredentials): Promise<AuthResponse> {
+  try {
+    // TODO: Implement actual authentication logic
+    // For now, return a proper error response indicating this needs implementation
+    return { 
+      error: new Error('Authentication not yet implemented - placeholder function') 
+    };
+  } catch (error) {
+    return { error: error instanceof Error ? error : new Error('Unknown authentication error') };
+  }
+}
+
+export async function signUpWithEmail(data: SignUpData): Promise<AuthResponse> {
+  try {
+    // TODO: Implement actual registration logic
+    // For now, return a proper error response indicating this needs implementation
+    return { 
+      error: new Error('Registration not yet implemented - placeholder function') 
+    };
+  } catch (error) {
+    return { error: error instanceof Error ? error : new Error('Unknown registration error') };
+  }
+}
+
+export async function resetPassword(email: string): Promise<{ error?: Error }> {
+  try {
+    // TODO: Implement actual password reset logic
+    // For now, return a proper error response indicating this needs implementation
+    return { 
+      error: new Error('Password reset not yet implemented - placeholder function') 
+    };
+  } catch (error) {
+    return { error: error instanceof Error ? error : new Error('Unknown password reset error') };
+  }
+}
+
+export async function updatePassword(supabaseClient: SupabaseClient, newPassword: string): Promise<{ error?: Error }> {
+  try {
+    const { error } = await supabaseClient.auth.updateUser({
+      password: newPassword
+    });
+    return { error: error || undefined };
+  } catch (err) {
+    return { error: err as Error };
+  }
+}
+
+// Audit logger implementation - using proper types instead of any
+export interface AuditEventDetails {
+  [key: string]: unknown;
+}
+
+export interface AuditEventData {
+  action: string;
+  details?: AuditEventDetails;
+}
+
+export const auditLogger = {
+  log: (event: string, details?: AuditEventDetails) => {
+    // TODO: Implement proper audit logging service integration
+    // Console logging removed for production
+  },
+  logAuthEvent: (userId: string, action: string, details?: AuditEventDetails) => {
+    // TODO: Implement proper auth event logging
+    // Console logging removed for production
+  },
+  logPermissionEvent: (userId: string, permission: string, granted: boolean) => {
+    // TODO: Implement proper permission event logging
+    // Console logging removed for production
+  },
+  logEvent: (eventData: AuditEventData) => {
+    // TODO: Implement proper event logging
+    // Console logging removed for production
+  }
+};

package/src/utils/bundleAnalysis.ts

@@ -0,0 +1,129 @@
+
+interface BundleStats {
+  totalSize: number;
+  gzippedSize: number;
+  chunks: ChunkInfo[];
+  treeshakingEffectiveness: number;
+}
+
+interface ChunkInfo {
+  name: string;
+  size: number;
+  modules: string[];
+  dynamicallyImported: boolean;
+}
+
+class BundleAnalyzer {
+  private enabled = process.env.NODE_ENV === 'development';
+
+  analyzeBundle(): BundleStats | null {
+    if (!this.enabled) return null;
+
+    // In a real implementation, this would integrate with webpack-bundle-analyzer
+    // or similar tools. For now, we'll simulate analysis
+    
+    // TODO: Replace with proper logging service integration
+    // For now, we'll log to console for testing purposes
+    console.log('Bundle analysis would run here in development');
+    console.log('To enable real bundle analysis:');
+    console.log('1. Install webpack-bundle-analyzer');
+    console.log('2. Add bundle analysis to build scripts');
+    console.log('3. Integrate with performance budgets');
+
+    return {
+      totalSize: 0,
+      gzippedSize: 0,
+      chunks: [],
+      treeshakingEffectiveness: 0
+    };
+  }
+
+  checkTreeshaking(): void {
+    if (!this.enabled) return;
+
+    const potentialIssues = [
+      'Check for unused exports in index files',
+      'Verify side-effect free modules in package.json',
+      'Ensure proper ES module syntax',
+      'Check for circular dependencies'
+    ];
+
+    // TODO: Replace with proper logging service integration
+    // For now, we'll log to console for testing purposes
+    console.group('Tree-shaking Analysis');
+    potentialIssues.forEach(issue => console.log('- ' + issue));
+    console.groupEnd();
+  }
+
+  validateExports(): void {
+    if (!this.enabled) return;
+
+    // TODO: Replace with proper logging service integration
+    // For now, we'll log to console for testing purposes
+    console.group('Export Validation');
+    console.log('Checking for optimal export patterns...');
+    console.log('- Prefer named exports over default exports');
+    console.log('- Avoid barrel exports for large modules');
+    console.log('- Use dynamic imports for large dependencies');
+    console.groupEnd();
+  }
+
+  generateReport(): string {
+    const report = `
+# Bundle Analysis Report
+
+## Recommendations for @jmruthers/pace-core
+
+### 1. Code Splitting Opportunities
+- ✅ DataTable virtualization is lazy-loaded
+- ⚠️  Consider splitting auth providers by use case
+- ⚠️  Lazy load heavy UI components (charts, complex forms)
+
+### 2. Tree-shaking Optimization
+- ✅ Using ES modules throughout
+- ✅ Proper sideEffects configuration
+- ⚠️  Check for unused utility functions
+
+### 3. Bundle Size Targets
+- Core components: < 50KB gzipped
+- Auth module: < 30KB gzipped  
+- Utilities: < 20KB gzipped
+- Total package: < 150KB gzipped
+
+### 4. Performance Monitoring
+- Monitor component render times
+- Track bundle size changes
+- Validate tree-shaking effectiveness
+    `;
+
+    return report.trim();
+  }
+}
+
+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;
+
+  const largeModules = ['lodash', 'moment', 'rxjs'];
+  const isLargeModule = largeModules.some(mod => moduleId.includes(mod));
+  
+  if (isLargeModule && importedItems.length > 5) {
+    // TODO: Replace with proper logging service integration
+    // For now, we'll log to console for testing purposes
+    console.warn(
+      'Large import detected: importing ' + importedItems.length + ' items from ' + moduleId + '. ' +
+      'Consider splitting imports or using more specific imports.'
+    );
+  }
+}
+
+// Monitor dynamic imports
+export function trackDynamicImport(moduleName: string): void {
+  if (process.env.NODE_ENV !== 'development') return;
+  
+  // TODO: Replace with proper logging service integration
+  // For now, we'll log to console for testing purposes
+  console.log('Dynamic import: ' + moduleName + ' - Good for code splitting!');
+}

package/src/utils/cn.ts

@@ -0,0 +1,7 @@
+
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}