@jmruthers/pace-core 0.5.185 → 0.5.187

package/src/hooks/useQueryCache.ts

@@ -0,0 +1,315 @@
+/**
+ * Query Result Caching Hook
+ * @package @jmruthers/pace-core
+ * @module Hooks/QueryCache
+ * @since 2.0.0
+ * 
+ * Provides in-memory caching for frequently accessed data to eliminate duplicate queries.
+ * Useful for caching user profiles, app pages, and other relatively static data.
+ */
+
+import { useCallback, useRef, useEffect } from 'react';
+import { SupabaseClient } from '@supabase/supabase-js';
+import { Database } from '../types/database';
+import { createLogger } from '../utils/core/logger';
+
+const log = createLogger('useQueryCache');
+
+interface CachedQueryEntry<T> {
+  data: T;
+  expiresAt: number; // Unix timestamp
+  promise?: Promise<T>; // For in-flight requests
+}
+
+/**
+ * In-memory cache for query results
+ * Key format: `table:filterKey:filterValue`
+ */
+const queryCache = new Map<string, CachedQueryEntry<any>>();
+
+// Cleanup interval (every 5 minutes)
+const CLEANUP_INTERVAL_MS = 5 * 60 * 1000;
+let cleanupTimer: ReturnType<typeof setInterval> | null = null;
+
+function runCacheCleanup() {
+  const now = Date.now();
+  const expiredKeys: string[] = [];
+  
+  queryCache.forEach((entry, key) => {
+    if (entry.expiresAt <= now) {
+      expiredKeys.push(key);
+    }
+  });
+  
+  expiredKeys.forEach(key => {
+    queryCache.delete(key);
+    log.debug(`Removed expired query from cache: ${key}`);
+  });
+}
+
+// Initialize cleanup timer once
+if (typeof window !== 'undefined' && !cleanupTimer) {
+  cleanupTimer = setInterval(runCacheCleanup, CLEANUP_INTERVAL_MS);
+  log.debug('Query cache cleanup initialized.');
+}
+
+export interface UseQueryCacheOptions {
+  /** Time to live in seconds (default: 300 = 5 minutes) */
+  ttl?: number;
+  /** Whether to enable caching (default: true) */
+  enabled?: boolean;
+}
+
+export interface UseQueryCacheReturn {
+  /** Get cached query result or fetch if not cached */
+  getCachedQuery: <T>(
+    table: string,
+    filterKey: string,
+    filterValue: string,
+    fetchFn: () => Promise<T>,
+    options?: UseQueryCacheOptions
+  ) => Promise<T>;
+  /** Invalidate a specific cached query */
+  invalidateQuery: (table: string, filterKey: string, filterValue: string) => void;
+  /** Clear all cached queries */
+  clearCache: () => void;
+  /** Get cache statistics */
+  getCacheStats: () => { size: number; keys: string[] };
+}
+
+/**
+ * Hook for query result caching
+ * 
+ * Provides caching for frequently accessed data to eliminate duplicate queries.
+ * Automatically handles cache expiration and cleanup.
+ * 
+ * @param supabase - Supabase client (optional, can be passed in fetchFn)
+ * @returns Query cache utilities
+ * 
+ * @example
+ * ```tsx
+ * const { getCachedQuery } = useQueryCache(supabase);
+ * 
+ * const person = await getCachedQuery(
+ *   'pace_person',
+ *   'user_id',
+ *   userId,
+ *   async () => {
+ *     const { data } = await supabase
+ *       .from('pace_person')
+ *       .select('id, first_name, last_name, email')
+ *       .eq('user_id', userId)
+ *       .single();
+ *     return data;
+ *   },
+ *   { ttl: 300 } // 5 minutes
+ * );
+ * ```
+ */
+export function useQueryCache(supabase?: SupabaseClient<Database>): UseQueryCacheReturn {
+  const getCachedQuery = useCallback(async <T,>(
+    table: string,
+    filterKey: string,
+    filterValue: string,
+    fetchFn: () => Promise<T>,
+    options: UseQueryCacheOptions = {}
+  ): Promise<T> => {
+    const { ttl = 300, enabled = true } = options; // Default 5 minutes
+    const cacheKey = `${table}:${filterKey}:${filterValue}`;
+    const now = Date.now();
+    
+    if (!enabled) {
+      return fetchFn();
+    }
+    
+    // Check cache
+    const cached = queryCache.get(cacheKey);
+    if (cached) {
+      // If data is still valid, return it
+      if (cached.expiresAt > now && cached.data !== undefined) {
+        log.debug(`Cache hit for query: ${cacheKey}`);
+        return cached.data as T;
+      }
+      
+      // If there's an in-flight request, wait for it
+      if (cached.promise) {
+        log.debug(`Waiting for in-flight request: ${cacheKey}`);
+        return cached.promise as Promise<T>;
+      }
+    }
+    
+    // Fetch data
+    log.debug(`Cache miss for query: ${cacheKey}, fetching...`);
+    const fetchPromise = fetchFn();
+    
+    // Store promise for in-flight request deduplication
+    queryCache.set(cacheKey, {
+      data: undefined as any,
+      expiresAt: now + (ttl * 1000),
+      promise: fetchPromise,
+    });
+    
+    try {
+      const data = await fetchPromise;
+      
+      // Update cache with actual data
+      queryCache.set(cacheKey, {
+        data,
+        expiresAt: now + (ttl * 1000),
+      });
+      
+      log.debug(`Cached query result: ${cacheKey}, expires in ${ttl}s`);
+      return data;
+    } catch (error) {
+      // Remove failed request from cache
+      queryCache.delete(cacheKey);
+      log.error(`Query failed for ${cacheKey}:`, error);
+      throw error;
+    }
+  }, []);
+  
+  const invalidateQuery = useCallback((table: string, filterKey: string, filterValue: string) => {
+    const cacheKey = `${table}:${filterKey}:${filterValue}`;
+    queryCache.delete(cacheKey);
+    log.debug(`Invalidated query cache: ${cacheKey}`);
+  }, []);
+  
+  const clearCache = useCallback(() => {
+    queryCache.clear();
+    log.debug('Cleared all query cache entries.');
+  }, []);
+  
+  const getCacheStats = useCallback(() => {
+    return {
+      size: queryCache.size,
+      keys: Array.from(queryCache.keys()),
+    };
+  }, []);
+  
+  return {
+    getCachedQuery,
+    invalidateQuery,
+    clearCache,
+    getCacheStats,
+  };
+}
+
+/**
+ * Pre-configured cache helpers for common queries
+ */
+export const queryCacheHelpers = {
+  /**
+   * Cache pace_person queries by user_id
+   * TTL: 5 minutes
+   */
+  pacePersonByUserId: <T>(
+    supabase: SupabaseClient<Database>,
+    userId: string,
+    fetchFn: () => Promise<T>
+  ): Promise<T> => {
+    const cacheKey = `pace_person:user_id:${userId}`;
+    const now = Date.now();
+    const ttl = 300 * 1000; // 5 minutes
+    
+    const cached = queryCache.get(cacheKey);
+    if (cached && cached.expiresAt > now && cached.data !== undefined) {
+      return Promise.resolve(cached.data as T);
+    }
+    
+    if (cached?.promise) {
+      return cached.promise as Promise<T>;
+    }
+    
+    const promise = fetchFn();
+    queryCache.set(cacheKey, {
+      data: undefined as any,
+      expiresAt: now + ttl,
+      promise,
+    });
+    
+    promise.then(data => {
+      queryCache.set(cacheKey, { data, expiresAt: now + ttl });
+    }).catch(() => {
+      queryCache.delete(cacheKey);
+    });
+    
+    return promise;
+  },
+  
+  /**
+   * Cache pace_member queries by person_id
+   * TTL: 5 minutes
+   */
+  paceMemberByPersonId: <T>(
+    supabase: SupabaseClient<Database>,
+    personId: string,
+    fetchFn: () => Promise<T>
+  ): Promise<T> => {
+    const cacheKey = `pace_member:person_id:${personId}`;
+    const now = Date.now();
+    const ttl = 300 * 1000; // 5 minutes
+    
+    const cached = queryCache.get(cacheKey);
+    if (cached && cached.expiresAt > now && cached.data !== undefined) {
+      return Promise.resolve(cached.data as T);
+    }
+    
+    if (cached?.promise) {
+      return cached.promise as Promise<T>;
+    }
+    
+    const promise = fetchFn();
+    queryCache.set(cacheKey, {
+      data: undefined as any,
+      expiresAt: now + ttl,
+      promise,
+    });
+    
+    promise.then(data => {
+      queryCache.set(cacheKey, { data, expiresAt: now + ttl });
+    }).catch(() => {
+      queryCache.delete(cacheKey);
+    });
+    
+    return promise;
+  },
+  
+  /**
+   * Cache rbac_app_pages queries by app_id
+   * TTL: 15 minutes (app pages are relatively static)
+   */
+  rbacAppPagesByAppId: <T>(
+    supabase: SupabaseClient<Database>,
+    appId: string,
+    fetchFn: () => Promise<T>
+  ): Promise<T> => {
+    const cacheKey = `rbac_app_pages:app_id:${appId}`;
+    const now = Date.now();
+    const ttl = 15 * 60 * 1000; // 15 minutes
+    
+    const cached = queryCache.get(cacheKey);
+    if (cached && cached.expiresAt > now && cached.data !== undefined) {
+      return Promise.resolve(cached.data as T);
+    }
+    
+    if (cached?.promise) {
+      return cached.promise as Promise<T>;
+    }
+    
+    const promise = fetchFn();
+    queryCache.set(cacheKey, {
+      data: undefined as any,
+      expiresAt: now + ttl,
+      promise,
+    });
+    
+    promise.then(data => {
+      queryCache.set(cacheKey, { data, expiresAt: now + ttl });
+    }).catch(() => {
+      queryCache.delete(cacheKey);
+    });
+    
+    return promise;
+  },
+};
+

package/src/hooks/useSecureDataAccess.ts

@@ -219,7 +219,7 @@ export function useSecureDataAccess(): SecureDataAccessReturn {
       'cake_meal', 'cake_mealtype', 'pace_person', 'pace_member',
       // SECURITY: Phase 3A additions - medical and personal data
       'medi_profile', 'medi_condition', 'medi_diet', 'medi_action_plan', 'medi_profile_versions',
-      'pace_consent', 'pace_contact', 'pace_id_documents', 'pace_qualifications',
+      'pace_consent', 'pace_contact', 'pace_identification', 'pace_identification_type', 'pace_qualification',
       'form_responses', 'form_response_values', 'forms',
       // SECURITY: Phase 3B additions - remaining critical tables
       'invoice', 'line_item', 'credit_balance', 'payment_method',
@@ -379,7 +379,7 @@ export function useSecureDataAccess(): SecureDataAccessReturn {
       'cake_meal', 'cake_mealtype', 'pace_person', 'pace_member',
       // SECURITY: Phase 3A additions - medical and personal data
       'medi_profile', 'medi_condition', 'medi_diet', 'medi_action_plan', 'medi_profile_versions',
-      'pace_consent', 'pace_contact', 'pace_id_documents', 'pace_qualifications',
+      'pace_consent', 'pace_contact', 'pace_identification', 'pace_identification_type', 'pace_qualification',
       'form_responses', 'form_response_values', 'forms',
       // SECURITY: Phase 3B additions - remaining critical tables
       'invoice', 'line_item', 'credit_balance', 'payment_method',

package/src/index.ts

@@ -76,6 +76,8 @@ export type { CardProps } from './components/Card/Card';
 
 export { Input } from './components/Input/Input';
 export type { InputProps } from './components/Input/Input';
+export { AddressField } from './components/AddressField';
+export type { AddressFieldProps, AddressFieldRef, ParsedAddress, AutocompleteOptions } from './components/AddressField';
 export { Label } from './components/Label/Label';
 export type { LabelProps } from './components/Label/Label';
 

package/src/providers/services/EventServiceProvider.tsx

@@ -50,6 +50,7 @@ export function EventServiceProvider({
   const eventService = eventServiceRef.current;
 
   // Update service dependencies and initialize when dependencies change
+  // Note: eventService is a ref and never changes, so we don't include it in dependencies
   useEffect(() => {
     let isMounted = true;
     
@@ -72,7 +73,9 @@ export function EventServiceProvider({
     return () => {
       isMounted = false;
     };
-  }, [eventService, supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    // eventService is a ref and never changes, so we exclude it from dependencies
+  }, [supabaseClient, user, session, appName, selectedOrganisation, setSelectedEventId]);
 
   // Cleanup service on unmount only
   useEffect(() => {