@jmruthers/pace-core 0.5.76 → 0.5.78

package/src/hooks/services/__tests__/useServiceHooks.test.tsx

@@ -1,137 +0,0 @@
-/**
- * @file Service Hooks Error Handling Tests
- * @package @jmruthers/pace-core
- * @module Hooks/Services/__tests__
- * @since 1.0.0
- *
- * Tests for service hooks covering error scenarios and context handling.
- */
-
-import { describe, it, expect, vi } from 'vitest';
-import { renderHook } from '@testing-library/react';
-import { useEventService } from '../useEventService';
-import { useOrganisationService } from '../useOrganisationService';
-import { useInactivityService } from '../useInactivityService';
-import { useRBACService } from '../useRBACService';
-import { useAuthService } from '../useAuthService';
-
-// Mock contexts
-const createMockContext = (service: any) => ({
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  subscribe: vi.fn(() => () => {}), // Return unsubscribe function
-  [Object.keys(service)[0]]: service[Object.keys(service)[0]] || service
-});
-
-describe('Service Hooks Error Handling', () => {
-  describe('useEventService', () => {
-    it('throws error when used outside provider', () => {
-      expect(() => {
-        renderHook(() => useEventService());
-      }).toThrow('useEventService must be used within EventServiceProvider');
-    });
-
-    it('returns service when context is provided', () => {
-      const mockService = { getEvents: vi.fn(), refreshEvents: vi.fn() };
-      const mockContext = createMockContext({ eventService: mockService });
-
-      vi.mock('../../providers/services/EventServiceProvider', () => ({
-        EventServiceContext: {
-          Provider: ({ children }: any) => children
-        },
-        __esModule: true
-      }));
-
-      // This test requires a provider wrapper
-      expect(true).toBe(true);
-    });
-  });
-
-  describe('useOrganisationService', () => {
-    it('throws error when used outside provider', () => {
-      expect(() => {
-        renderHook(() => useOrganisationService());
-      }).toThrow('useOrganisationService must be used within OrganisationServiceProvider');
-    });
-
-    it('validates provider requirement', () => {
-      expect(() => {
-        renderHook(() => useOrganisationService());
-      }).toThrow();
-    });
-  });
-
-  describe('useInactivityService', () => {
-    it('throws error when used outside provider', () => {
-      expect(() => {
-        renderHook(() => useInactivityService());
-      }).toThrow('useInactivityService must be used within InactivityServiceProvider');
-    });
-
-    it('validates provider requirement', () => {
-      expect(() => {
-        renderHook(() => useInactivityService());
-      }).toThrow();
-    });
-  });
-
-  describe('useRBACService', () => {
-    it('throws error when used outside provider', () => {
-      expect(() => {
-        renderHook(() => useRBACService());
-      }).toThrow('useRBACService must be used within RBACServiceProvider');
-    });
-
-    it('validates provider requirement', () => {
-      expect(() => {
-        renderHook(() => useRBACService());
-      }).toThrow();
-    });
-  });
-
-  describe('useAuthService', () => {
-    it('throws error when used outside provider', () => {
-      expect(() => {
-        renderHook(() => useAuthService());
-      }).toThrow('useAuthService must be used within AuthServiceProvider');
-    });
-
-    it('validates provider requirement', () => {
-      expect(() => {
-        renderHook(() => useAuthService());
-      }).toThrow();
-    });
-  });
-
-  describe('Error Message Consistency', () => {
-    it('all hooks use consistent error message pattern', () => {
-      const errorMessages = [
-        'useEventService must be used within EventServiceProvider',
-        'useOrganisationService must be used within OrganisationServiceProvider',
-        'useInactivityService must be used within InactivityServiceProvider',
-        'useRBACService must be used within RBACServiceProvider',
-        'useAuthService must be used within AuthServiceProvider'
-      ];
-
-      errorMessages.forEach(msg => {
-        expect(msg).toMatch(/must be used within \w+Provider$/);
-      });
-    });
-  });
-
-  describe('Subscription Cleanup', () => {
-    it('service hooks handle subscription cleanup', () => {
-      // All service hooks use same pattern: subscribe in useEffect, return unsubscribe
-      const checkPattern = (hook: any) => {
-        // The pattern is: useEffect(() => { return context.service.subscribe(() => forceUpdate()); }, []);
-        expect(typeof hook).toBe('function');
-      };
-
-      checkPattern(useEventService);
-      checkPattern(useOrganisationService);
-      checkPattern(useInactivityService);
-      checkPattern(useRBACService);
-      checkPattern(useAuthService);
-    });
-  });
-});
-

package/src/hooks/services/usePermissions.ts

@@ -1,70 +0,0 @@
-/**
- * @file Permissions Convenience Hook
- * @package @jmruthers/pace-core
- * @module Hooks/Services
- * @since 0.1.0
- *
- * Convenience hook for permissions.
- * Returns just the permission state and methods needed by components.
- */
-
-import { useRBACService } from './useRBACService';
-import { AccessLevel } from '../../types/unified';
-
-export interface PermissionsState {
-  permissions: Record<string, boolean>;
-  roles: string[];
-  accessLevel: AccessLevel;
-  rbacLoading: boolean;
-  rbacError: Error | null;
-  selectedEventId: string | null;
-  appConfig: any | null;
-  userEventAccess: any[];
-  eventAccessLoading: boolean;
-  selectedOrganisationId: string | null;
-  
-  // Permission methods
-  hasPermission: (permission: string, orgId?: string) => boolean;
-  hasAnyPermission: (permissions: string[], orgId?: string) => boolean;
-  hasAllPermissions: (permissions: string[], orgId?: string) => boolean;
-  hasRole: (role: string) => boolean;
-  hasAccessLevel: (level: AccessLevel) => boolean;
-  canAccess: (resource: string, action: string, orgId?: string) => boolean;
-  validatePermission: (permission: string, orgId?: string) => Promise<boolean>;
-  validateAccess: (resource: string, action: string, orgId?: string) => Promise<boolean>;
-  refreshPermissions: (eventId?: string, orgId?: string) => Promise<void>;
-  setSelectedEventId: (eventId: string | null) => void;
-  loadUserEventAccess: (orgId?: string) => Promise<void>;
-  getUserEventAccess: (eventId: string) => any | undefined;
-  requireOrganisationContext: () => string;
-}
-
-export function usePermissions(): PermissionsState {
-  const rbacService = useRBACService();
-  
-  return {
-    permissions: rbacService.getPermissions(),
-    roles: rbacService.getRoles(),
-    accessLevel: rbacService.getAccessLevel(),
-    rbacLoading: rbacService.isLoading(),
-    rbacError: rbacService.getError(),
-    selectedEventId: rbacService.getSelectedEventId(),
-    appConfig: rbacService.getAppConfig(),
-    userEventAccess: rbacService.getUserEventAccess(),
-    eventAccessLoading: rbacService.isEventAccessLoading(),
-    selectedOrganisationId: rbacService.getSelectedOrganisationId(),
-    hasPermission: rbacService.hasPermission.bind(rbacService),
-    hasAnyPermission: rbacService.hasAnyPermission.bind(rbacService),
-    hasAllPermissions: rbacService.hasAllPermissions.bind(rbacService),
-    hasRole: rbacService.hasRole.bind(rbacService),
-    hasAccessLevel: rbacService.hasAccessLevel.bind(rbacService),
-    canAccess: rbacService.canAccess.bind(rbacService),
-    validatePermission: rbacService.validatePermission.bind(rbacService),
-    validateAccess: rbacService.validateAccess.bind(rbacService),
-    refreshPermissions: rbacService.refreshPermissions.bind(rbacService),
-    setSelectedEventId: rbacService.setSelectedEventId.bind(rbacService),
-    loadUserEventAccess: rbacService.loadUserEventAccess.bind(rbacService),
-    getUserEventAccess: rbacService.getUserEventAccess.bind(rbacService),
-    requireOrganisationContext: rbacService.requireOrganisationContext.bind(rbacService),
-  };
-}

package/src/hooks/services/useRBACService.ts

@@ -1,30 +0,0 @@
-/**
- * @file RBAC Service Hook
- * @package @jmruthers/pace-core
- * @module Hooks/Services
- * @since 0.1.0
- *
- * React hook for RBACService.
- * Provides RBAC service with reactive state updates.
- */
-
-import { useContext, useReducer, useEffect } from 'react';
-import { RBACServiceContext } from '../../providers/services/RBACServiceProvider';
-import { RBACService } from '../../services/RBACService';
-
-export function useRBACService(): RBACService {
-  const context = useContext(RBACServiceContext);
-  
-  if (!context) {
-    throw new Error('useRBACService must be used within RBACServiceProvider');
-  }
-  
-  // Subscribe to service state changes
-  const [, forceUpdate] = useReducer(x => x + 1, 0);
-  
-  useEffect(() => {
-    return context.rbacService.subscribe(() => forceUpdate());
-  }, [context.rbacService]);
-  
-  return context.rbacService;
-}

package/src/hooks/usePermissionCheck.ts

@@ -1,150 +0,0 @@
-/**
- * @file usePermissionCheck Hook
- * @package @jmruthers/pace-core
- * @module Hooks/PermissionCheck
- * @since 0.1.0
- *
- * A hook for checking user permissions that replaces dynamic imports
- * with a more testable and predictable pattern.
- */
-
-import { useCallback } from 'react';
-import { useUnifiedAuth } from '../providers/services/UnifiedAuthProvider';
-import { isSuperAdmin, isPermitted } from '../rbac/api';
-import type { Operation, Permission } from '../rbac/types';
-
-export interface PermissionCheckResult {
-  hasPermission: boolean;
-  isLoading: boolean;
-  error: Error | null;
-}
-
-export interface UsePermissionCheckOptions {
-  /** The operation to check (read, create, update, delete, manage) */
-  operation: Operation;
-  /** The page ID to check permissions for */
-  pageId?: string;
-  /** Whether to use cached results */
-  useCache?: boolean;
-}
-
-/**
- * Hook for checking user permissions
- * 
- * This hook replaces dynamic imports with a more testable pattern.
- * It uses the RBAC API functions directly, making it easier to mock in tests.
- * 
- * @param options - Permission check options
- * @returns Permission check result with loading and error states
- * 
- * @example
- * ```tsx
- * function MyComponent() {
- *   const { hasPermission, isLoading, error } = usePermissionCheck({
- *     operation: 'read',
- *     pageId: 'dashboard'
- *   });
- *   
- *   if (isLoading) return <div>Checking permissions...</div>;
- *   if (error) return <div>Error: {error.message}</div>;
- *   
- *   return hasPermission ? <Dashboard /> : <AccessDenied />;
- * }
- * ```
- */
-export function usePermissionCheck(options: UsePermissionCheckOptions): PermissionCheckResult {
-  const { operation, pageId, useCache = true } = options;
-  const { user, session, supabase, appName, selectedEvent, selectedOrganisation } = useUnifiedAuth();
-
-  const checkPermission = useCallback(async (): Promise<boolean> => {
-    try {
-      if (!user?.id) return false;
-      
-      const scope = {
-        organisationId: user.user_metadata?.organisationId || user.app_metadata?.organisationId,
-        eventId: user.user_metadata?.eventId || user.app_metadata?.eventId,
-        appId: user.user_metadata?.appId || user.app_metadata?.appId,
-      };
-      
-      // Check if user is super admin first - super admins can access everything
-      // regardless of organisation context
-      const isSuper = await isSuperAdmin(user.id);
-      
-      if (isSuper) {
-        // Super admin bypass - allow access regardless of organisation context
-        return true;
-      }
-      
-      // For non-super admins, ensure we have at least organisationId for RBAC
-      if (!scope.organisationId) {
-        console.warn('No organisation context available for permission check, denying access');
-        return false;
-      }
-      
-      return await isPermitted({
-        userId: user.id,
-        scope,
-        permission: operation as Permission,
-        pageId
-      });
-    } catch (error) {
-      console.error('Permission check failed:', error);
-      // Let the error bubble up so it can be handled by the calling code
-      throw error;
-    }
-  }, [user?.id, operation, pageId]);
-
-  return {
-    hasPermission: false, // This will be set by the calling component
-    isLoading: false, // This will be set by the calling component
-    error: null // This will be set by the calling component
-  };
-}
-
-/**
- * Hook for checking multiple permissions
- * 
- * @param permissions - Array of permission checks
- * @returns Array of permission check results
- */
-export function useMultiplePermissionChecks(
-  permissions: UsePermissionCheckOptions[]
-): PermissionCheckResult[] {
-  return permissions.map(options => usePermissionCheck(options));
-}
-
-/**
- * Hook for checking if user has any of the specified permissions
- * 
- * @param permissions - Array of permission checks
- * @returns Whether user has any of the permissions
- */
-export function useHasAnyPermission(
-  permissions: UsePermissionCheckOptions[]
-): PermissionCheckResult {
-  // This would need to be implemented with proper state management
-  // For now, return a placeholder
-  return {
-    hasPermission: false,
-    isLoading: false,
-    error: null
-  };
-}
-
-/**
- * Hook for checking if user has all of the specified permissions
- * 
- * @param permissions - Array of permission checks
- * @returns Whether user has all of the permissions
- */
-export function useHasAllPermissions(
-  permissions: UsePermissionCheckOptions[]
-): PermissionCheckResult {
-  // This would need to be implemented with proper state management
-  // For now, return a placeholder
-  return {
-    hasPermission: false,
-    isLoading: false,
-    error: null
-  };
-}