@jmruthers/pace-core 0.5.186 → 0.5.188

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

@@ -19,6 +19,7 @@ vi.mock('../../hooks/useOrganisations', () => ({
 // Mock the RBAC API
 vi.mock('../../rbac/api', () => ({
   isPermitted: vi.fn(),
+  isPermittedCached: vi.fn(),
   getPermissionMap: vi.fn(),
   emitAuditEvent: vi.fn()
 }));
@@ -451,8 +452,8 @@ describe('useOrganisationSecurity', () => {
       const mockOrg = { id: 'org-123' };
 
       // Mock the RBAC API
-      const { isPermitted } = await import('../../rbac/api');
-      vi.mocked(isPermitted).mockResolvedValue(true);
+      const { isPermittedCached } = await import('../../rbac/api');
+      vi.mocked(isPermittedCached).mockResolvedValue(true);
       
       vi.mocked(useUnifiedAuth).mockReturnValue({
         ...mockUseUnifiedAuth,
@@ -469,7 +470,7 @@ describe('useOrganisationSecurity', () => {
       const hasPermission = await result.current.hasPermission('view_basic');
 
       expect(hasPermission).toBe(true);
-      expect(isPermitted).toHaveBeenCalledWith({
+      expect(isPermittedCached).toHaveBeenCalledWith({
         userId: 'user-123',
         scope: {
           organisationId: 'org-123',
@@ -485,8 +486,8 @@ describe('useOrganisationSecurity', () => {
       const mockOrg = { id: 'org-123' };
 
       // Mock the RBAC API to throw an error
-      const { isPermitted } = await import('../../rbac/api');
-      vi.mocked(isPermitted).mockRejectedValue(new Error('RBAC API error'));
+      const { isPermittedCached } = await import('../../rbac/api');
+      vi.mocked(isPermittedCached).mockRejectedValue(new Error('RBAC API error'));
       
       vi.mocked(useUnifiedAuth).mockReturnValue({
         ...mockUseUnifiedAuth,
@@ -510,8 +511,8 @@ describe('useOrganisationSecurity', () => {
       const mockOrg = { id: 'org-123' };
 
       // Mock the RBAC API to throw an error
-      const { isPermitted } = await import('../../rbac/api');
-      vi.mocked(isPermitted).mockImplementation(() => {
+      const { isPermittedCached } = await import('../../rbac/api');
+      vi.mocked(isPermittedCached).mockImplementation(() => {
         throw new Error('RBAC API exception');
       });
       
@@ -536,8 +537,8 @@ describe('useOrganisationSecurity', () => {
       const mockUser = { id: 'user-123', user_metadata: { eventId: 'event-123', appId: 'app-123' } };
 
       // Mock the RBAC API
-      const { isPermitted } = await import('../../rbac/api');
-      vi.mocked(isPermitted).mockResolvedValue(true);
+      const { isPermittedCached } = await import('../../rbac/api');
+      vi.mocked(isPermittedCached).mockResolvedValue(true);
       
       vi.mocked(useUnifiedAuth).mockReturnValue({
         ...mockUseUnifiedAuth,
@@ -549,7 +550,7 @@ describe('useOrganisationSecurity', () => {
 
       await result.current.hasPermission('view_basic', 'org-456');
 
-      expect(isPermitted).toHaveBeenCalledWith({
+      expect(isPermittedCached).toHaveBeenCalledWith({
         userId: 'user-123',
         scope: {
           organisationId: 'org-456',

package/src/hooks/__tests__/usePublicFileDisplay.test.ts

@@ -21,9 +21,20 @@ import type { Database } from '../../types/database';
 import type { FileCategory } from '../../types/file-reference';
 import { FileCategory as FileCategoryEnum } from '../../types/file-reference';
 
-// Mock getPublicUrl
+// Mock getPublicUrl and generateFileUrlsBatch
 vi.mock('../../utils/storage/helpers', () => ({
-  getPublicUrl: vi.fn((supabase: any, path: string) => `https://example.com/${path}`)
+  getPublicUrl: vi.fn((supabase: any, path: string) => `https://example.com/${path}`),
+  generateFileUrlsBatch: vi.fn().mockImplementation(async (supabase, files) => {
+    const urlMap = new Map<string, string>();
+    for (const file of files) {
+      if (file.is_public) {
+        urlMap.set(file.id, `https://example.com/${file.file_path}`);
+      } else {
+        urlMap.set(file.id, `https://example.com/signed/${file.file_path}`);
+      }
+    }
+    return urlMap;
+  })
 }));
 
 // Mock logger
@@ -36,7 +47,7 @@ vi.mock('../../utils/core/logger', () => ({
   },
 }));
 
-import { getPublicUrl } from '../../utils/storage/helpers';
+import { getPublicUrl, generateFileUrlsBatch } from '../../utils/storage/helpers';
 
 describe('usePublicFileDisplay Hook', () => {
   let mockSupabase: SupabaseClient<Database>;
@@ -61,6 +72,19 @@ describe('usePublicFileDisplay Hook', () => {
     vi.clearAllMocks();
     clearPublicFileDisplayCache();
     mockSupabase = createMockSupabaseClient() as any;
+    
+    // Reset generateFileUrlsBatch mock to ensure it returns a Map
+    vi.mocked(generateFileUrlsBatch).mockImplementation(async (supabase, files) => {
+      const urlMap = new Map<string, string>();
+      for (const file of files) {
+        if (file.is_public) {
+          urlMap.set(file.id, `https://example.com/${file.file_path}`);
+        } else {
+          urlMap.set(file.id, `https://example.com/signed/${file.file_path}`);
+        }
+      }
+      return urlMap;
+    });
   });
 
   afterEach(() => {
@@ -256,13 +280,14 @@ describe('usePublicFileDisplay Hook', () => {
       await waitFor(
         () => {
           expect(result.current.isLoading).toBe(false);
+          expect(result.current.fileCount).toBe(2);
+          expect(result.current.fileReferences.length).toBe(2);
+          expect(result.current.fileUrls).toBeDefined();
+          expect(result.current.fileUrls.size).toBe(2);
         },
         { timeout: 2000 }
       );
 
-      expect(result.current.fileCount).toBe(2);
-      expect(result.current.fileReferences.length).toBe(2);
-      expect(result.current.fileUrls.size).toBe(2);
       expect(result.current.fileUrls.get('file-123')).toBe('https://example.com/org-123/logos/logo.png');
       expect(result.current.fileUrls.get('file-456')).toBe('https://example.com/org-123/logos/logo2.png');
       expect(result.current.fileUrl).toBe(null); // No single file URL in multiple mode

package/src/hooks/index.ts

@@ -28,6 +28,8 @@ export { useEventTheme } from './useEventTheme';
 // === DATA & STATE HOOKS ===
 export { useDebounce } from './useDebounce';
 export { useDataTableState } from './useDataTableState';
+export { useAddressAutocomplete } from './useAddressAutocomplete';
+export type { UseAddressAutocompleteOptions, UseAddressAutocompleteReturn } from './useAddressAutocomplete';
 
 // === ORGANISATION HOOKS ===
 export { useOrganisationPermissions } from './useOrganisationPermissions';
@@ -48,6 +50,8 @@ export { useComponentPerformance } from './useComponentPerformance';
 export { useAppConfig } from './useAppConfig';
 export type { UseAppConfigReturn } from './useAppConfig';
 export { usePerformanceMonitor } from './usePerformanceMonitor';
+export { useQueryCache, queryCacheHelpers } from './useQueryCache';
+export type { UseQueryCacheReturn, UseQueryCacheOptions } from './useQueryCache';
 
 // DataTable performance hook
 export { useDataTablePerformance } from './useDataTablePerformance';
@@ -56,6 +60,8 @@ export type { UseDataTablePerformanceOptions, UseDataTablePerformanceReturn } fr
 // === FILE DISPLAY HOOKS ===
 export { useFileDisplay, clearFileDisplayCache, getFileDisplayCacheStats, invalidateFileDisplayCache } from './useFileDisplay';
 export type { UseFileDisplayReturn, UseFileDisplayOptions } from './useFileDisplay';
+export { useFileUrlCache } from './useFileUrlCache';
+export type { UseFileUrlCacheReturn } from './useFileUrlCache';
 
 // === STORAGE HOOKS ===
 export { useStorage, useFileUpload } from './useStorage';

package/src/hooks/public/usePublicFileDisplay.ts

@@ -40,7 +40,7 @@ import { useState, useEffect, useCallback } from 'react';
 import type { SupabaseClient } from '@supabase/supabase-js';
 import type { Database } from '../../types/database';
 import { FileReference, FileCategory } from '../../types/file-reference';
-import { getPublicUrl } from '../../utils/storage/helpers';
+import { getPublicUrl, generateFileUrlsBatch } from '../../utils/storage/helpers';
 import { logger } from '../../utils/core/logger';
 
 // Simple in-memory cache for public file data
@@ -236,7 +236,7 @@ export function usePublicFileDisplay(
           const ids = fileIds.map((item: any) => item.id);
           const { data: fullData, error: fetchError } = await supabase
             .from('file_references')
-            .select('*')
+            .select('id, table_name, record_id, file_path, file_metadata, organisation_id, app_id, is_public, created_at, updated_at')
             .in('id', ids)
             .eq('is_public', true); // Only public files in public context
 
@@ -295,14 +295,12 @@ export function usePublicFileDisplay(
         const url = getPublicUrl(supabase, firstFile.file_path, true);
         setFileUrl(url);
       } else {
-        // Multiple files mode - generate URLs for all files
-        const urlMap = new Map<string, string>();
-        for (const fileRef of fileRefs) {
-          const url = getPublicUrl(supabase, fileRef.file_path, true);
-          if (url) {
-            urlMap.set(fileRef.id, url);
-          }
-        }
+        // Multiple files mode - generate URLs for all files in batch
+        const urlMap = await generateFileUrlsBatch(supabase, fileRefs, {
+          appName: 'pace-core',
+          orgId: organisation_id,
+          expiresIn: 3600
+        });
         setFileUrls(urlMap);
         setFileReference(null);
         setFileUrl(null);

package/src/hooks/useAddressAutocomplete.test.ts

@@ -0,0 +1,318 @@
+/**
+ * @file Address Autocomplete Hook Tests
+ * @package @jmruthers/pace-core
+ * @module Hooks/__tests__
+ * @since 0.1.0
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { renderHook, waitFor } from '@testing-library/react';
+import { useAddressAutocomplete } from './useAddressAutocomplete';
+import * as googlePlacesUtils from '../utils/google-places';
+
+// Mock the Google Places utilities
+vi.mock('../utils/google-places', () => ({
+  fetchPlaceAutocomplete: vi.fn(),
+  fetchPlaceDetails: vi.fn(),
+  createAddressFromPlaceResult: vi.fn(),
+  getAddressByPlaceId: vi.fn(),
+}));
+
+// Mock useQueryCache
+vi.mock('./useQueryCache', () => ({
+  useQueryCache: () => ({
+    getCachedQuery: async <T,>(_table: string, _filterKey: string, _filterValue: string, fetchFn: () => Promise<T>) => {
+      return fetchFn();
+    },
+  }),
+}));
+
+// Mock useDebounce to return value immediately for tests
+vi.mock('./useDebounce', () => ({
+  useDebounce: (value: any, _delay: number) => value,
+}));
+
+describe('useAddressAutocomplete', () => {
+  const mockApiKey = 'test-api-key';
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    vi.useRealTimers();
+  });
+
+  describe('Initial state', () => {
+    it('returns initial state with empty suggestions', () => {
+      const { result } = renderHook(() => useAddressAutocomplete(mockApiKey, ''));
+
+      expect(result.current.suggestions).toEqual([]);
+      expect(result.current.isLoading).toBe(false);
+      expect(result.current.error).toBeNull();
+    }, { timeout: 5000 });
+  });
+
+  describe('Autocomplete suggestions', () => {
+    it('fetches suggestions when input value changes', async () => {
+      const mockPredictions = [
+        {
+          description: '123 Main St, Melbourne VIC, Australia',
+          place_id: 'ChIJ123',
+          structured_formatting: {
+            main_text: '123 Main St',
+            secondary_text: 'Melbourne VIC, Australia',
+          },
+        },
+      ];
+
+      vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockResolvedValueOnce(mockPredictions);
+
+      const { result } = renderHook(() =>
+        useAddressAutocomplete(mockApiKey, '123 Main', { debounceDelay: 0 })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.suggestions).toHaveLength(1);
+        },
+        { timeout: 1000 }
+      );
+
+      expect(result.current.suggestions[0].place_id).toBe('ChIJ123');
+    }, { timeout: 5000 });
+
+    it('debounces input value', async () => {
+      vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockResolvedValue([]);
+
+      // Since we're mocking useDebounce to return immediately, this test verifies
+      // that the hook still works correctly with rapid input changes
+      const { result, rerender } = renderHook(
+        ({ inputValue }) => useAddressAutocomplete(mockApiKey, inputValue, { debounceDelay: 0 }),
+        { initialProps: { inputValue: '123' } }
+      );
+
+      // Change input quickly - with mocked debounce, each change triggers immediately
+      rerender({ inputValue: '123 M' });
+      rerender({ inputValue: '123 Ma' });
+      rerender({ inputValue: '123 Main' });
+
+      // Wait for the last call
+      await waitFor(
+        () => {
+          expect(googlePlacesUtils.fetchPlaceAutocomplete).toHaveBeenCalled();
+        },
+        { timeout: 1000 }
+      );
+
+      // With mocked debounce, it will be called for each change
+      expect(googlePlacesUtils.fetchPlaceAutocomplete).toHaveBeenCalled();
+    }, { timeout: 5000 });
+
+    it('clears suggestions when input is empty', async () => {
+      vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockResolvedValueOnce([
+        { description: '123 Main St', place_id: 'ChIJ123' },
+      ]);
+
+      const { result, rerender } = renderHook(
+        ({ inputValue }) => useAddressAutocomplete(mockApiKey, inputValue, { debounceDelay: 0 }),
+        { initialProps: { inputValue: '123 Main' } }
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.suggestions).toBeDefined();
+          expect(result.current.suggestions.length).toBeGreaterThan(0);
+        },
+        { timeout: 1000 }
+      );
+
+      rerender({ inputValue: '' });
+
+      await waitFor(
+        () => {
+          expect(result.current.suggestions).toBeDefined();
+          expect(result.current.suggestions).toEqual([]);
+        },
+        { timeout: 1000 }
+      );
+    }, { timeout: 5000 });
+
+    it('handles API errors', async () => {
+      const error = new Error('API request denied');
+      vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockRejectedValueOnce(error);
+
+      const { result } = renderHook(() =>
+        useAddressAutocomplete(mockApiKey, '123 Main', { debounceDelay: 0 })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.error).not.toBeNull();
+        },
+        { timeout: 1000 }
+      );
+
+      expect(result.current.error?.message).toBe('API request denied');
+      expect(result.current.suggestions).toEqual([]);
+    }, { timeout: 5000 });
+  });
+
+  describe('Address selection', () => {
+    it('selects address by place_id', async () => {
+      const mockPlaceDetails = {
+        place_id: 'ChIJ123',
+        formatted_address: '123 Main St, Melbourne VIC 3000, Australia',
+        address_components: [],
+        geometry: { location: { lat: -37.8136, lng: 144.9631 } },
+      };
+
+      const mockParsedAddress = {
+        place_id: 'ChIJ123',
+        full_address: '123 Main St, Melbourne VIC 3000, Australia',
+        street_number: null,
+        route: null,
+        suburb: null,
+        state: null,
+        postcode: null,
+        country: null,
+        lat: -37.8136,
+        lng: 144.9631,
+      };
+
+      vi.mocked(googlePlacesUtils.fetchPlaceDetails).mockResolvedValueOnce(mockPlaceDetails);
+      vi.mocked(googlePlacesUtils.createAddressFromPlaceResult).mockReturnValueOnce(mockParsedAddress);
+
+      const { result } = renderHook(() => useAddressAutocomplete(mockApiKey, ''));
+
+      const address = await result.current.selectAddress('ChIJ123');
+
+      expect(address).not.toBeNull();
+      expect(address?.place_id).toBe('ChIJ123');
+      expect(googlePlacesUtils.fetchPlaceDetails).toHaveBeenCalledWith('ChIJ123', mockApiKey);
+    }, { timeout: 5000 });
+
+    it('returns null when place_id is invalid', async () => {
+      vi.mocked(googlePlacesUtils.fetchPlaceDetails).mockRejectedValueOnce(new Error('Place not found'));
+
+      const { result } = renderHook(() => useAddressAutocomplete(mockApiKey, ''));
+
+      const address = await result.current.selectAddress('invalid');
+
+      expect(address).toBeNull();
+    });
+  });
+
+  describe('getAddressByPlaceId', () => {
+    it('retrieves address by place_id', async () => {
+      const mockAddress = {
+        place_id: 'ChIJ123',
+        full_address: '123 Main St',
+        street_number: null,
+        route: null,
+        suburb: null,
+        state: null,
+        postcode: null,
+        country: null,
+        lat: null,
+        lng: null,
+      };
+
+      vi.mocked(googlePlacesUtils.getAddressByPlaceId).mockResolvedValueOnce(mockAddress);
+
+      const { result } = renderHook(() => useAddressAutocomplete(mockApiKey, ''));
+
+      const address = await result.current.getAddressByPlaceId('ChIJ123');
+
+      expect(address).not.toBeNull();
+      expect(address?.place_id).toBe('ChIJ123');
+    }, { timeout: 5000 });
+
+    it('returns null on error', async () => {
+      vi.mocked(googlePlacesUtils.getAddressByPlaceId).mockResolvedValueOnce(null);
+
+      const { result } = renderHook(() => useAddressAutocomplete(mockApiKey, ''));
+
+      const address = await result.current.getAddressByPlaceId('invalid');
+
+      expect(address).toBeNull();
+    }, { timeout: 5000 });
+  });
+
+  describe('clearSuggestions', () => {
+    it('clears suggestions', async () => {
+      vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockResolvedValueOnce([
+        { description: '123 Main St', place_id: 'ChIJ123' },
+      ]);
+
+      const { result } = renderHook(() =>
+        useAddressAutocomplete(mockApiKey, '123 Main', { debounceDelay: 0 })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.suggestions).toBeDefined();
+          expect(result.current.suggestions.length).toBeGreaterThan(0);
+        },
+        { timeout: 1000 }
+      );
+
+      result.current.clearSuggestions();
+
+      // Wait for state update
+      await waitFor(
+        () => {
+          expect(result.current.suggestions).toEqual([]);
+          expect(result.current.error).toBeNull();
+        },
+        { timeout: 1000 }
+      );
+    }, { timeout: 5000 });
+  });
+
+  describe('Caching', () => {
+    it('uses cache when enabled', async () => {
+      const mockPredictions = [{ description: '123 Main St', place_id: 'ChIJ123' }];
+      vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockResolvedValueOnce(mockPredictions);
+
+      const { result } = renderHook(() =>
+        useAddressAutocomplete(mockApiKey, '123 Main', {
+          debounceDelay: 0,
+          cacheEnabled: true,
+        })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.suggestions.length).toBeGreaterThan(0);
+        },
+        { timeout: 1000 }
+      );
+
+      expect(googlePlacesUtils.fetchPlaceAutocomplete).toHaveBeenCalled();
+    });
+
+    it('skips cache when disabled', async () => {
+      const mockPredictions = [{ description: '123 Main St', place_id: 'ChIJ123' }];
+      vi.mocked(googlePlacesUtils.fetchPlaceAutocomplete).mockResolvedValueOnce(mockPredictions);
+
+      const { result } = renderHook(() =>
+        useAddressAutocomplete(mockApiKey, '123 Main', {
+          debounceDelay: 0,
+          cacheEnabled: false,
+        })
+      );
+
+      await waitFor(
+        () => {
+          expect(result.current.suggestions.length).toBeGreaterThan(0);
+        },
+        { timeout: 1000 }
+      );
+
+      expect(googlePlacesUtils.fetchPlaceAutocomplete).toHaveBeenCalled();
+    }, { timeout: 5000 });
+  });
+});
+