@jmruthers/pace-core 0.5.117 → 0.5.119

package/src/hooks/__tests__/useToast.unit.test.tsx

@@ -1,62 +1,463 @@
+/**
+ * @file useToast Hook Unit Tests
+ * @package @jmruthers/pace-core
+ * @module Hooks/__tests__/useToast
+ * @since 0.1.0
+ * 
+ * Comprehensive tests for the useToast hook covering all critical functionality.
+ */
 
-import { renderHook, act } from '@testing-library/react';
-import { describe, it, expect, beforeEach } from 'vitest';
-import { useToast, reset } from '../useToast';
+import { renderHook, act, waitFor } from '@testing-library/react';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { useToast, reset, toast } from '../useToast';
+
+const TOAST_REMOVE_DELAY = 1000;
+const DEFAULT_TOAST_DURATION = 10000;
 
 describe('useToast', () => {
   beforeEach(() => {
+    vi.useFakeTimers();
     reset();
   });
 
-  it('should add a toast', () => {
-    const { result } = renderHook(() => useToast());
+  afterEach(() => {
+    vi.clearAllTimers();
+    vi.useRealTimers();
+  });
+
+  describe('Toast Creation', () => {
+    it('adds a toast with title and description', () => {
+      const { result } = renderHook(() => useToast());
 
-    act(() => {
-      result.current.toast({
+      act(() => {
+        result.current.toast({
+          title: 'Test Toast',
+          description: 'This is a test toast',
+        });
+      });
+
+      expect(result.current.toasts).toHaveLength(1);
+      expect(result.current.toasts[0]).toMatchObject({
         title: 'Test Toast',
         description: 'This is a test toast',
+        open: true,
+      });
+    });
+
+    it('adds a toast with default duration', () => {
+      const { result } = renderHook(() => useToast());
+
+      act(() => {
+        result.current.toast({
+          title: 'Test Toast',
+        });
+      });
+
+      expect(result.current.toasts[0].duration).toBe(DEFAULT_TOAST_DURATION);
+    });
+
+    it('ignores custom duration and uses default', () => {
+      const { result } = renderHook(() => useToast());
+
+      act(() => {
+        // Even if duration is provided, it should be ignored
+        result.current.toast({
+          title: 'Test Toast',
+          // @ts-expect-error - duration should not be in props
+          duration: 5000,
+        });
+      });
+
+      expect(result.current.toasts[0].duration).toBe(DEFAULT_TOAST_DURATION);
+    });
+
+    it('adds toast with variant', () => {
+      const { result } = renderHook(() => useToast());
+
+      act(() => {
+        result.current.toast({
+          title: 'Success Toast',
+          variant: 'success',
+        });
       });
+
+      expect(result.current.toasts[0].variant).toBe('success');
     });
 
-    expect(result.current.toasts).toHaveLength(1);
-    expect(result.current.toasts[0]).toMatchObject({
-      title: 'Test Toast',
-      description: 'This is a test toast',
+    it('adds toast with action', () => {
+      const { result } = renderHook(() => useToast());
+      const actionButton = <button>Action</button>;
+
+      act(() => {
+        result.current.toast({
+          title: 'Test Toast',
+          action: actionButton,
+        });
+      });
+
+      expect(result.current.toasts[0].action).toBe(actionButton);
     });
   });
 
-  it('should dismiss a toast', () => {
-    const { result } = renderHook(() => useToast());
+  describe('Toast Dismissal', () => {
+    it('dismisses a toast using dismiss function', () => {
+      const { result } = renderHook(() => useToast());
 
-    let dismissFn: (() => void) | undefined;
+      let dismissFn: (() => void) | undefined;
 
-    act(() => {
-      const response = result.current.toast({
-        title: 'Test Toast',
+      act(() => {
+        const response = result.current.toast({
+          title: 'Test Toast',
+        });
+        dismissFn = response.dismiss;
+      });
+
+      expect(result.current.toasts).toHaveLength(1);
+      expect(result.current.toasts[0].open).toBe(true);
+
+      act(() => {
+        dismissFn?.();
       });
-      dismissFn = response.dismiss;
+
+      expect(result.current.toasts[0].open).toBe(false);
     });
 
-    expect(result.current.toasts).toHaveLength(1);
+    it('dismisses a toast using dismiss method with toast ID', () => {
+      const { result } = renderHook(() => useToast());
+
+      let toastId: string | undefined;
 
-    act(() => {
-      dismissFn?.();
+      act(() => {
+        const response = result.current.toast({
+          title: 'Test Toast',
+        });
+        toastId = response.id;
+      });
+
+      expect(result.current.toasts[0].open).toBe(true);
+
+      act(() => {
+        result.current.dismiss(toastId);
+      });
+
+      expect(result.current.toasts[0].open).toBe(false);
     });
 
-    expect(result.current.toasts[0].open).toBe(false);
-  });
+    it('dismisses all toasts when no ID provided', () => {
+      const { result } = renderHook(() => useToast());
 
-  it('should limit the number of toasts', () => {
-    const { result } = renderHook(() => useToast());
+      act(() => {
+        result.current.toast({ title: 'Toast 1' });
+        result.current.toast({ title: 'Toast 2' });
+        result.current.toast({ title: 'Toast 3' });
+      });
+
+      expect(result.current.toasts).toHaveLength(3);
+      expect(result.current.toasts.every(t => t.open)).toBe(true);
+
+      act(() => {
+        result.current.dismiss();
+      });
+
+      expect(result.current.toasts.every(t => !t.open)).toBe(true);
+    });
 
-    act(() => {
-      for (let i = 0; i < 10; i++) {
+    it('calls onOpenChange handler when open changes', () => {
+      const { result } = renderHook(() => useToast());
+      const onOpenChange = vi.fn();
+
+      act(() => {
         result.current.toast({
-          title: `Toast ${i}`,
+          title: 'Test Toast',
+          onOpenChange,
+        });
+      });
+
+      act(() => {
+        result.current.toasts[0].onOpenChange?.(false);
+      });
+
+      expect(onOpenChange).toHaveBeenCalledWith(false);
+      expect(result.current.toasts[0].open).toBe(false);
+    });
+
+    it('removes toast after delay when dismissed', async () => {
+      const { result } = renderHook(() => useToast());
+
+      let toastId: string | undefined;
+
+      act(() => {
+        const response = result.current.toast({
+          title: 'Test Toast',
+        });
+        toastId = response.id;
+      });
+
+      expect(result.current.toasts).toHaveLength(1);
+
+      act(() => {
+        result.current.dismiss(toastId);
+      });
+
+      expect(result.current.toasts[0].open).toBe(false);
+      expect(result.current.toasts).toHaveLength(1); // Still in array
+
+      // Advance time past removal delay
+      act(() => {
+        vi.advanceTimersByTime(TOAST_REMOVE_DELAY);
+      });
+
+      await waitFor(() => {
+        expect(result.current.toasts).toHaveLength(0);
+      }, { timeout: 100 });
+    });
+
+    it('does not remove toast if already in remove queue', () => {
+      const { result } = renderHook(() => useToast());
+
+      let toastId: string | undefined;
+
+      act(() => {
+        const response = result.current.toast({
+          title: 'Test Toast',
+        });
+        toastId = response.id;
+      });
+
+      act(() => {
+        result.current.dismiss(toastId);
+      });
+
+      // Try to dismiss again
+      act(() => {
+        result.current.dismiss(toastId);
+      });
+
+      // Should still only have one toast
+      expect(result.current.toasts).toHaveLength(1);
+    });
+  });
+
+  describe('Toast Updates', () => {
+    it('updates a toast with new properties', () => {
+      const { result } = renderHook(() => useToast());
+
+      let toastId: string | undefined;
+      let updateFn: ((props: any) => void) | undefined;
+
+      act(() => {
+        const response = result.current.toast({
+          title: 'Original Title',
+          description: 'Original Description',
+        });
+        toastId = response.id;
+        updateFn = response.update;
+      });
+
+      expect(result.current.toasts[0].title).toBe('Original Title');
+      expect(result.current.toasts[0].description).toBe('Original Description');
+
+      act(() => {
+        updateFn?.({
+          title: 'Updated Title',
+          description: 'Updated Description',
+        });
+      });
+
+      expect(result.current.toasts[0].title).toBe('Updated Title');
+      expect(result.current.toasts[0].description).toBe('Updated Description');
+      expect(result.current.toasts[0].id).toBe(toastId);
+      expect(result.current.toasts[0].duration).toBe(DEFAULT_TOAST_DURATION);
+    });
+
+    it('updates toast variant', () => {
+      const { result } = renderHook(() => useToast());
+
+      let updateFn: ((props: any) => void) | undefined;
+
+      act(() => {
+        const response = result.current.toast({
+          title: 'Test Toast',
+          variant: 'default',
+        });
+        updateFn = response.update;
+      });
+
+      expect(result.current.toasts[0].variant).toBe('default');
+
+      act(() => {
+        updateFn?.({
+          variant: 'destructive',
+        });
+      });
+
+      expect(result.current.toasts[0].variant).toBe('destructive');
+    });
+  });
+
+  describe('Toast Limits', () => {
+    it('limits toasts to maximum of 5', () => {
+      const { result } = renderHook(() => useToast());
+
+      act(() => {
+        for (let i = 0; i < 10; i++) {
+          result.current.toast({
+            title: `Toast ${i}`,
+          });
+        }
+      });
+
+      expect(result.current.toasts.length).toBeLessThanOrEqual(5);
+      expect(result.current.toasts.length).toBe(5);
+    });
+
+    it('keeps newest toasts when limit exceeded', () => {
+      const { result } = renderHook(() => useToast());
+
+      act(() => {
+        for (let i = 0; i < 7; i++) {
+          result.current.toast({
+            title: `Toast ${i}`,
+          });
+        }
+      });
+
+      expect(result.current.toasts.length).toBe(5);
+      // Should keep the last 5 (toasts 2-6)
+      expect(result.current.toasts[0].title).toBe('Toast 6');
+      expect(result.current.toasts[4].title).toBe('Toast 2');
+    });
+  });
+
+  describe('Direct Toast Function', () => {
+    it('creates toast using direct toast function', () => {
+      const { result } = renderHook(() => useToast());
+
+      act(() => {
+        toast({
+          title: 'Direct Toast',
         });
-      }
+      });
+
+      expect(result.current.toasts).toHaveLength(1);
+      expect(result.current.toasts[0].title).toBe('Direct Toast');
     });
+  });
+
+  describe('Reset Function', () => {
+    it('resets all toasts and clears timeouts', () => {
+      const { result } = renderHook(() => useToast());
 
-    expect(result.current.toasts.length).toBeLessThanOrEqual(5);
+      act(() => {
+        result.current.toast({ title: 'Toast 1' });
+        result.current.toast({ title: 'Toast 2' });
+      });
+
+      expect(result.current.toasts).toHaveLength(2);
+
+      act(() => {
+        reset();
+      });
+
+      // Create new hook instance to verify reset cleared global state
+      const { result: result2 } = renderHook(() => useToast());
+      expect(result2.current.toasts).toHaveLength(0);
+    });
+  });
+
+  describe('Multiple Hook Instances', () => {
+    it('shares state between multiple hook instances', () => {
+      const { result: result1 } = renderHook(() => useToast());
+      const { result: result2 } = renderHook(() => useToast());
+
+      act(() => {
+        result1.current.toast({
+          title: 'Toast from instance 1',
+        });
+      });
+
+      expect(result1.current.toasts).toHaveLength(1);
+      expect(result2.current.toasts).toHaveLength(1);
+      expect(result2.current.toasts[0].title).toBe('Toast from instance 1');
+    });
+  });
+
+  describe('Remove Queue', () => {
+    it('removes toast by ID after delay', async () => {
+      const { result } = renderHook(() => useToast());
+
+      let toastId: string | undefined;
+
+      act(() => {
+        const response = result.current.toast({
+          title: 'Test Toast',
+        });
+        toastId = response.id;
+      });
+
+      expect(result.current.toasts).toHaveLength(1);
+
+      act(() => {
+        result.current.dismiss(toastId);
+      });
+
+      expect(result.current.toasts[0].open).toBe(false);
+      expect(result.current.toasts).toHaveLength(1); // Still in array
+
+      // Advance time past removal delay - this should trigger the setTimeout callback
+      act(() => {
+        vi.advanceTimersByTime(TOAST_REMOVE_DELAY);
+      });
+
+      // The setTimeout callback should have fired and dispatched REMOVE_TOAST
+      // Wait for React to process the state update
+      await waitFor(() => {
+        expect(result.current.toasts).toHaveLength(0);
+      }, { timeout: 200 });
+    });
+
+    it('dismisses all toasts when toastId is undefined', async () => {
+      const { result } = renderHook(() => useToast());
+
+      let toastId1: string | undefined;
+      let toastId2: string | undefined;
+
+      act(() => {
+        const response1 = result.current.toast({ title: 'Toast 1' });
+        const response2 = result.current.toast({ title: 'Toast 2' });
+        toastId1 = response1.id;
+        toastId2 = response2.id;
+      });
+
+      expect(result.current.toasts).toHaveLength(2);
+
+      // Dismiss all - this sets all toasts to open: false but doesn't add them to remove queue
+      act(() => {
+        result.current.dismiss(); // Dismiss all
+      });
+
+      expect(result.current.toasts.every(t => !t.open)).toBe(true);
+      expect(result.current.toasts).toHaveLength(2); // Still in array (not removed yet)
+
+      // Note: When dismissing all (toastId undefined), individual toasts are NOT added to remove queue
+      // They remain in the array but are closed. To actually remove them, we need to dismiss individually
+      // or wait for their auto-dismiss timers (if they have them)
+      
+      // Test that dismissing individually removes them
+      act(() => {
+        result.current.dismiss(toastId1);
+        result.current.dismiss(toastId2);
+      });
+
+      // Advance time past removal delay
+      act(() => {
+        vi.advanceTimersByTime(TOAST_REMOVE_DELAY);
+      });
+
+      // Wait for state update
+      await waitFor(() => {
+        expect(result.current.toasts).toHaveLength(0);
+      }, { timeout: 200 });
+    });
   });
 });

package/src/hooks/useSecureDataAccess.test.ts

@@ -303,6 +303,7 @@ describe('useSecureDataAccess', () => {
       
       expect(freshMockSupabase.rpc).toHaveBeenCalledWith('get_user_data', {
         user_id: 'user-123',
+        p_user_id: 'user-123',
         organisation_id: 'org-123'
       });
     });

package/src/hooks/useSecureDataAccess.ts

@@ -507,15 +507,53 @@ export function useSecureDataAccess(): SecureDataAccessReturn {
       'app_cake_delivery_upsert'
     ];
     
-    const secureParams = {
-      ...params,
-      [paramName]: organisationId
-    };
+    // Build secureParams with correct parameter order
+    // For functions that require p_event_id as first parameter, ensure it's first
+    const secureParams: Record<string, any> = {};
+    
+    // Functions where p_event_id is the FIRST required parameter (no default)
+    const functionsWithEventIdFirst = [
+      'data_cake_meals_list',
+      'data_cake_units_list'
+    ];
+    
+    // Add p_user_id explicitly for functions that need it (even though it has a default)
+    // This ensures parameter matching works correctly
+    if (user?.id) {
+      secureParams.p_user_id = user.id;
+    }
+    
+    // Add organisation_id parameter
+    secureParams[paramName] = organisationId;
     
     // Add p_event_id if function needs it and event is selected
+    // CRITICAL: This must be added AFTER organisation_id but BEFORE caller params
+    // to ensure it's not overwritten. For data_cake_items_list, p_event_id is the 3rd param.
     if (functionsNeedingEventId.includes(functionName) && selectedEvent?.event_id) {
       secureParams.p_event_id = selectedEvent.event_id;
     }
+    
+    // Add any other params passed by caller (limit, offset, etc.)
+    // NOTE: This will NOT overwrite p_event_id if caller passes it, but we want to ensure
+    // our value takes precedence if event is selected
+    Object.assign(secureParams, params);
+    
+    // Ensure p_event_id is set if needed (after Object.assign, so it overrides caller params)
+    if (functionsNeedingEventId.includes(functionName) && selectedEvent?.event_id) {
+      secureParams.p_event_id = selectedEvent.event_id;
+    }
+
+    // Debug logging for items list to help diagnose issues
+    if (functionName === 'data_cake_items_list') {
+      console.log('[useSecureDataAccess] Calling data_cake_items_list with params:', {
+        p_user_id: secureParams.p_user_id,
+        p_organisation_id: secureParams.organisation_id || secureParams.p_organisation_id,
+        p_event_id: secureParams.p_event_id,
+        hasEvent: !!selectedEvent?.event_id,
+        eventId: selectedEvent?.event_id,
+        allParams: secureParams
+      });
+    }
 
     const { data, error } = await supabase!.rpc(functionName, secureParams);
 
@@ -529,7 +567,7 @@ export function useSecureDataAccess(): SecureDataAccessReturn {
     });
 
     return data as T;
-  }, [validateContext, getCurrentOrganisationId, setOrganisationContextInSession, supabase, selectedEvent?.event_id]);
+  }, [validateContext, getCurrentOrganisationId, setOrganisationContextInSession, supabase, selectedEvent?.event_id, user?.id]);
 
   // NEW: Phase 1 - Enhanced Security Features
   const [dataAccessHistory, setDataAccessHistory] = useState<DataAccessRecord[]>([]);