@jmruthers/pace-core 0.5.181 → 0.5.183

package/src/utils/organisationContext.test.ts

@@ -1,322 +0,0 @@
-/**
- * @file Organisation Context Tests
- * @package @jmruthers/pace-core
- * @module Utils/OrganisationContext
- * @since 0.4.0
- * 
- * Comprehensive tests for organisation context utility functions covering all critical functionality.
- */
-
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import {
-  setOrganisationContext,
-  clearOrganisationContext,
-  getOrganisationContext
-} from './organisationContext';
-import type { SupabaseClient } from '@supabase/supabase-js';
-
-// Mock Supabase client
-const createMockSupabaseClient = () => ({
-  rpc: vi.fn().mockResolvedValue({ data: null, error: null })
-});
-
-describe('Organisation Context', () => {
-  let mockSupabase: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockSupabase = createMockSupabaseClient();
-  });
-
-    describe('setOrganisationContext', () => {
-    it('sets organisation context successfully', async () => {
-      mockSupabase.rpc.mockResolvedValue({
-        data: null,
-        error: null
-      });
-
-      await setOrganisationContext(mockSupabase, 'org-123');
-
-      expect(mockSupabase.rpc).toHaveBeenCalledWith('set_organisation_context', {
-        org_id: 'org-123'
-      });
-    });
-
-    it('handles missing supabase client gracefully', async () => {
-      await expect(setOrganisationContext(null as any, 'org-123')).resolves.not.toThrow();
-      await expect(setOrganisationContext(undefined as any, 'org-123')).resolves.not.toThrow();
-    });
-
-    it('handles missing organisation ID gracefully', async () => {
-      await expect(setOrganisationContext(mockSupabase, null as any)).resolves.not.toThrow();
-      await expect(setOrganisationContext(mockSupabase, undefined as any)).resolves.not.toThrow();
-      await expect(setOrganisationContext(mockSupabase, '')).resolves.not.toThrow();
-    });
-
-    it('handles database function errors gracefully', async () => {
-      mockSupabase.rpc.mockResolvedValue({
-        data: null,
-        error: { message: 'Function not found' }
-      });
-
-      // Should not throw error
-      await expect(setOrganisationContext(mockSupabase, 'org-123')).resolves.not.toThrow();
-    });
-
-    it('handles RPC exceptions gracefully', async () => {
-      mockSupabase.rpc.mockRejectedValue(new Error('Network error'));
-
-      // Should not throw error
-      await expect(setOrganisationContext(mockSupabase, 'org-123')).resolves.not.toThrow();
-    });
-
-    it('handles invalid organisation ID format', async () => {
-      await expect(setOrganisationContext(mockSupabase, 'invalid-id')).resolves.not.toThrow();
-      await expect(setOrganisationContext(mockSupabase, '123')).resolves.not.toThrow();
-    });
-
-    it('handles very long organisation ID', async () => {
-      const longOrgId = 'a'.repeat(1000);
-      await expect(setOrganisationContext(mockSupabase, longOrgId)).resolves.not.toThrow();
-    });
-  });
-
-  describe('clearOrganisationContext', () => {
-    it('clears organisation context successfully', async () => {
-      mockSupabase.rpc.mockResolvedValue({
-        data: null,
-        error: null
-      });
-
-      await clearOrganisationContext(mockSupabase);
-
-      expect(mockSupabase.rpc).toHaveBeenCalledWith('rbac_audit_log', {
-        p_event_type: 'organisation_switched',
-        p_metadata: { action: 'clear_context' }
-      });
-    });
-
-    it('handles missing supabase client gracefully', async () => {
-      await expect(clearOrganisationContext(null as any)).resolves.not.toThrow();
-      await expect(clearOrganisationContext(undefined as any)).resolves.not.toThrow();
-    });
-
-    it('handles database function errors gracefully', async () => {
-      mockSupabase.rpc.mockResolvedValue({
-        data: null,
-        error: { message: 'Function not found' }
-      });
-
-      // Should not throw error
-      await expect(clearOrganisationContext(mockSupabase)).resolves.not.toThrow();
-    });
-
-    it('handles RPC exceptions gracefully', async () => {
-      mockSupabase.rpc.mockRejectedValue(new Error('Network error'));
-
-      // Should not throw error
-      await expect(clearOrganisationContext(mockSupabase)).resolves.not.toThrow();
-    });
-  });
-
-  describe('getOrganisationContext', () => {
-    it('gets organisation context successfully', async () => {
-      const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
-    });
-
-    it('returns null when no context is set', async () => {
-      const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
-    });
-
-    it('handles missing supabase client gracefully', async () => {
-      const result1 = await getOrganisationContext(null as any);
-      const result2 = await getOrganisationContext(undefined as any);
-
-      expect(result1).toBeNull();
-      expect(result2).toBeNull();
-    });
-
-    it('handles database function errors gracefully', async () => {
-      const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
-    });
-
-    it('handles RPC exceptions gracefully', async () => {
-      const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
-    });
-
-    it('handles invalid data format gracefully', async () => {
-      const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
-    });
-
-    it('handles empty string data', async () => {
-      const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('Integration Tests', () => {
-    it('works with real Supabase client structure', async () => {
-      const mockClient = {
-        rpc: vi.fn().mockResolvedValue({
-          data: 'org-123',
-          error: null
-        })
-      };
-
-      const result = await getOrganisationContext(mockClient as any);
-
-      expect(result).toBeNull();
-    });
-
-    it('handles complete workflow', async () => {
-      // Set context
-      mockSupabase.rpc.mockResolvedValueOnce({
-        data: null,
-        error: null
-      });
-
-      await setOrganisationContext(mockSupabase, 'org-123');
-
-      // Get context
-      const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
-
-      // Clear context
-      mockSupabase.rpc.mockResolvedValueOnce({
-        data: null,
-        error: null
-      });
-
-      await clearOrganisationContext(mockSupabase);
-
-      expect(mockSupabase.rpc).toHaveBeenCalledTimes(2);
-    });
-
-    it('handles multiple organisation switches', async () => {
-      const organisations = ['org-123', 'org-456', 'org-789'];
-
-      for (const orgId of organisations) {
-        mockSupabase.rpc.mockResolvedValue({
-          data: null,
-          error: null
-        });
-
-        await setOrganisationContext(mockSupabase, orgId);
-      }
-
-      expect(mockSupabase.rpc).toHaveBeenCalledTimes(3);
-      expect(mockSupabase.rpc).toHaveBeenCalledWith('set_organisation_context', { org_id: 'org-123' });
-      expect(mockSupabase.rpc).toHaveBeenCalledWith('set_organisation_context', { org_id: 'org-456' });
-      expect(mockSupabase.rpc).toHaveBeenCalledWith('set_organisation_context', { org_id: 'org-789' });
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('handles network timeouts gracefully', async () => {
-      mockSupabase.rpc.mockRejectedValue(new Error('Request timeout'));
-
-      await expect(setOrganisationContext(mockSupabase, 'org-123')).resolves.not.toThrow();
-      await expect(clearOrganisationContext(mockSupabase)).resolves.not.toThrow();
-      await expect(getOrganisationContext(mockSupabase)).resolves.toBeNull();
-    });
-
-    it('handles malformed responses gracefully', async () => {
-      const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
-    });
-
-    it('handles null responses gracefully', async () => {
-      const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
-    });
-
-    it('handles undefined responses gracefully', async () => {
-      const result = await getOrganisationContext(mockSupabase);
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('Performance', () => {
-    it('handles rapid context changes efficiently', async () => {
-      const startTime = Date.now();
-
-      // Rapidly switch contexts
-      for (let i = 0; i < 100; i++) {
-        mockSupabase.rpc.mockResolvedValue({
-          data: null,
-          error: null
-        });
-
-        await setOrganisationContext(mockSupabase, `org-${i}`);
-      }
-
-      const endTime = Date.now();
-
-      expect(endTime - startTime).toBeLessThan(1000); // Should complete within 1 second
-    });
-
-    it('handles concurrent operations gracefully', async () => {
-      const operations = [
-        setOrganisationContext(mockSupabase, 'org-1'),
-        setOrganisationContext(mockSupabase, 'org-2'),
-        clearOrganisationContext(mockSupabase),
-        getOrganisationContext(mockSupabase)
-      ];
-
-      await expect(Promise.all(operations)).resolves.not.toThrow();
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('handles special characters in organisation ID', async () => {
-      const specialOrgId = 'org-123@domain.com';
-      await expect(setOrganisationContext(mockSupabase, specialOrgId)).resolves.not.toThrow();
-    });
-
-    it('handles unicode characters in organisation ID', async () => {
-      const unicodeOrgId = 'org-用户-123';
-      await expect(setOrganisationContext(mockSupabase, unicodeOrgId)).resolves.not.toThrow();
-    });
-
-    it('handles very long organisation ID', async () => {
-      const longOrgId = 'a'.repeat(10000);
-      await expect(setOrganisationContext(mockSupabase, longOrgId)).resolves.not.toThrow();
-    });
-
-    it('handles numeric organisation ID', async () => {
-      await expect(setOrganisationContext(mockSupabase, '123')).resolves.not.toThrow();
-    });
-
-    it('handles boolean organisation ID', async () => {
-      await expect(setOrganisationContext(mockSupabase, 'true' as any)).resolves.not.toThrow();
-    });
-  });
-
-  describe('Type Safety', () => {
-    it('maintains type safety with TypeScript', async () => {
-      const result = await getOrganisationContext(mockSupabase);
-      expect(result).toBeNull();
-    });
-
-    it('handles mixed input types gracefully', async () => {
-      await expect(setOrganisationContext(mockSupabase, 123 as any)).resolves.not.toThrow();
-      await expect(setOrganisationContext(mockSupabase, true as any)).resolves.not.toThrow();
-      await expect(setOrganisationContext(mockSupabase, {} as any)).resolves.not.toThrow();
-    });
-  });
-});

package/src/utils/organisationContext.ts

@@ -1,153 +0,0 @@
-/**
- * @file Organisation Context Utility
- * @package @jmruthers/pace-core
- * @module Utils/OrganisationContext
- * @since 0.4.0
- *
- * Utility functions for managing organisation context in database sessions.
- * Provides fallback mechanisms for when database functions are not available.
- */
-
-import type { SupabaseClient } from '@supabase/supabase-js';
-
-/**
- * Set organisation context in the database session
- * 
- * This function attempts to set the organisation context using a database function.
- * If the function is not available, it falls back gracefully without throwing errors.
- * 
- * @param supabase - Supabase client instance
- * @param organisationId - The organisation ID to set as context
- * @returns Promise that resolves when context is set (or falls back gracefully)
- */
-export async function setOrganisationContext(
-  supabase: SupabaseClient,
-  organisationId: string
-): Promise<void> {
-  if (!supabase || !organisationId) {
-    // TODO: Replace with proper logging service integration
-    return;
-  }
-
-  try {
-    // Add timeout to prevent hanging RPC calls
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => reject(new Error('RPC timeout after 3 seconds')), 3000);
-    });
-    
-    // Call the database function to set organisation context
-    const rpcPromise = supabase.rpc('set_organisation_context', {
-      org_id: organisationId
-    });
-
-    const { error } = await Promise.race([rpcPromise, timeoutPromise]) as any;
-
-    if (error) {
-      // Function might not exist yet - this is expected during migration
-      // Silent fail - will fall back to client-side filtering
-      console.log('[organisationContext] RPC function not available or failed, continuing without database context');
-    } else {
-      console.log('[organisationContext] Organisation context set in database successfully');
-    }
-  } catch (error) {
-    // Handle any other errors gracefully
-    // Silent fail - will fall back to client-side filtering
-    console.log('[organisationContext] Failed to set database context, continuing without it:', error);
-  }
-}
-
-/**
- * Clear organisation context from the database session
- * 
- * @param supabase - Supabase client instance
- * @returns Promise that resolves when context is cleared
- */
-export async function clearOrganisationContext(
-  supabase: SupabaseClient
-): Promise<void> {
-  if (!supabase) {
-    // TODO: Replace with proper logging service integration
-    return;
-  }
-
-  try {
-    const { error } = await supabase.rpc('rbac_audit_log', {
-      p_event_type: 'organisation_switched',
-      p_metadata: { action: 'clear_context' }
-    });
-    
-    if (error) {
-      // Silent fail - function not available
-      // TODO: Replace with proper logging service integration
-    } else {
-      // TODO: Replace with proper logging service integration
-    }
-  } catch (error) {
-    // Silent fail - error occurred
-    // TODO: Replace with proper logging service integration
-  }
-}
-
-/**
- * Get current organisation context from the database session
- * 
- * @param supabase - Supabase client instance
- * @returns Promise that resolves to the current organisation ID or null
- */
-export async function getOrganisationContext(
-  supabase: SupabaseClient
-): Promise<string | null> {
-  if (!supabase) {
-    // TODO: Replace with proper logging service integration
-    return null;
-  }
-
-  try {
-    // For now, return null since we're not using database context
-    // This will be replaced with proper context management
-    const data = null;
-    const error = null;
-    
-    if (error) {
-      // TODO: Replace with proper logging service integration
-      return null;
-    }
-    
-    // Validate that data is a string (allow empty strings)
-    if (typeof data === 'string') {
-      return data;
-    }
-    
-    // Return null for invalid data formats
-    return null;
-  } catch (error) {
-    // TODO: Replace with proper logging service integration
-    return null;
-  }
-}
-
-/**
- * Check if organisation context functions are available in the database
- * 
- * @param supabase - Supabase client instance
- * @returns Promise that resolves to true if functions are available
- */
-export async function isOrganisationContextAvailable(
-  supabase: SupabaseClient
-): Promise<boolean> {
-  if (!supabase) {
-    return false;
-  }
-
-  try {
-    const { error } = await supabase.rpc('get_organisation_context');
-    
-    if (error) {
-      return false;
-    }
-    
-    return true;
-  } catch (error) {
-    return false;
-  }
-} 

package/src/utils/performanceBenchmark.ts

@@ -1,64 +0,0 @@
-/**
- * Performance benchmarking utilities
- */
-
-export interface PerformanceMetrics {
-  renderTime: number;
-  interactionTime: number;
-  memoryUsage: number;
-  bundleSize: number;
-}
-
-export function createPerformanceBenchmark(name: string) {
-  const startTime = performance.now();
-  const startMemory = (performance as any).memory?.usedJSHeapSize || 0;
-
-  return {
-    end: () => {
-      const endTime = performance.now();
-      const endMemory = (performance as any).memory?.usedJSHeapSize || 0;
-      
-      const metrics: PerformanceMetrics = {
-        renderTime: endTime - startTime,
-        interactionTime: 0, // Would be measured separately
-        memoryUsage: endMemory - startMemory,
-        bundleSize: 0, // Would be measured at build time
-      };
-
-      // TODO: Replace with proper logging service integration
-      // For now, we'll use a no-op to prevent console pollution
-      const _unused = { 
-        benchmark: `Performance Benchmark [${name}]`, 
-        metrics 
-      };
-      
-      return metrics;
-    }
-  };
-}
-
-export function measureRenderPerformance(componentName: string, renderFn: () => void): PerformanceMetrics {
-  const startTime = performance.now();
-  const startMemory = (performance as any).memory?.usedJSHeapSize || 0;
-  
-  renderFn();
-  
-  const endTime = performance.now();
-  const endMemory = (performance as any).memory?.usedJSHeapSize || 0;
-  
-  const metrics: PerformanceMetrics = {
-    renderTime: endTime - startTime,
-    interactionTime: 0,
-    memoryUsage: endMemory - startMemory,
-    bundleSize: 0,
-  };
-  
-  // TODO: Replace with proper logging service integration
-  // For now, we'll use a no-op to prevent console pollution
-  const _unused = { 
-    benchmark: `Render Performance [${componentName}]`, 
-    metrics 
-  };
-  
-  return metrics;
-} 

package/src/utils/performanceBudgets.ts

@@ -1,110 +0,0 @@
-
-interface PerformanceBudget {
-  metric: string;
-  budget: number;
-  actual: number;
-  threshold: 'error' | 'warning' | 'info';
-}
-
-interface PerformanceMetrics {
-  bundleSize: number;
-  chunkCount: number;
-  treeshakingEffectiveness: number;
-  dynamicImportUsage: number;
-}
-
-interface MeasurementResult {
-  passed: boolean;
-  value: number;
-  threshold: number;
-}
-
-// Performance budget thresholds with index signature
-export const PERFORMANCE_BUDGETS: { [key: string]: { threshold: number } } = {
-  COMPONENT_RENDER: { threshold: 50 },
-  BUNDLE_SIZE: { threshold: 150000 },
-  CHUNK_COUNT: { threshold: 10 },
-  TREESHAKING_SCORE: { threshold: 70 },
-  ERROR_BOUNDARY_TRIGGER: { threshold: 5 },
-  MEMORY_INCREASE: { threshold: 1000 },
-  LARGE_LIST_RENDER: { threshold: 500 },
-} as const;
-
-class PerformanceBudgetMonitor {
-  private metrics: Map<string, number> = new Map();
-  private budgets: PerformanceBudget[] = [];
-
-  measure(metric: string, value: number, metadata?: Record<string, unknown>): MeasurementResult {
-    this.metrics.set(metric, value);
-    
-    // In production, this would send to a proper logging service
-    // For now, we'll log to console for testing purposes
-    if (import.meta.env.MODE === 'development' || import.meta.env.MODE === 'test' || process.env.NODE_ENV === 'test') {
-      console.log('📊 Performance Metric: ' + metric + ' = ' + value, metadata);
-    }
-
-    // Get threshold for this metric
-    const budgetConfig = PERFORMANCE_BUDGETS[metric];
-    const threshold = budgetConfig?.threshold || 100;
-    const passed = value <= threshold;
-
-    return {
-      passed,
-      value,
-      threshold
-    };
-  }
-
-  setBudget(metric: string, budget: number, threshold: 'error' | 'warning' | 'info' = 'warning'): void {
-    this.budgets.push({ metric, budget, actual: 0, threshold });
-  }
-
-  checkBudgets(): PerformanceBudget[] {
-    const violations: PerformanceBudget[] = [];
-    
-    for (const budget of this.budgets) {
-      const actual = this.metrics.get(budget.metric) || 0;
-      budget.actual = actual;
-      
-      if (actual > budget.budget) {
-        violations.push(budget);
-        
-        // In production, this would send to a proper logging service
-        // For now, we'll log to console for testing purposes
-        if (import.meta.env.MODE === 'development' || import.meta.env.MODE === 'test' || process.env.NODE_ENV === 'test') {
-          if (budget.threshold === 'error') {
-            console.error('❌ Performance budget exceeded: ' + budget.metric + ' (' + actual + ' > ' + budget.budget + ')');
-          } else if (budget.threshold === 'warning') {
-            console.warn('⚠️ Performance budget exceeded: ' + budget.metric + ' (' + actual + ' > ' + budget.budget + ')');
-          } else {
-            console.info('ℹ️ Performance budget exceeded: ' + budget.metric + ' (' + actual + ' > ' + budget.budget + ')');
-          }
-        }
-      }
-    }
-    
-    return violations;
-  }
-
-  getMetrics(): PerformanceMetrics {
-    return {
-      bundleSize: this.metrics.get('BUNDLE_SIZE') || 0,
-      chunkCount: this.metrics.get('CHUNK_COUNT') || 0,
-      treeshakingEffectiveness: this.metrics.get('TREESHAKING_SCORE') || 0,
-      dynamicImportUsage: this.metrics.get('DYNAMIC_IMPORTS') || 0,
-    };
-  }
-
-  reset(): void {
-    this.metrics.clear();
-    this.budgets.length = 0;
-  }
-}
-
-export const performanceBudgetMonitor = new PerformanceBudgetMonitor();
-
-// Set default performance budgets
-performanceBudgetMonitor.setBudget('BUNDLE_SIZE', 150000, 'error'); // 150KB
-performanceBudgetMonitor.setBudget('CHUNK_COUNT', 10, 'warning');
-performanceBudgetMonitor.setBudget('TREESHAKING_SCORE', 70, 'warning');
-performanceBudgetMonitor.setBudget('ERROR_BOUNDARY_TRIGGER', 5, 'error');

package/src/utils/permissionTypes.ts

@@ -1,37 +0,0 @@
-
-/**
- * @file Permission type definitions and utilities
- */
-
-export enum PermissionType {
-  READ = 'read',
-  WRITE = 'write',
-  DELETE = 'delete',
-  ADMIN = 'admin'
-}
-
-/**
- * Parse a permission string into components
- */
-export function parsePermission(permission: string): { resource: string; action: string } | null {
-  if (!permission || typeof permission !== 'string') {
-    return null;
-  }
-  
-  const parts = permission.split(':');
-  if (parts.length !== 2) {
-    return null;
-  }
-  
-  const [action, resource] = parts;
-  
-  // Check that both action and resource exist and are not empty
-  if (action === undefined || resource === undefined || action === '' || resource === '') {
-    return null;
-  }
-  
-  return {
-    resource,
-    action
-  };
-}